@event-driven-io/dumbo 0.13.0-beta.35 → 0.13.0-beta.36

package/dist/index-BdWFmDhJ.d.cts

@@ -0,0 +1,68 @@
+import { At as DatabaseLockOptions, Dt as AcquireDatabaseLockMode, Gi as SQL, Jt as SQLExecutor, Mt as ReleaseDatabaseLockOptions, Ot as AcquireDatabaseLockOptions, Qi as DefaultSQLColumnProcessors, Ri as SQLFormatter, Wa as SQLIn, gn as DumboError, i as DatabaseConnectionString, kt as DatabaseLock, ra as SQLProcessor, rt as DatabaseDriverType, xt as MigratorOptions, za as SQLArray } from "./index-BDSQvDH2.cjs";
+
+//#region src/storage/postgresql/core/connections/connectionString.d.ts
+declare const defaultPostgreSQLConnectionString: PostgreSQLConnectionString;
+type PostgreSQLConnectionString = DatabaseConnectionString<'PostgreSQL', `postgresql://${string}` | `postgres://${string}`>;
+declare const PostgreSQLConnectionString: (connectionString: string) => PostgreSQLConnectionString;
+/**
+ * Parse database name from a PostgreSQL connection string
+ */
+declare function parseDatabaseName(str: string): string | null;
+//#endregion
+//#region src/storage/postgresql/core/errors/errorMapper.d.ts
+/**
+ * Maps a PostgreSQL error (from the `pg` driver) to a typed DumboError
+ * based on the SQLSTATE code.
+ *
+ * SQLSTATE reference: https://www.postgresql.org/docs/current/errcodes-appendix.html
+ * Transient classification based on Npgsql's PostgresException.IsTransient.
+ *
+ * Falls back to a generic DumboError (500) if the error is not a recognized PostgreSQL error.
+ */
+declare const mapPostgresError: (error: unknown) => DumboError;
+//#endregion
+//#region src/storage/postgresql/core/locks/advisoryLocks.d.ts
+declare const tryAcquireAdvisoryLock: (execute: SQLExecutor, options: AcquireDatabaseLockOptions) => Promise<boolean>;
+declare const releaseAdvisoryLock: (execute: SQLExecutor, options: ReleaseDatabaseLockOptions) => Promise<boolean>;
+declare const acquireAdvisoryLock: (execute: SQLExecutor, options: AcquireDatabaseLockOptions) => Promise<void>;
+declare const AdvisoryLock: DatabaseLock;
+declare const advisoryLock: (execute: SQLExecutor, options: DatabaseLockOptions) => {
+  acquire: (acquireOptions?: {
+    mode: AcquireDatabaseLockMode;
+  }) => Promise<void>;
+  tryAcquire: (acquireOptions?: {
+    mode: AcquireDatabaseLockMode;
+  }) => Promise<boolean>;
+  release: () => Promise<boolean>;
+  withAcquire: <Result>(handle: () => Promise<Result>, acquireOptions?: {
+    mode: AcquireDatabaseLockMode;
+  }) => Promise<Result>;
+};
+//#endregion
+//#region src/storage/postgresql/core/schema/migrations.d.ts
+declare const DefaultPostgreSQLMigratorOptions: MigratorOptions;
+//#endregion
+//#region src/storage/postgresql/core/schema/schema.d.ts
+declare const defaultPostgreSqlDatabase = "postgres";
+declare const tableExistsSQL: (tableName: string) => SQL;
+declare const tableExists: (execute: SQLExecutor, tableName: string) => Promise<boolean>;
+declare const functionExistsSQL: (functionName: string) => SQL;
+declare const functionExists: (execute: SQLExecutor, functionName: string) => Promise<boolean>;
+//#endregion
+//#region src/storage/postgresql/core/sql/formatter/index.d.ts
+declare const pgFormatter: SQLFormatter;
+//#endregion
+//#region src/storage/postgresql/core/sql/processors/arrayProcessors.d.ts
+declare const PostgreSQLArrayProcessor: SQLProcessor<SQLArray>;
+declare const PostgreSQLExpandSQLInProcessor: SQLProcessor<SQLIn>;
+//#endregion
+//#region src/storage/postgresql/core/sql/processors/columProcessors.d.ts
+declare const postgreSQLColumnProcessors: DefaultSQLColumnProcessors;
+//#endregion
+//#region src/storage/postgresql/core/index.d.ts
+type PostgreSQLDatabaseName = 'PostgreSQL';
+declare const PostgreSQLDatabaseName = "PostgreSQL";
+type PostgreSQLDriverType<DriverName extends string = string> = DatabaseDriverType<PostgreSQLDatabaseName, DriverName>;
+//#endregion
+export { tryAcquireAdvisoryLock as _, PostgreSQLExpandSQLInProcessor as a, defaultPostgreSQLConnectionString as b, functionExists as c, tableExistsSQL as d, DefaultPostgreSQLMigratorOptions as f, releaseAdvisoryLock as g, advisoryLock as h, PostgreSQLArrayProcessor as i, functionExistsSQL as l, acquireAdvisoryLock as m, PostgreSQLDriverType as n, pgFormatter as o, AdvisoryLock as p, postgreSQLColumnProcessors as r, defaultPostgreSqlDatabase as s, PostgreSQLDatabaseName as t, tableExists as u, mapPostgresError as v, parseDatabaseName as x, PostgreSQLConnectionString as y };
+//# sourceMappingURL=index-BdWFmDhJ.d.cts.map

package/dist/index-D1jryNqo.d.ts

@@ -0,0 +1,198 @@
+import { D as Connection, E as AnyConnection, F as InferDriverTypeFromConnection, Gt as DbSQLExecutor, I as InferTransactionFromConnection, Jt as SQLExecutor, K as DatabaseTransaction, P as InferDbClientFromConnection, R as InitTransaction, Ri as SQLFormatter, Wt as BatchSQLCommandOptions, co as JSONSerializer, gn as DumboError, i as DatabaseConnectionString, k as ConnectionOptions, p as ConnectionPool, q as DatabaseTransactionOptions, qt as SQLCommandOptions, rt as DatabaseDriverType, xt as MigratorOptions } from "./index-zkszkJqP.js";
+//#region src/storage/sqlite/core/execute/execute.d.ts
+type SQLiteErrorMapper = (error: unknown) => DumboError;
+declare const sqliteExecute: <Result = void>(database: SQLiteClient, handle: (client: SQLiteClient) => Promise<Result>) => Promise<Result>;
+type SQLiteSQLExecutor<DriverType extends SQLiteDriverType = SQLiteDriverType> = DbSQLExecutor<DriverType, SQLiteClient>;
+declare const sqliteSQLExecutor: <DriverType extends SQLiteDriverType = SQLiteDriverType>(driverType: DriverType, serializer: JSONSerializer, formatter?: SQLFormatter, errorMapper?: SQLiteErrorMapper) => SQLiteSQLExecutor<DriverType>;
+//#endregion
+//#region src/storage/sqlite/core/transactions/index.d.ts
+type SQLiteTransaction<ConnectionType extends AnySQLiteConnection = AnySQLiteConnection, TransactionOptions extends SQLiteTransactionOptions = SQLiteTransactionOptions> = DatabaseTransaction<ConnectionType, TransactionOptions>;
+type SQLiteTransactionMode = 'DEFERRED' | 'IMMEDIATE' | 'EXCLUSIVE';
+type SQLiteTransactionOptions = DatabaseTransactionOptions & {
+  mode?: SQLiteTransactionMode;
+  useSavepoints?: boolean;
+};
+declare const sqliteTransaction: <ConnectionType extends AnySQLiteConnection = AnySQLiteConnection>(driverType: ConnectionType["driverType"], connection: () => ConnectionType, allowNestedTransactions: boolean, serializer: JSONSerializer, defaultTransactionMode?: "IMMEDIATE" | "DEFERRED" | "EXCLUSIVE") => (getClient: Promise<InferDbClientFromConnection<ConnectionType>>, options?: {
+  close: (client: InferDbClientFromConnection<ConnectionType>, error?: unknown) => Promise<void>;
+} & SQLiteTransactionOptions) => InferTransactionFromConnection<ConnectionType>;
+//#endregion
+//#region src/storage/sqlite/core/connections/connectionString.d.ts
+type SQLitePragmaOptions = {
+  journal_mode?: 'DELETE' | 'TRUNCATE' | 'PERSIST' | 'MEMORY' | 'WAL' | 'OFF';
+  synchronous?: 'OFF' | 'NORMAL' | 'FULL' | 'EXTRA';
+  cache_size?: number;
+  foreign_keys?: boolean;
+  temp_store?: 'DEFAULT' | 'FILE' | 'MEMORY';
+  busy_timeout?: number;
+  mmap_size?: number;
+};
+type SQLiteConnectionString = DatabaseConnectionString<'SQLite', `file:${string}` | `:memory:` | `/${string}` | `./${string}`>;
+declare const SQLiteConnectionString: (connectionString: string) => SQLiteConnectionString;
+declare const parsePragmasFromConnectionString: (connectionString: string | SQLiteConnectionString) => Partial<SQLitePragmaOptions>;
+//#endregion
+//#region src/storage/sqlite/core/connections/index.d.ts
+type SQLiteCommandOptions = SQLCommandOptions & {
+  ignoreChangesCount?: boolean;
+};
+type BatchSQLiteCommandOptions = SQLiteCommandOptions & BatchSQLCommandOptions;
+type SQLiteParameters = object | string | bigint | number | boolean | null;
+type SQLiteClient = {
+  connect: () => Promise<void>;
+  close: () => Promise<void>;
+} & SQLExecutor;
+type SQLitePoolClient = {
+  release: () => void;
+} & SQLExecutor;
+type SQLiteClientFactory<SQLiteClientType extends SQLiteClient = SQLiteClient, ClientOptions = SQLiteClientOptions> = (options: ClientOptions) => SQLiteClientType;
+type SQLiteClientOrPoolClient = SQLitePoolClient | SQLiteClient;
+interface SQLiteError extends Error {
+  errno: number;
+}
+declare const isSQLiteError: (error: unknown) => error is SQLiteError;
+type SQLiteClientConnection<Self extends AnyConnection = AnyConnection, DriverType extends SQLiteDriverType = SQLiteDriverType, SQLiteClientType extends SQLiteClient = SQLiteClient, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>> = Connection<Self, DriverType, SQLiteClientType, TransactionType>;
+type SQLitePoolClientConnection<Self extends AnyConnection = AnyConnection, DriverType extends SQLiteDriverType = SQLiteDriverType, SQLitePoolClientType extends SQLitePoolClient = SQLitePoolClient, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>> = Connection<Self, DriverType, SQLitePoolClientType, TransactionType>;
+type SQLiteConnection<Self extends AnyConnection = AnyConnection, DriverType extends SQLiteDriverType = SQLiteDriverType, SQLiteClientType extends SQLiteClientOrPoolClient = SQLiteClient | SQLitePoolClient, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>> = (SQLiteClientType extends SQLiteClient ? SQLiteClientConnection<Self, DriverType, SQLiteClientType, TransactionType> : never) | (SQLiteClientType extends SQLitePoolClient ? SQLitePoolClientConnection<Self, DriverType, SQLiteClientType, TransactionType> : never);
+type AnySQLiteClientConnection = SQLiteClientConnection<any, any>;
+type AnySQLitePoolClientConnection = SQLitePoolClientConnection<any, any, any, any>;
+type AnySQLiteConnection = SQLiteConnection<any, any, any, any>;
+type SQLiteConnectionOptions<ConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionOptions<ConnectionType> & SQLiteClientOptions;
+type SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection, ConnectionOptions = SQLiteConnectionOptions> = {
+  driverType: InferDriverTypeFromConnection<SQLiteConnectionType>;
+  type: 'Client';
+  sqliteClientFactory: SQLiteClientFactory<InferDbClientFromConnection<SQLiteConnectionType>, ConnectionOptions>;
+  connectionOptions: SQLiteConnectionOptions<SQLiteConnectionType>;
+  serializer: JSONSerializer;
+};
+type SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLitePoolClientConnection = AnySQLitePoolClientConnection, ConnectionOptions = SQLiteConnectionOptions> = {
+  driverType: InferDriverTypeFromConnection<SQLiteConnectionType>;
+  type: 'PoolClient';
+  sqliteClientFactory: SQLiteClientFactory<InferDbClientFromConnection<SQLiteConnectionType>, ConnectionOptions>;
+  connectionOptions: SQLiteConnectionOptions<SQLiteConnectionType>;
+  serializer: JSONSerializer;
+};
+type SQLiteConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLitePoolClientConnection = AnySQLitePoolClientConnection, ClientOptions = SQLiteClientOptions> = SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions> | SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>;
+type SQLiteConnectionFactory<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = (options: ConnectionOptions) => SQLiteConnectionType;
+type TransactionNestingCounter = {
+  increment: () => void;
+  decrement: () => void;
+  reset: () => void;
+  level: number;
+};
+declare const transactionNestingCounter: () => TransactionNestingCounter;
+type SqliteAmbientClientConnectionOptions<SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection> = {
+  driverType: SQLiteConnectionType['driverType'];
+  client: InferDbClientFromConnection<SQLiteConnectionType>;
+  initTransaction?: InitTransaction<SQLiteConnectionType>;
+  allowNestedTransactions?: boolean;
+  defaultTransactionMode?: SQLiteTransactionMode;
+  serializer: JSONSerializer;
+  errorMapper?: SQLiteErrorMapper;
+};
+declare const sqliteAmbientClientConnection: <SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection>(options: SqliteAmbientClientConnectionOptions<SQLiteConnectionType>) => SQLiteConnectionType;
+declare const sqliteClientConnection: <SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection, ClientOptions = SQLiteClientOptions>(options: SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>) => SQLiteConnectionType;
+declare const sqlitePoolClientConnection: <SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection, ClientOptions = SQLiteClientOptions>(options: SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>) => SQLiteConnectionType;
+declare function sqliteConnection<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ClientOptions = SQLiteClientOptions>(options: SQLiteConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>): SQLiteConnectionType;
+type InMemorySQLiteDatabase = ':memory:';
+declare const InMemorySQLiteDatabase: SQLiteConnectionString;
+declare const DEFAULT_SQLITE_PRAGMA_OPTIONS: SQLitePragmaOptions;
+type SQLiteClientOptions = {
+  pragmaOptions?: Partial<SQLitePragmaOptions>;
+  defaultTransactionMode?: SQLiteTransactionMode;
+  skipDatabasePragmas?: boolean;
+  readonly?: boolean;
+};
+//#endregion
+//#region src/storage/sqlite/core/errors/errorMapper.d.ts
+/**
+ * Maps a SQLite error (from the `sqlite3` / node-sqlite3 driver) to a typed
+ * DumboError based on the SQLite result code.
+ *
+ * Result code reference: https://www.sqlite.org/rescode.html
+ *
+ * Falls back to a generic DumboError (500) if the error is not a recognized SQLite error.
+ */
+declare const mapSqliteError: (error: unknown) => DumboError;
+//#endregion
+//#region src/storage/sqlite/core/pool/dualPool.d.ts
+type SQLiteDualPoolOptions<SQLiteConnectionType extends AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions> = {
+  driverType: SQLiteConnectionType['driverType'];
+  dual?: true;
+  singleton?: false;
+  pooled?: true;
+  connection?: never;
+  readerPoolSize?: number;
+  sqliteConnectionFactory: SQLiteConnectionFactory<SQLiteConnectionType, ConnectionOptions>;
+  connectionOptions?: ConnectionOptions;
+};
+//#endregion
+//#region src/storage/sqlite/core/pool/pool.d.ts
+type SQLiteFileNameOrConnectionString = {
+  fileName: string | SQLiteConnectionString;
+  connectionString?: never;
+} | {
+  connectionString: string | SQLiteConnectionString;
+  fileName?: never;
+};
+declare const isInMemoryDatabase: (options: Record<string, unknown>) => boolean;
+type SQLiteAmbientConnectionPool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionPool<SQLiteConnectionType>;
+type SQLiteAmbientConnectionPoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = {
+  singleton?: true;
+  pooled?: false;
+  sqliteConnectionFactory?: never;
+  connection: SQLiteConnectionType;
+  connectionOptions?: never;
+};
+declare const sqliteAmbientConnectionPool: <SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection>(options: {
+  driverType: SQLiteConnectionType["driverType"];
+} & SQLiteAmbientConnectionPoolOptions<SQLiteConnectionType["driverType"]>) => SQLiteAmbientConnectionPool<SQLiteConnectionType["driverType"]>;
+type SQLiteSingletonConnectionPoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = {
+  singleton: true;
+  pooled?: true;
+  sqliteConnectionFactory: SQLiteConnectionFactory<SQLiteConnectionType, ConnectionOptions>;
+  connection?: never;
+  connectionOptions: ConnectionOptions;
+};
+type SQLiteSingletonConnectionPool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionPool<SQLiteConnectionType>;
+declare const sqliteSingletonConnectionPool: <SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions & Record<string, unknown> = SQLiteConnectionOptions & Record<string, unknown>>(options: {
+  driverType: SQLiteConnectionType["driverType"];
+} & SQLiteSingletonConnectionPoolOptions<SQLiteConnectionType, ConnectionOptions>) => SQLiteSingletonConnectionPool<SQLiteConnectionType>;
+type SQLiteAlwaysNewPoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = {
+  singleton?: false;
+  pooled?: true;
+  sqliteConnectionFactory: SQLiteConnectionFactory<SQLiteConnectionType, ConnectionOptions>;
+  connection?: never;
+  connectionOptions: ConnectionOptions;
+};
+type SQLiteAlwaysNewConnectionPool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionPool<SQLiteConnectionType>;
+declare const sqliteAlwaysNewConnectionPool: <SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions & Record<string, unknown> = SQLiteConnectionOptions & Record<string, unknown>>(options: {
+  driverType: SQLiteConnectionType["driverType"];
+} & SQLiteAlwaysNewPoolOptions<SQLiteConnectionType, ConnectionOptions>) => SQLiteAlwaysNewConnectionPool<SQLiteConnectionType>;
+type SQLitePoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = (SQLiteAlwaysNewPoolOptions<SQLiteConnectionType, ConnectionOptions> | SQLiteSingletonConnectionPoolOptions<SQLiteConnectionType, ConnectionOptions> | SQLiteAmbientConnectionPoolOptions<SQLiteConnectionType> | SQLiteDualPoolOptions<SQLiteConnectionType, ConnectionOptions>) & {
+  driverType: SQLiteConnectionType['driverType'];
+  serializer?: JSONSerializer;
+};
+type SQLitePool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = SQLiteAmbientConnectionPool<SQLiteConnectionType> | SQLiteSingletonConnectionPool<SQLiteConnectionType> | SQLiteAlwaysNewConnectionPool<SQLiteConnectionType>;
+type SQLitePoolFactoryOptions<SQLiteConnectionType extends AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions> = Omit<SQLitePoolOptions<SQLiteConnectionType, ConnectionOptions>, 'singleton'> & {
+  singleton?: boolean;
+};
+declare const toSqlitePoolOptions: <SQLiteConnectionType extends AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions>(options: SQLitePoolFactoryOptions<SQLiteConnectionType, ConnectionOptions>) => SQLitePoolOptions<SQLiteConnectionType, ConnectionOptions>;
+declare function sqlitePool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions>(options: SQLitePoolOptions<SQLiteConnectionType, ConnectionOptions>): SQLitePool<SQLiteConnectionType>;
+//#endregion
+//#region src/storage/sqlite/core/schema/migrations.d.ts
+declare const DefaultSQLiteMigratorOptions: MigratorOptions;
+//#endregion
+//#region src/storage/sqlite/core/schema/schema.d.ts
+declare const defaultSQLiteDatabase = ":memory:";
+declare const tableExists: (execute: SQLExecutor, tableName: string) => Promise<boolean>;
+//#endregion
+//#region src/storage/sqlite/core/sql/formatter/index.d.ts
+declare const sqliteFormatter: SQLFormatter;
+//#endregion
+//#region src/storage/sqlite/core/index.d.ts
+type SQLiteDatabaseName = 'SQLite';
+declare const SQLiteDatabaseName = "SQLite";
+type SQLiteDriverType<DriverName extends string = string> = DatabaseDriverType<SQLiteDatabaseName, DriverName>;
+type SQLiteDatabaseType = 'SQLite';
+//#endregion
+export { SQLitePragmaOptions as $, SQLiteClientConnectionDefinitionOptions as A, SQLiteParameters as B, AnySQLiteConnection as C, InMemorySQLiteDatabase as D, DEFAULT_SQLITE_PRAGMA_OPTIONS as E, SQLiteConnection as F, TransactionNestingCounter as G, SQLitePoolClientConnection as H, SQLiteConnectionDefinitionOptions as I, sqliteClientConnection as J, isSQLiteError as K, SQLiteConnectionFactory as L, SQLiteClientOptions as M, SQLiteClientOrPoolClient as N, SQLiteClient as O, SQLiteCommandOptions as P, SQLiteConnectionString as Q, SQLiteConnectionOptions as R, AnySQLiteClientConnection as S, BatchSQLiteCommandOptions as T, SQLitePoolConnectionDefinitionOptions as U, SQLitePoolClient as V, SqliteAmbientClientConnectionOptions as W, sqlitePoolClientConnection as X, sqliteConnection as Y, transactionNestingCounter as Z, sqliteAmbientConnectionPool as _, defaultSQLiteDatabase as a, SQLiteErrorMapper as at, toSqlitePoolOptions as b, SQLiteAlwaysNewConnectionPool as c, sqliteSQLExecutor as ct, SQLitePool as d, parsePragmasFromConnectionString as et, SQLitePoolFactoryOptions as f, sqliteAlwaysNewConnectionPool as g, isInMemoryDatabase as h, sqliteFormatter as i, sqliteTransaction as it, SQLiteClientFactory as j, SQLiteClientConnection as k, SQLiteAmbientConnectionPool as l, SQLiteSingletonConnectionPool as m, SQLiteDatabaseType as n, SQLiteTransactionMode as nt, tableExists as o, SQLiteSQLExecutor as ot, SQLitePoolOptions as p, sqliteAmbientClientConnection as q, SQLiteDriverType as r, SQLiteTransactionOptions as rt, DefaultSQLiteMigratorOptions as s, sqliteExecute as st, SQLiteDatabaseName as t, SQLiteTransaction as tt, SQLiteFileNameOrConnectionString as u, sqlitePool as v, AnySQLitePoolClientConnection as w, mapSqliteError as x, sqliteSingletonConnectionPool as y, SQLiteError as z };
+//# sourceMappingURL=index-D1jryNqo.d.ts.map

package/dist/index-DaP2fTEX.d.ts

@@ -0,0 +1,67 @@
+import { La as AnySQLToken, ci as AnyTypeValidationError, cn as QueryResult, li as TypeValidationSuccess, ln as QueryResultRow } from "./index-zkszkJqP.js";
+
+//#region src/core/sql/valueMappers/reservedSqlWords.d.ts
+declare const ansiSqlReservedMap: {
+  [key: string]: boolean;
+};
+//#endregion
+//#region src/core/sql/tokenizedSQL/tokenizedSQL.d.ts
+type TokenizedSQL = Readonly<{
+  __brand: 'tokenized-sql';
+  sqlChunks: ReadonlyArray<string>;
+  sqlTokens: ReadonlyArray<AnySQLToken>;
+}>;
+declare const TokenizedSQL: {
+  (strings: ReadonlyArray<string>, values: unknown[]): TokenizedSQL;
+  paramPlaceholder: string;
+  empty: {
+    __brand: "tokenized-sql";
+    sqlChunks: string[];
+    sqlTokens: never[];
+  };
+};
+declare const isTokenizedSQL: (value: unknown) => value is TokenizedSQL;
+//#endregion
+//#region src/core/query/mappers.d.ts
+declare const mapRows: <Result extends QueryResultRow = QueryResultRow, Mapped = unknown>(getResult: Promise<QueryResult<Result>>, map: (row: Result) => Mapped) => Promise<Mapped[]>;
+declare const toCamelCase: (snakeStr: string) => string;
+declare const mapToCamelCase: <T extends Record<string, unknown>>(obj: Record<string, unknown>) => T;
+//#endregion
+//#region src/core/query/selectors.d.ts
+declare const firstOrNull: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result | null>;
+declare const first: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result>;
+declare const singleOrNull: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result | null>;
+declare const single: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result>;
+type CountSQLQueryResult = {
+  count: number;
+};
+declare const count: (getResult: Promise<QueryResult<CountSQLQueryResult>>) => Promise<number>;
+type ExistsSQLQueryResult = {
+  exists: boolean | 1 | 0;
+};
+declare const exists: (getResult: Promise<QueryResult<ExistsSQLQueryResult>>) => Promise<boolean>;
+//#endregion
+//#region src/core/testing/typesTesting.d.ts
+type Expect<T extends true> = T;
+type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type IsError<T> = T extends AnyTypeValidationError ? true : false;
+type IsOK<T> = T extends TypeValidationSuccess ? true : false;
+//#endregion
+//#region src/core/tracing/printing/color.d.ts
+declare const color: {
+  level: 0 | 1;
+  hex: (value: string) => (text: string) => string;
+  red: (value: string) => string;
+  green: (value: string) => string;
+  blue: (value: string) => string;
+  cyan: (value: string) => string;
+  yellow: (value: string) => string;
+};
+//#endregion
+//#region src/core/tracing/printing/pretty.d.ts
+declare const prettyJson: (obj: unknown, options?: {
+  handleMultiline?: boolean;
+}) => string;
+//#endregion
+export { toCamelCase as _, IsError as a, ansiSqlReservedMap as b, ExistsSQLQueryResult as c, first as d, firstOrNull as f, mapToCamelCase as g, mapRows as h, Expect as i, count as l, singleOrNull as m, color as n, IsOK as o, single as p, Equals as r, CountSQLQueryResult as s, prettyJson as t, exists as u, TokenizedSQL as v, isTokenizedSQL as y };
+//# sourceMappingURL=index-DaP2fTEX.d.ts.map

package/dist/index-DqVvUav9.d.cts

@@ -0,0 +1,198 @@
+import { D as Connection, E as AnyConnection, F as InferDriverTypeFromConnection, Gt as DbSQLExecutor, I as InferTransactionFromConnection, Jt as SQLExecutor, K as DatabaseTransaction, P as InferDbClientFromConnection, R as InitTransaction, Ri as SQLFormatter, Wt as BatchSQLCommandOptions, co as JSONSerializer, gn as DumboError, i as DatabaseConnectionString, k as ConnectionOptions, p as ConnectionPool, q as DatabaseTransactionOptions, qt as SQLCommandOptions, rt as DatabaseDriverType, xt as MigratorOptions } from "./index-BDSQvDH2.cjs";
+//#region src/storage/sqlite/core/execute/execute.d.ts
+type SQLiteErrorMapper = (error: unknown) => DumboError;
+declare const sqliteExecute: <Result = void>(database: SQLiteClient, handle: (client: SQLiteClient) => Promise<Result>) => Promise<Result>;
+type SQLiteSQLExecutor<DriverType extends SQLiteDriverType = SQLiteDriverType> = DbSQLExecutor<DriverType, SQLiteClient>;
+declare const sqliteSQLExecutor: <DriverType extends SQLiteDriverType = SQLiteDriverType>(driverType: DriverType, serializer: JSONSerializer, formatter?: SQLFormatter, errorMapper?: SQLiteErrorMapper) => SQLiteSQLExecutor<DriverType>;
+//#endregion
+//#region src/storage/sqlite/core/transactions/index.d.ts
+type SQLiteTransaction<ConnectionType extends AnySQLiteConnection = AnySQLiteConnection, TransactionOptions extends SQLiteTransactionOptions = SQLiteTransactionOptions> = DatabaseTransaction<ConnectionType, TransactionOptions>;
+type SQLiteTransactionMode = 'DEFERRED' | 'IMMEDIATE' | 'EXCLUSIVE';
+type SQLiteTransactionOptions = DatabaseTransactionOptions & {
+  mode?: SQLiteTransactionMode;
+  useSavepoints?: boolean;
+};
+declare const sqliteTransaction: <ConnectionType extends AnySQLiteConnection = AnySQLiteConnection>(driverType: ConnectionType["driverType"], connection: () => ConnectionType, allowNestedTransactions: boolean, serializer: JSONSerializer, defaultTransactionMode?: "IMMEDIATE" | "DEFERRED" | "EXCLUSIVE") => (getClient: Promise<InferDbClientFromConnection<ConnectionType>>, options?: {
+  close: (client: InferDbClientFromConnection<ConnectionType>, error?: unknown) => Promise<void>;
+} & SQLiteTransactionOptions) => InferTransactionFromConnection<ConnectionType>;
+//#endregion
+//#region src/storage/sqlite/core/connections/connectionString.d.ts
+type SQLitePragmaOptions = {
+  journal_mode?: 'DELETE' | 'TRUNCATE' | 'PERSIST' | 'MEMORY' | 'WAL' | 'OFF';
+  synchronous?: 'OFF' | 'NORMAL' | 'FULL' | 'EXTRA';
+  cache_size?: number;
+  foreign_keys?: boolean;
+  temp_store?: 'DEFAULT' | 'FILE' | 'MEMORY';
+  busy_timeout?: number;
+  mmap_size?: number;
+};
+type SQLiteConnectionString = DatabaseConnectionString<'SQLite', `file:${string}` | `:memory:` | `/${string}` | `./${string}`>;
+declare const SQLiteConnectionString: (connectionString: string) => SQLiteConnectionString;
+declare const parsePragmasFromConnectionString: (connectionString: string | SQLiteConnectionString) => Partial<SQLitePragmaOptions>;
+//#endregion
+//#region src/storage/sqlite/core/connections/index.d.ts
+type SQLiteCommandOptions = SQLCommandOptions & {
+  ignoreChangesCount?: boolean;
+};
+type BatchSQLiteCommandOptions = SQLiteCommandOptions & BatchSQLCommandOptions;
+type SQLiteParameters = object | string | bigint | number | boolean | null;
+type SQLiteClient = {
+  connect: () => Promise<void>;
+  close: () => Promise<void>;
+} & SQLExecutor;
+type SQLitePoolClient = {
+  release: () => void;
+} & SQLExecutor;
+type SQLiteClientFactory<SQLiteClientType extends SQLiteClient = SQLiteClient, ClientOptions = SQLiteClientOptions> = (options: ClientOptions) => SQLiteClientType;
+type SQLiteClientOrPoolClient = SQLitePoolClient | SQLiteClient;
+interface SQLiteError extends Error {
+  errno: number;
+}
+declare const isSQLiteError: (error: unknown) => error is SQLiteError;
+type SQLiteClientConnection<Self extends AnyConnection = AnyConnection, DriverType extends SQLiteDriverType = SQLiteDriverType, SQLiteClientType extends SQLiteClient = SQLiteClient, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>> = Connection<Self, DriverType, SQLiteClientType, TransactionType>;
+type SQLitePoolClientConnection<Self extends AnyConnection = AnyConnection, DriverType extends SQLiteDriverType = SQLiteDriverType, SQLitePoolClientType extends SQLitePoolClient = SQLitePoolClient, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>> = Connection<Self, DriverType, SQLitePoolClientType, TransactionType>;
+type SQLiteConnection<Self extends AnyConnection = AnyConnection, DriverType extends SQLiteDriverType = SQLiteDriverType, SQLiteClientType extends SQLiteClientOrPoolClient = SQLiteClient | SQLitePoolClient, TransactionType extends DatabaseTransaction<Self> = DatabaseTransaction<Self>> = (SQLiteClientType extends SQLiteClient ? SQLiteClientConnection<Self, DriverType, SQLiteClientType, TransactionType> : never) | (SQLiteClientType extends SQLitePoolClient ? SQLitePoolClientConnection<Self, DriverType, SQLiteClientType, TransactionType> : never);
+type AnySQLiteClientConnection = SQLiteClientConnection<any, any>;
+type AnySQLitePoolClientConnection = SQLitePoolClientConnection<any, any, any, any>;
+type AnySQLiteConnection = SQLiteConnection<any, any, any, any>;
+type SQLiteConnectionOptions<ConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionOptions<ConnectionType> & SQLiteClientOptions;
+type SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection, ConnectionOptions = SQLiteConnectionOptions> = {
+  driverType: InferDriverTypeFromConnection<SQLiteConnectionType>;
+  type: 'Client';
+  sqliteClientFactory: SQLiteClientFactory<InferDbClientFromConnection<SQLiteConnectionType>, ConnectionOptions>;
+  connectionOptions: SQLiteConnectionOptions<SQLiteConnectionType>;
+  serializer: JSONSerializer;
+};
+type SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLitePoolClientConnection = AnySQLitePoolClientConnection, ConnectionOptions = SQLiteConnectionOptions> = {
+  driverType: InferDriverTypeFromConnection<SQLiteConnectionType>;
+  type: 'PoolClient';
+  sqliteClientFactory: SQLiteClientFactory<InferDbClientFromConnection<SQLiteConnectionType>, ConnectionOptions>;
+  connectionOptions: SQLiteConnectionOptions<SQLiteConnectionType>;
+  serializer: JSONSerializer;
+};
+type SQLiteConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLitePoolClientConnection = AnySQLitePoolClientConnection, ClientOptions = SQLiteClientOptions> = SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions> | SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>;
+type SQLiteConnectionFactory<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = (options: ConnectionOptions) => SQLiteConnectionType;
+type TransactionNestingCounter = {
+  increment: () => void;
+  decrement: () => void;
+  reset: () => void;
+  level: number;
+};
+declare const transactionNestingCounter: () => TransactionNestingCounter;
+type SqliteAmbientClientConnectionOptions<SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection> = {
+  driverType: SQLiteConnectionType['driverType'];
+  client: InferDbClientFromConnection<SQLiteConnectionType>;
+  initTransaction?: InitTransaction<SQLiteConnectionType>;
+  allowNestedTransactions?: boolean;
+  defaultTransactionMode?: SQLiteTransactionMode;
+  serializer: JSONSerializer;
+  errorMapper?: SQLiteErrorMapper;
+};
+declare const sqliteAmbientClientConnection: <SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection>(options: SqliteAmbientClientConnectionOptions<SQLiteConnectionType>) => SQLiteConnectionType;
+declare const sqliteClientConnection: <SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection, ClientOptions = SQLiteClientOptions>(options: SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>) => SQLiteConnectionType;
+declare const sqlitePoolClientConnection: <SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection, ClientOptions = SQLiteClientOptions>(options: SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>) => SQLiteConnectionType;
+declare function sqliteConnection<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ClientOptions = SQLiteClientOptions>(options: SQLiteConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>): SQLiteConnectionType;
+type InMemorySQLiteDatabase = ':memory:';
+declare const InMemorySQLiteDatabase: SQLiteConnectionString;
+declare const DEFAULT_SQLITE_PRAGMA_OPTIONS: SQLitePragmaOptions;
+type SQLiteClientOptions = {
+  pragmaOptions?: Partial<SQLitePragmaOptions>;
+  defaultTransactionMode?: SQLiteTransactionMode;
+  skipDatabasePragmas?: boolean;
+  readonly?: boolean;
+};
+//#endregion
+//#region src/storage/sqlite/core/errors/errorMapper.d.ts
+/**
+ * Maps a SQLite error (from the `sqlite3` / node-sqlite3 driver) to a typed
+ * DumboError based on the SQLite result code.
+ *
+ * Result code reference: https://www.sqlite.org/rescode.html
+ *
+ * Falls back to a generic DumboError (500) if the error is not a recognized SQLite error.
+ */
+declare const mapSqliteError: (error: unknown) => DumboError;
+//#endregion
+//#region src/storage/sqlite/core/pool/dualPool.d.ts
+type SQLiteDualPoolOptions<SQLiteConnectionType extends AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions> = {
+  driverType: SQLiteConnectionType['driverType'];
+  dual?: true;
+  singleton?: false;
+  pooled?: true;
+  connection?: never;
+  readerPoolSize?: number;
+  sqliteConnectionFactory: SQLiteConnectionFactory<SQLiteConnectionType, ConnectionOptions>;
+  connectionOptions?: ConnectionOptions;
+};
+//#endregion
+//#region src/storage/sqlite/core/pool/pool.d.ts
+type SQLiteFileNameOrConnectionString = {
+  fileName: string | SQLiteConnectionString;
+  connectionString?: never;
+} | {
+  connectionString: string | SQLiteConnectionString;
+  fileName?: never;
+};
+declare const isInMemoryDatabase: (options: Record<string, unknown>) => boolean;
+type SQLiteAmbientConnectionPool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionPool<SQLiteConnectionType>;
+type SQLiteAmbientConnectionPoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = {
+  singleton?: true;
+  pooled?: false;
+  sqliteConnectionFactory?: never;
+  connection: SQLiteConnectionType;
+  connectionOptions?: never;
+};
+declare const sqliteAmbientConnectionPool: <SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection>(options: {
+  driverType: SQLiteConnectionType["driverType"];
+} & SQLiteAmbientConnectionPoolOptions<SQLiteConnectionType["driverType"]>) => SQLiteAmbientConnectionPool<SQLiteConnectionType["driverType"]>;
+type SQLiteSingletonConnectionPoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = {
+  singleton: true;
+  pooled?: true;
+  sqliteConnectionFactory: SQLiteConnectionFactory<SQLiteConnectionType, ConnectionOptions>;
+  connection?: never;
+  connectionOptions: ConnectionOptions;
+};
+type SQLiteSingletonConnectionPool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionPool<SQLiteConnectionType>;
+declare const sqliteSingletonConnectionPool: <SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions & Record<string, unknown> = SQLiteConnectionOptions & Record<string, unknown>>(options: {
+  driverType: SQLiteConnectionType["driverType"];
+} & SQLiteSingletonConnectionPoolOptions<SQLiteConnectionType, ConnectionOptions>) => SQLiteSingletonConnectionPool<SQLiteConnectionType>;
+type SQLiteAlwaysNewPoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = {
+  singleton?: false;
+  pooled?: true;
+  sqliteConnectionFactory: SQLiteConnectionFactory<SQLiteConnectionType, ConnectionOptions>;
+  connection?: never;
+  connectionOptions: ConnectionOptions;
+};
+type SQLiteAlwaysNewConnectionPool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = ConnectionPool<SQLiteConnectionType>;
+declare const sqliteAlwaysNewConnectionPool: <SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions & Record<string, unknown> = SQLiteConnectionOptions & Record<string, unknown>>(options: {
+  driverType: SQLiteConnectionType["driverType"];
+} & SQLiteAlwaysNewPoolOptions<SQLiteConnectionType, ConnectionOptions>) => SQLiteAlwaysNewConnectionPool<SQLiteConnectionType>;
+type SQLitePoolOptions<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = (SQLiteAlwaysNewPoolOptions<SQLiteConnectionType, ConnectionOptions> | SQLiteSingletonConnectionPoolOptions<SQLiteConnectionType, ConnectionOptions> | SQLiteAmbientConnectionPoolOptions<SQLiteConnectionType> | SQLiteDualPoolOptions<SQLiteConnectionType, ConnectionOptions>) & {
+  driverType: SQLiteConnectionType['driverType'];
+  serializer?: JSONSerializer;
+};
+type SQLitePool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection> = SQLiteAmbientConnectionPool<SQLiteConnectionType> | SQLiteSingletonConnectionPool<SQLiteConnectionType> | SQLiteAlwaysNewConnectionPool<SQLiteConnectionType>;
+type SQLitePoolFactoryOptions<SQLiteConnectionType extends AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions> = Omit<SQLitePoolOptions<SQLiteConnectionType, ConnectionOptions>, 'singleton'> & {
+  singleton?: boolean;
+};
+declare const toSqlitePoolOptions: <SQLiteConnectionType extends AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions>(options: SQLitePoolFactoryOptions<SQLiteConnectionType, ConnectionOptions>) => SQLitePoolOptions<SQLiteConnectionType, ConnectionOptions>;
+declare function sqlitePool<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions>(options: SQLitePoolOptions<SQLiteConnectionType, ConnectionOptions>): SQLitePool<SQLiteConnectionType>;
+//#endregion
+//#region src/storage/sqlite/core/schema/migrations.d.ts
+declare const DefaultSQLiteMigratorOptions: MigratorOptions;
+//#endregion
+//#region src/storage/sqlite/core/schema/schema.d.ts
+declare const defaultSQLiteDatabase = ":memory:";
+declare const tableExists: (execute: SQLExecutor, tableName: string) => Promise<boolean>;
+//#endregion
+//#region src/storage/sqlite/core/sql/formatter/index.d.ts
+declare const sqliteFormatter: SQLFormatter;
+//#endregion
+//#region src/storage/sqlite/core/index.d.ts
+type SQLiteDatabaseName = 'SQLite';
+declare const SQLiteDatabaseName = "SQLite";
+type SQLiteDriverType<DriverName extends string = string> = DatabaseDriverType<SQLiteDatabaseName, DriverName>;
+type SQLiteDatabaseType = 'SQLite';
+//#endregion
+export { SQLitePragmaOptions as $, SQLiteClientConnectionDefinitionOptions as A, SQLiteParameters as B, AnySQLiteConnection as C, InMemorySQLiteDatabase as D, DEFAULT_SQLITE_PRAGMA_OPTIONS as E, SQLiteConnection as F, TransactionNestingCounter as G, SQLitePoolClientConnection as H, SQLiteConnectionDefinitionOptions as I, sqliteClientConnection as J, isSQLiteError as K, SQLiteConnectionFactory as L, SQLiteClientOptions as M, SQLiteClientOrPoolClient as N, SQLiteClient as O, SQLiteCommandOptions as P, SQLiteConnectionString as Q, SQLiteConnectionOptions as R, AnySQLiteClientConnection as S, BatchSQLiteCommandOptions as T, SQLitePoolConnectionDefinitionOptions as U, SQLitePoolClient as V, SqliteAmbientClientConnectionOptions as W, sqlitePoolClientConnection as X, sqliteConnection as Y, transactionNestingCounter as Z, sqliteAmbientConnectionPool as _, defaultSQLiteDatabase as a, SQLiteErrorMapper as at, toSqlitePoolOptions as b, SQLiteAlwaysNewConnectionPool as c, sqliteSQLExecutor as ct, SQLitePool as d, parsePragmasFromConnectionString as et, SQLitePoolFactoryOptions as f, sqliteAlwaysNewConnectionPool as g, isInMemoryDatabase as h, sqliteFormatter as i, sqliteTransaction as it, SQLiteClientFactory as j, SQLiteClientConnection as k, SQLiteAmbientConnectionPool as l, SQLiteSingletonConnectionPool as m, SQLiteDatabaseType as n, SQLiteTransactionMode as nt, tableExists as o, SQLiteSQLExecutor as ot, SQLitePoolOptions as p, sqliteAmbientClientConnection as q, SQLiteDriverType as r, SQLiteTransactionOptions as rt, DefaultSQLiteMigratorOptions as s, sqliteExecute as st, SQLiteDatabaseName as t, SQLiteTransaction as tt, SQLiteFileNameOrConnectionString as u, sqlitePool as v, AnySQLitePoolClientConnection as w, mapSqliteError as x, sqliteSingletonConnectionPool as y, SQLiteError as z };
+//# sourceMappingURL=index-DqVvUav9.d.cts.map

package/dist/index-S_wp0Eaf.d.cts

@@ -0,0 +1,67 @@
+import { La as AnySQLToken, ci as AnyTypeValidationError, cn as QueryResult, li as TypeValidationSuccess, ln as QueryResultRow } from "./index-BDSQvDH2.cjs";
+
+//#region src/core/sql/valueMappers/reservedSqlWords.d.ts
+declare const ansiSqlReservedMap: {
+  [key: string]: boolean;
+};
+//#endregion
+//#region src/core/sql/tokenizedSQL/tokenizedSQL.d.ts
+type TokenizedSQL = Readonly<{
+  __brand: 'tokenized-sql';
+  sqlChunks: ReadonlyArray<string>;
+  sqlTokens: ReadonlyArray<AnySQLToken>;
+}>;
+declare const TokenizedSQL: {
+  (strings: ReadonlyArray<string>, values: unknown[]): TokenizedSQL;
+  paramPlaceholder: string;
+  empty: {
+    __brand: "tokenized-sql";
+    sqlChunks: string[];
+    sqlTokens: never[];
+  };
+};
+declare const isTokenizedSQL: (value: unknown) => value is TokenizedSQL;
+//#endregion
+//#region src/core/query/mappers.d.ts
+declare const mapRows: <Result extends QueryResultRow = QueryResultRow, Mapped = unknown>(getResult: Promise<QueryResult<Result>>, map: (row: Result) => Mapped) => Promise<Mapped[]>;
+declare const toCamelCase: (snakeStr: string) => string;
+declare const mapToCamelCase: <T extends Record<string, unknown>>(obj: Record<string, unknown>) => T;
+//#endregion
+//#region src/core/query/selectors.d.ts
+declare const firstOrNull: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result | null>;
+declare const first: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result>;
+declare const singleOrNull: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result | null>;
+declare const single: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result>;
+type CountSQLQueryResult = {
+  count: number;
+};
+declare const count: (getResult: Promise<QueryResult<CountSQLQueryResult>>) => Promise<number>;
+type ExistsSQLQueryResult = {
+  exists: boolean | 1 | 0;
+};
+declare const exists: (getResult: Promise<QueryResult<ExistsSQLQueryResult>>) => Promise<boolean>;
+//#endregion
+//#region src/core/testing/typesTesting.d.ts
+type Expect<T extends true> = T;
+type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type IsError<T> = T extends AnyTypeValidationError ? true : false;
+type IsOK<T> = T extends TypeValidationSuccess ? true : false;
+//#endregion
+//#region src/core/tracing/printing/color.d.ts
+declare const color: {
+  level: 0 | 1;
+  hex: (value: string) => (text: string) => string;
+  red: (value: string) => string;
+  green: (value: string) => string;
+  blue: (value: string) => string;
+  cyan: (value: string) => string;
+  yellow: (value: string) => string;
+};
+//#endregion
+//#region src/core/tracing/printing/pretty.d.ts
+declare const prettyJson: (obj: unknown, options?: {
+  handleMultiline?: boolean;
+}) => string;
+//#endregion
+export { toCamelCase as _, IsError as a, ansiSqlReservedMap as b, ExistsSQLQueryResult as c, first as d, firstOrNull as f, mapToCamelCase as g, mapRows as h, Expect as i, count as l, singleOrNull as m, color as n, IsOK as o, single as p, Equals as r, CountSQLQueryResult as s, prettyJson as t, exists as u, TokenizedSQL as v, isTokenizedSQL as y };
+//# sourceMappingURL=index-S_wp0Eaf.d.cts.map