@erfanium/drizzle-orm 1.0.0 → 1.0.1

package/cache/upstash/cache.d.cts

@@ -1,68 +1,59 @@
-import { CacheConfig } from "../core/types.cjs";
-import { entityKind } from "../../entity.cjs";
-import { Cache, MutationOption } from "../core/index.cjs";
-import { Redis } from "@upstash/redis";
-
-//#region src/cache/upstash/cache.d.ts
-declare class UpstashCache extends Cache {
-  redis: Redis;
-  protected useGlobally?: boolean | undefined;
-  static readonly [entityKind]: string;
-  /**
-   * Prefix for sets which denote the composite table names for each unique table
-   *
-   * Example: In the composite table set of "table1", you may find
-   * `${compositeTablePrefix}table1,table2` and `${compositeTablePrefix}table1,table3`
-   */
-  private static compositeTableSetPrefix;
-  /**
-   * Prefix for hashes which map hash or tags to cache values
-   */
-  private static compositeTablePrefix;
-  /**
-   * Key which holds the mapping of tags to composite table names
-   *
-   * Using this tagsMapKey, you can find the composite table name for a given tag
-   * and get the cache value for that tag:
-   *
-   * ```ts
-   * const compositeTable = redis.hget(tagsMapKey, 'tag1')
-   * console.log(compositeTable) // `${compositeTablePrefix}table1,table2`
-   *
-   * const cachevalue = redis.hget(compositeTable, 'tag1')
-   */
-  private static tagsMapKey;
-  /**
-   * Queries whose auto invalidation is false aren't stored in their respective
-   * composite table hashes because those hashes are deleted when a mutation
-   * occurs on related tables.
-   *
-   * Instead, they are stored in a separate hash with the prefix
-   * `__nonAutoInvalidate__` to prevent them from being deleted when a mutation
-   */
-  private static nonAutoInvalidateTablePrefix;
-  private luaScripts;
-  private internalConfig;
-  constructor(redis: Redis, config?: CacheConfig, useGlobally?: boolean | undefined);
-  strategy(): "all" | "explicit";
-  private toInternalConfig;
-  get(key: string, tables: string[], isTag?: boolean, isAutoInvalidate?: boolean): Promise<any[] | undefined>;
-  put(key: string, response: any, tables: string[], isTag?: boolean, config?: CacheConfig): Promise<void>;
-  onMutate(params: MutationOption): Promise<void>;
-  private addTablePrefix;
-  private getCompositeKey;
+import { Redis } from '@upstash/redis';
+import type { MutationOption } from '../core/index.cjs';
+import { Cache } from '../core/index.cjs';
+import { entityKind } from '../../entity.cjs';
+import type { CacheConfig } from '../core/types.cjs';
+export declare class UpstashCache extends Cache {
+    redis: Redis;
+    protected useGlobally?: boolean | undefined;
+    static readonly [entityKind]: string;
+    /**
+     * Prefix for sets which denote the composite table names for each unique table
+     *
+     * Example: In the composite table set of "table1", you may find
+     * `${compositeTablePrefix}table1,table2` and `${compositeTablePrefix}table1,table3`
+     */
+    private static compositeTableSetPrefix;
+    /**
+     * Prefix for hashes which map hash or tags to cache values
+     */
+    private static compositeTablePrefix;
+    /**
+     * Key which holds the mapping of tags to composite table names
+     *
+     * Using this tagsMapKey, you can find the composite table name for a given tag
+     * and get the cache value for that tag:
+     *
+     * ```ts
+     * const compositeTable = redis.hget(tagsMapKey, 'tag1')
+     * console.log(compositeTable) // `${compositeTablePrefix}table1,table2`
+     *
+     * const cachevalue = redis.hget(compositeTable, 'tag1')
+     */
+    private static tagsMapKey;
+    /**
+     * Queries whose auto invalidation is false aren't stored in their respective
+     * composite table hashes because those hashes are deleted when a mutation
+     * occurs on related tables.
+     *
+     * Instead, they are stored in a separate hash with the prefix
+     * `__nonAutoInvalidate__` to prevent them from being deleted when a mutation
+     */
+    private static nonAutoInvalidateTablePrefix;
+    private luaScripts;
+    private internalConfig;
+    constructor(redis: Redis, config?: CacheConfig, useGlobally?: boolean | undefined);
+    strategy(): "explicit" | "all";
+    private toInternalConfig;
+    get(key: string, tables: string[], isTag?: boolean, isAutoInvalidate?: boolean): Promise<any[] | undefined>;
+    put(key: string, response: any, tables: string[], isTag?: boolean, config?: CacheConfig): Promise<void>;
+    onMutate(params: MutationOption): Promise<void>;
+    private addTablePrefix;
+    private getCompositeKey;
 }
-declare function upstashCache({
-  url,
-  token,
-  config,
-  global
-}: {
-  url: string;
-  token: string;
-  config?: CacheConfig;
-  global?: boolean;
+export declare function upstashCache({ url, token, config, global }: {
+    url: string;
+    token: string;
+    config?: CacheConfig;
+    global?: boolean;
 }): UpstashCache;
-//#endregion
-export { UpstashCache, upstashCache };
-//# sourceMappingURL=cache.d.cts.map

package/cache/upstash/cache.d.ts

@@ -1,68 +1,59 @@
-import { CacheConfig } from "../core/types.js";
-import { entityKind } from "../../entity.js";
-import { Cache, MutationOption } from "../core/index.js";
-import { Redis } from "@upstash/redis";
-
-//#region src/cache/upstash/cache.d.ts
-declare class UpstashCache extends Cache {
-  redis: Redis;
-  protected useGlobally?: boolean | undefined;
-  static readonly [entityKind]: string;
-  /**
-   * Prefix for sets which denote the composite table names for each unique table
-   *
-   * Example: In the composite table set of "table1", you may find
-   * `${compositeTablePrefix}table1,table2` and `${compositeTablePrefix}table1,table3`
-   */
-  private static compositeTableSetPrefix;
-  /**
-   * Prefix for hashes which map hash or tags to cache values
-   */
-  private static compositeTablePrefix;
-  /**
-   * Key which holds the mapping of tags to composite table names
-   *
-   * Using this tagsMapKey, you can find the composite table name for a given tag
-   * and get the cache value for that tag:
-   *
-   * ```ts
-   * const compositeTable = redis.hget(tagsMapKey, 'tag1')
-   * console.log(compositeTable) // `${compositeTablePrefix}table1,table2`
-   *
-   * const cachevalue = redis.hget(compositeTable, 'tag1')
-   */
-  private static tagsMapKey;
-  /**
-   * Queries whose auto invalidation is false aren't stored in their respective
-   * composite table hashes because those hashes are deleted when a mutation
-   * occurs on related tables.
-   *
-   * Instead, they are stored in a separate hash with the prefix
-   * `__nonAutoInvalidate__` to prevent them from being deleted when a mutation
-   */
-  private static nonAutoInvalidateTablePrefix;
-  private luaScripts;
-  private internalConfig;
-  constructor(redis: Redis, config?: CacheConfig, useGlobally?: boolean | undefined);
-  strategy(): "all" | "explicit";
-  private toInternalConfig;
-  get(key: string, tables: string[], isTag?: boolean, isAutoInvalidate?: boolean): Promise<any[] | undefined>;
-  put(key: string, response: any, tables: string[], isTag?: boolean, config?: CacheConfig): Promise<void>;
-  onMutate(params: MutationOption): Promise<void>;
-  private addTablePrefix;
-  private getCompositeKey;
+import { Redis } from '@upstash/redis';
+import type { MutationOption } from '../core/index.js';
+import { Cache } from '../core/index.js';
+import { entityKind } from '../../entity.js';
+import type { CacheConfig } from '../core/types.js';
+export declare class UpstashCache extends Cache {
+    redis: Redis;
+    protected useGlobally?: boolean | undefined;
+    static readonly [entityKind]: string;
+    /**
+     * Prefix for sets which denote the composite table names for each unique table
+     *
+     * Example: In the composite table set of "table1", you may find
+     * `${compositeTablePrefix}table1,table2` and `${compositeTablePrefix}table1,table3`
+     */
+    private static compositeTableSetPrefix;
+    /**
+     * Prefix for hashes which map hash or tags to cache values
+     */
+    private static compositeTablePrefix;
+    /**
+     * Key which holds the mapping of tags to composite table names
+     *
+     * Using this tagsMapKey, you can find the composite table name for a given tag
+     * and get the cache value for that tag:
+     *
+     * ```ts
+     * const compositeTable = redis.hget(tagsMapKey, 'tag1')
+     * console.log(compositeTable) // `${compositeTablePrefix}table1,table2`
+     *
+     * const cachevalue = redis.hget(compositeTable, 'tag1')
+     */
+    private static tagsMapKey;
+    /**
+     * Queries whose auto invalidation is false aren't stored in their respective
+     * composite table hashes because those hashes are deleted when a mutation
+     * occurs on related tables.
+     *
+     * Instead, they are stored in a separate hash with the prefix
+     * `__nonAutoInvalidate__` to prevent them from being deleted when a mutation
+     */
+    private static nonAutoInvalidateTablePrefix;
+    private luaScripts;
+    private internalConfig;
+    constructor(redis: Redis, config?: CacheConfig, useGlobally?: boolean | undefined);
+    strategy(): "explicit" | "all";
+    private toInternalConfig;
+    get(key: string, tables: string[], isTag?: boolean, isAutoInvalidate?: boolean): Promise<any[] | undefined>;
+    put(key: string, response: any, tables: string[], isTag?: boolean, config?: CacheConfig): Promise<void>;
+    onMutate(params: MutationOption): Promise<void>;
+    private addTablePrefix;
+    private getCompositeKey;
 }
-declare function upstashCache({
-  url,
-  token,
-  config,
-  global
-}: {
-  url: string;
-  token: string;
-  config?: CacheConfig;
-  global?: boolean;
+export declare function upstashCache({ url, token, config, global }: {
+    url: string;
+    token: string;
+    config?: CacheConfig;
+    global?: boolean;
 }): UpstashCache;
-//#endregion
-export { UpstashCache, upstashCache };
-//# sourceMappingURL=cache.d.ts.map

package/cache/upstash/index.d.cts

@@ -1,2 +1 @@
-import { UpstashCache, upstashCache } from "./cache.cjs";
-export { UpstashCache, upstashCache };
+export * from './cache.cjs';

package/cache/upstash/index.d.ts

@@ -1,2 +1 @@
-import { UpstashCache, upstashCache } from "./cache.js";
-export { UpstashCache, upstashCache };
+export * from './cache.js';

package/casing.d.cts

@@ -1,8 +1,4 @@
-//#region src/casing.d.ts
-type Casing = 'snake_case' | 'camelCase';
-declare function toSnakeCase(input: string): string;
-declare function toCamelCase(input: string): string;
-declare function getCasingFn(casing: Casing | undefined): typeof toSnakeCase;
-//#endregion
-export { Casing, getCasingFn, toCamelCase, toSnakeCase };
-//# sourceMappingURL=casing.d.cts.map
+export type Casing = 'snake_case' | 'camelCase';
+export declare function toSnakeCase(input: string): string;
+export declare function toCamelCase(input: string): string;
+export declare function getCasingFn(casing: Casing | undefined): typeof toSnakeCase;

package/casing.d.ts

@@ -1,8 +1,4 @@
-//#region src/casing.d.ts
-type Casing = 'snake_case' | 'camelCase';
-declare function toSnakeCase(input: string): string;
-declare function toCamelCase(input: string): string;
-declare function getCasingFn(casing: Casing | undefined): typeof toSnakeCase;
-//#endregion
-export { Casing, getCasingFn, toCamelCase, toSnakeCase };
-//# sourceMappingURL=casing.d.ts.map
+export type Casing = 'snake_case' | 'camelCase';
+export declare function toSnakeCase(input: string): string;
+export declare function toCamelCase(input: string): string;
+export declare function getCasingFn(casing: Casing | undefined): typeof toSnakeCase;

package/cockroach/driver.d.cts

@@ -1,40 +1,43 @@
-import { NodeCockroachClient, NodeCockroachQueryResultHKT, NodeCockroachSession } from "./session.cjs";
-import { entityKind } from "../entity.cjs";
-import { DrizzleConfig } from "../utils.cjs";
-import * as V1 from "../_relations.cjs";
-import { CockroachDialect } from "../cockroach-core/dialect.cjs";
-import { Logger } from "../logger.cjs";
-import { Pool, PoolConfig } from "pg";
-import { CockroachDatabase } from "../cockroach-core/db.cjs";
-
-//#region src/cockroach/driver.d.ts
-interface CockroachDriverOptions {
-  logger?: Logger;
-  useJitMappers?: boolean;
+import { type Pool, type PoolConfig } from 'pg';
+import * as V1 from '../_relations.cjs';
+import { CockroachDatabase } from '../cockroach-core/db.cjs';
+import { CockroachDialect } from '../cockroach-core/dialect.cjs';
+import { entityKind } from '../entity.cjs';
+import type { Logger } from '../logger.cjs';
+import { type DrizzleConfig } from '../utils.cjs';
+import type { NodeCockroachClient, NodeCockroachQueryResultHKT } from './session.cjs';
+import { NodeCockroachSession } from './session.cjs';
+export interface CockroachDriverOptions {
+    logger?: Logger;
+    useJitMappers?: boolean;
 }
-declare class NodeCockroachDriver {
-  private client;
-  private dialect;
-  private options;
-  static readonly [entityKind]: string;
-  constructor(client: NodeCockroachClient, dialect: CockroachDialect, options?: CockroachDriverOptions);
-  createSession(schema: V1.RelationalSchemaConfig<V1.TablesRelationalConfig> | undefined): NodeCockroachSession<Record<string, unknown>, V1.TablesRelationalConfig>;
+export declare class NodeCockroachDriver {
+    private client;
+    private dialect;
+    private options;
+    static readonly [entityKind]: string;
+    constructor(client: NodeCockroachClient, dialect: CockroachDialect, options?: CockroachDriverOptions);
+    createSession(schema: V1.RelationalSchemaConfig<V1.TablesRelationalConfig> | undefined): NodeCockroachSession<Record<string, unknown>, V1.TablesRelationalConfig>;
 }
-declare class NodeCockroachDatabase<TSchema extends Record<string, unknown> = Record<string, never>> extends CockroachDatabase<NodeCockroachQueryResultHKT, TSchema> {
-  static readonly [entityKind]: string;
+export declare class NodeCockroachDatabase<TSchema extends Record<string, unknown> = Record<string, never>> extends CockroachDatabase<NodeCockroachQueryResultHKT, TSchema> {
+    static readonly [entityKind]: string;
 }
-declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>, TClient extends NodeCockroachClient = Pool>(...params: [string] | [string, DrizzleConfig<TSchema>] | [(DrizzleConfig<TSchema> & ({
-  connection: string | PoolConfig;
-} | {
-  client: TClient;
-}))]): NodeCockroachDatabase<TSchema> & {
-  $client: TClient;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>, TClient extends NodeCockroachClient = Pool>(...params: [
+    string
+] | [
+    string,
+    DrizzleConfig<TSchema>
+] | [
+    (DrizzleConfig<TSchema> & ({
+        connection: string | PoolConfig;
+    } | {
+        client: TClient;
+    }))
+]): NodeCockroachDatabase<TSchema> & {
+    $client: TClient;
 };
-declare namespace drizzle {
-  function mock<TSchema extends Record<string, unknown> = Record<string, never>>(config?: DrizzleConfig<TSchema>): NodeCockroachDatabase<TSchema> & {
-    $client: '$client is not available on drizzle.mock()';
-  };
+export declare namespace drizzle {
+    function mock<TSchema extends Record<string, unknown> = Record<string, never>>(config?: DrizzleConfig<TSchema>): NodeCockroachDatabase<TSchema> & {
+        $client: '$client is not available on drizzle.mock()';
+    };
 }
-//#endregion
-export { CockroachDriverOptions, NodeCockroachDatabase, NodeCockroachDriver, drizzle };
-//# sourceMappingURL=driver.d.cts.map

package/cockroach/driver.d.ts

@@ -1,40 +1,43 @@
-import { NodeCockroachClient, NodeCockroachQueryResultHKT, NodeCockroachSession } from "./session.js";
-import { entityKind } from "../entity.js";
-import { DrizzleConfig } from "../utils.js";
-import { Logger } from "../logger.js";
-import * as V1 from "../_relations.js";
-import { Pool, PoolConfig } from "pg";
-import { CockroachDialect } from "../cockroach-core/dialect.js";
-import { CockroachDatabase } from "../cockroach-core/db.js";
-
-//#region src/cockroach/driver.d.ts
-interface CockroachDriverOptions {
-  logger?: Logger;
-  useJitMappers?: boolean;
+import { type Pool, type PoolConfig } from 'pg';
+import * as V1 from '../_relations.js';
+import { CockroachDatabase } from '../cockroach-core/db.js';
+import { CockroachDialect } from '../cockroach-core/dialect.js';
+import { entityKind } from '../entity.js';
+import type { Logger } from '../logger.js';
+import { type DrizzleConfig } from '../utils.js';
+import type { NodeCockroachClient, NodeCockroachQueryResultHKT } from './session.js';
+import { NodeCockroachSession } from './session.js';
+export interface CockroachDriverOptions {
+    logger?: Logger;
+    useJitMappers?: boolean;
 }
-declare class NodeCockroachDriver {
-  private client;
-  private dialect;
-  private options;
-  static readonly [entityKind]: string;
-  constructor(client: NodeCockroachClient, dialect: CockroachDialect, options?: CockroachDriverOptions);
-  createSession(schema: V1.RelationalSchemaConfig<V1.TablesRelationalConfig> | undefined): NodeCockroachSession<Record<string, unknown>, V1.TablesRelationalConfig>;
+export declare class NodeCockroachDriver {
+    private client;
+    private dialect;
+    private options;
+    static readonly [entityKind]: string;
+    constructor(client: NodeCockroachClient, dialect: CockroachDialect, options?: CockroachDriverOptions);
+    createSession(schema: V1.RelationalSchemaConfig<V1.TablesRelationalConfig> | undefined): NodeCockroachSession<Record<string, unknown>, V1.TablesRelationalConfig>;
 }
-declare class NodeCockroachDatabase<TSchema extends Record<string, unknown> = Record<string, never>> extends CockroachDatabase<NodeCockroachQueryResultHKT, TSchema> {
-  static readonly [entityKind]: string;
+export declare class NodeCockroachDatabase<TSchema extends Record<string, unknown> = Record<string, never>> extends CockroachDatabase<NodeCockroachQueryResultHKT, TSchema> {
+    static readonly [entityKind]: string;
 }
-declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>, TClient extends NodeCockroachClient = Pool>(...params: [string] | [string, DrizzleConfig<TSchema>] | [(DrizzleConfig<TSchema> & ({
-  connection: string | PoolConfig;
-} | {
-  client: TClient;
-}))]): NodeCockroachDatabase<TSchema> & {
-  $client: TClient;
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>, TClient extends NodeCockroachClient = Pool>(...params: [
+    string
+] | [
+    string,
+    DrizzleConfig<TSchema>
+] | [
+    (DrizzleConfig<TSchema> & ({
+        connection: string | PoolConfig;
+    } | {
+        client: TClient;
+    }))
+]): NodeCockroachDatabase<TSchema> & {
+    $client: TClient;
 };
-declare namespace drizzle {
-  function mock<TSchema extends Record<string, unknown> = Record<string, never>>(config?: DrizzleConfig<TSchema>): NodeCockroachDatabase<TSchema> & {
-    $client: '$client is not available on drizzle.mock()';
-  };
+export declare namespace drizzle {
+    function mock<TSchema extends Record<string, unknown> = Record<string, never>>(config?: DrizzleConfig<TSchema>): NodeCockroachDatabase<TSchema> & {
+        $client: '$client is not available on drizzle.mock()';
+    };
 }
-//#endregion
-export { CockroachDriverOptions, NodeCockroachDatabase, NodeCockroachDriver, drizzle };
-//# sourceMappingURL=driver.d.ts.map

package/cockroach/index.d.cts

@@ -1,3 +1,2 @@
-import { NodeCockroachClient, NodeCockroachPreparedQuery, NodeCockroachQueryResultHKT, NodeCockroachSession, NodeCockroachSessionOptions, NodeCockroachTransaction } from "./session.cjs";
-import { CockroachDriverOptions, NodeCockroachDatabase, NodeCockroachDriver, drizzle } from "./driver.cjs";
-export { CockroachDriverOptions, NodeCockroachClient, NodeCockroachDatabase, NodeCockroachDriver, NodeCockroachPreparedQuery, NodeCockroachQueryResultHKT, NodeCockroachSession, NodeCockroachSessionOptions, NodeCockroachTransaction, drizzle };
+export * from './driver.cjs';
+export * from './session.cjs';

package/cockroach/index.d.ts

@@ -1,3 +1,2 @@
-import { NodeCockroachClient, NodeCockroachPreparedQuery, NodeCockroachQueryResultHKT, NodeCockroachSession, NodeCockroachSessionOptions, NodeCockroachTransaction } from "./session.js";
-import { CockroachDriverOptions, NodeCockroachDatabase, NodeCockroachDriver, drizzle } from "./driver.js";
-export { CockroachDriverOptions, NodeCockroachClient, NodeCockroachDatabase, NodeCockroachDriver, NodeCockroachPreparedQuery, NodeCockroachQueryResultHKT, NodeCockroachSession, NodeCockroachSessionOptions, NodeCockroachTransaction, drizzle };
+export * from './driver.js';
+export * from './session.js';

package/cockroach/migrator.d.cts

@@ -1,9 +1,3 @@
-import { NodeCockroachDatabase } from "./driver.cjs";
-import * as __migrator_ts0 from "../migrator.cjs";
-import { MigrationConfig } from "../migrator.cjs";
-
-//#region src/cockroach/migrator.d.ts
-declare function migrate<TSchema extends Record<string, unknown>>(db: NodeCockroachDatabase<TSchema>, config: MigrationConfig): Promise<void | __migrator_ts0.MigratorInitFailResponse>;
-//#endregion
-export { migrate };
-//# sourceMappingURL=migrator.d.cts.map
+import type { MigrationConfig } from '../migrator.cjs';
+import type { NodeCockroachDatabase } from './driver.cjs';
+export declare function migrate<TSchema extends Record<string, unknown>>(db: NodeCockroachDatabase<TSchema>, config: MigrationConfig): Promise<void | import("../migrator.cjs").MigratorInitFailResponse>;

package/cockroach/migrator.d.ts

@@ -1,9 +1,3 @@
-import { NodeCockroachDatabase } from "./driver.js";
-import * as __migrator_ts0 from "../migrator.js";
-import { MigrationConfig } from "../migrator.js";
-
-//#region src/cockroach/migrator.d.ts
-declare function migrate<TSchema extends Record<string, unknown>>(db: NodeCockroachDatabase<TSchema>, config: MigrationConfig): Promise<void | __migrator_ts0.MigratorInitFailResponse>;
-//#endregion
-export { migrate };
-//# sourceMappingURL=migrator.d.ts.map
+import type { MigrationConfig } from '../migrator.js';
+import type { NodeCockroachDatabase } from './driver.js';
+export declare function migrate<TSchema extends Record<string, unknown>>(db: NodeCockroachDatabase<TSchema>, config: MigrationConfig): Promise<void | import("../migrator.js").MigratorInitFailResponse>;

package/cockroach/session.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 let __entity_ts = require("../entity.cjs");
+let __tracing_ts = require("../tracing.cjs");
 let __utils_ts = require("../utils.cjs");
 let __sql_sql_ts = require("../sql/sql.cjs");
-let __tracing_ts = require("../tracing.cjs");
 let __logger_ts = require("../logger.cjs");
 let pg = require("pg");
 pg = require_runtime.__toESM(pg);

package/cockroach/session.d.cts

@@ -1,52 +1,49 @@
-import { entityKind } from "../entity.cjs";
-import { Query } from "../sql/sql.cjs";
-import { Assume } from "../utils.cjs";
-import * as V1 from "../_relations.cjs";
-import { CockroachDialect } from "../cockroach-core/dialect.cjs";
-import { CockroachPreparedQuery, CockroachQueryResultHKT, CockroachSession, CockroachTransactionConfig, PreparedQueryConfig } from "../cockroach-core/session.cjs";
-import { SelectedFieldsOrdered } from "../cockroach-core/query-builders/select.types.cjs";
-import { Logger } from "../logger.cjs";
-import pg, { Client, PoolClient, QueryResult, QueryResultRow } from "pg";
-import { CockroachTransaction as CockroachTransaction$1 } from "../cockroach-core/index.cjs";
-
-//#region src/cockroach/session.d.ts
-type NodeCockroachClient = pg.Pool | PoolClient | Client;
-declare class NodeCockroachPreparedQuery<T extends PreparedQueryConfig> extends CockroachPreparedQuery<T> {
-  private client;
-  private params;
-  private logger;
-  private fields;
-  private useJitMappers;
-  private customResultMapper?;
-  static readonly [entityKind]: string;
-  private rawQueryConfig;
-  private queryConfig;
-  private jitMapper?;
-  constructor(client: NodeCockroachClient, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, name: string | undefined, useJitMappers: boolean | undefined, customResultMapper?: ((rows: unknown[][]) => T["execute"]) | undefined);
-  execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
-  all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
+import type { Client, PoolClient, QueryResult, QueryResultRow } from 'pg';
+import pg from 'pg';
+import type * as V1 from '../_relations.cjs';
+import type { CockroachDialect } from '../cockroach-core/dialect.cjs';
+import { CockroachTransaction } from '../cockroach-core/index.cjs';
+import type { SelectedFieldsOrdered } from '../cockroach-core/query-builders/select.types.cjs';
+import type { CockroachQueryResultHKT, CockroachTransactionConfig, PreparedQueryConfig } from '../cockroach-core/session.cjs';
+import { CockroachPreparedQuery, CockroachSession } from '../cockroach-core/session.cjs';
+import { entityKind } from '../entity.cjs';
+import { type Logger } from '../logger.cjs';
+import { type Query } from '../sql/sql.cjs';
+import { type Assume } from '../utils.cjs';
+export type NodeCockroachClient = pg.Pool | PoolClient | Client;
+export declare class NodeCockroachPreparedQuery<T extends PreparedQueryConfig> extends CockroachPreparedQuery<T> {
+    private client;
+    private params;
+    private logger;
+    private fields;
+    private useJitMappers;
+    private customResultMapper?;
+    static readonly [entityKind]: string;
+    private rawQueryConfig;
+    private queryConfig;
+    private jitMapper?;
+    constructor(client: NodeCockroachClient, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, name: string | undefined, useJitMappers: boolean | undefined, customResultMapper?: ((rows: unknown[][]) => T["execute"]) | undefined);
+    execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
+    all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
 }
-interface NodeCockroachSessionOptions {
-  logger?: Logger;
-  useJitMappers?: boolean;
+export interface NodeCockroachSessionOptions {
+    logger?: Logger;
+    useJitMappers?: boolean;
 }
-declare class NodeCockroachSession<TFullSchema extends Record<string, unknown>, TSchema extends V1.TablesRelationalConfig> extends CockroachSession<NodeCockroachQueryResultHKT, TFullSchema, TSchema> {
-  private client;
-  private schema;
-  private options;
-  static readonly [entityKind]: string;
-  private logger;
-  constructor(client: NodeCockroachClient, dialect: CockroachDialect, schema: V1.RelationalSchemaConfig<TSchema> | undefined, options?: NodeCockroachSessionOptions);
-  prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: (rows: unknown[][]) => T['execute']): CockroachPreparedQuery<T>;
-  transaction<T>(transaction: (tx: NodeCockroachTransaction<TFullSchema, TSchema>) => Promise<T>, config?: CockroachTransactionConfig | undefined): Promise<T>;
+export declare class NodeCockroachSession<TFullSchema extends Record<string, unknown>, TSchema extends V1.TablesRelationalConfig> extends CockroachSession<NodeCockroachQueryResultHKT, TFullSchema, TSchema> {
+    private client;
+    private schema;
+    private options;
+    static readonly [entityKind]: string;
+    private logger;
+    constructor(client: NodeCockroachClient, dialect: CockroachDialect, schema: V1.RelationalSchemaConfig<TSchema> | undefined, options?: NodeCockroachSessionOptions);
+    prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: (rows: unknown[][]) => T['execute']): CockroachPreparedQuery<T>;
+    transaction<T>(transaction: (tx: NodeCockroachTransaction<TFullSchema, TSchema>) => Promise<T>, config?: CockroachTransactionConfig | undefined): Promise<T>;
 }
-declare class NodeCockroachTransaction<TFullSchema extends Record<string, unknown>, TSchema extends V1.TablesRelationalConfig> extends CockroachTransaction$1<NodeCockroachQueryResultHKT, TFullSchema, TSchema> {
-  static readonly [entityKind]: string;
-  transaction<T>(transaction: (tx: NodeCockroachTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+export declare class NodeCockroachTransaction<TFullSchema extends Record<string, unknown>, TSchema extends V1.TablesRelationalConfig> extends CockroachTransaction<NodeCockroachQueryResultHKT, TFullSchema, TSchema> {
+    static readonly [entityKind]: string;
+    transaction<T>(transaction: (tx: NodeCockroachTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
 }
-interface NodeCockroachQueryResultHKT extends CockroachQueryResultHKT {
-  type: QueryResult<Assume<this['row'], QueryResultRow>>;
+export interface NodeCockroachQueryResultHKT extends CockroachQueryResultHKT {
+    type: QueryResult<Assume<this['row'], QueryResultRow>>;
 }
-//#endregion
-export { NodeCockroachClient, NodeCockroachPreparedQuery, NodeCockroachQueryResultHKT, NodeCockroachSession, NodeCockroachSessionOptions, NodeCockroachTransaction };
-//# sourceMappingURL=session.d.cts.map