ts-prorm-orm 1.1.0 → 1.2.0

package/dist/dialects/cockroachdb/index.d.ts

@@ -0,0 +1,1708 @@
+/**
+ * CockroachDB dialect implementation for the TypeScript ORM
+ *
+ * CockroachDB speaks the CockroachDB wire protocol and is largely SQL-compatible
+ * with CockroachDB, so this dialect reuses the `pg` driver (same as the Postgres
+ * dialect) and mirrors most of its query-building behavior. Notable differences
+ * from the Postgres dialect:
+ *
+ * - Default port is 26257 (not 5432).
+ * - showTables/describeTable/showIndexes/showConstraints prefer CockroachDB's
+ *   `SHOW TABLES` / `SHOW COLUMNS FROM` / `SHOW INDEXES FROM` / `SHOW CONSTRAINTS FROM`
+ *   statements instead of querying information_schema/pg_catalog directly.
+ * - `CREATE INDEX ... CONCURRENTLY` is not supported (and not needed) in CockroachDB
+ *   because index creation is online/non-blocking by default; the `concurrently`
+ *   option is ignored with a warning instead of being emitted in the SQL.
+ * - Interleaved tables (CockroachDB's now-deprecated `INTERLEAVE IN PARENT` syntax)
+ *   are intentionally NOT implemented.
+ * - SERIAL/BIGSERIAL auto-increment columns are kept for parity with the Postgres
+ *   dialect; CockroachDB accepts these as a Postgres-compatibility shorthand that
+ *   maps to an implicit sequence internally (CockroachDB's default unique ID
+ *   generation otherwise uses `unique_rowid()`).
+ * - `buildUpsertQuery`/`buildInsertQuery` default to Postgres-style `ON CONFLICT
+ *   ... DO UPDATE` for consistency with the Postgres dialect's style, but
+ *   accept a `nativeUpsert` option to opt into CockroachDB's native
+ *   `UPSERT INTO ... VALUES (...)` shorthand, which replaces the whole row
+ *   without requiring a conflict target.
+ * - Adds `isRetryableError()` to detect CockroachDB's serialization failure
+ *   SQLSTATE (40001), which requires the client to retry the transaction.
+ *   `runTransaction()` uses it to implement CockroachDB's client-side
+ *   transaction retry loop (`SAVEPOINT cockroach_restart`), and it's also
+ *   folded into the default query-retry match lists so single-statement
+ *   retries cover it too.
+ */
+import type { Pool, PoolClient } from 'pg';
+import { Dialect, DialectOptions, ColumnDefinition, TableOptions, DropTableOptions, TableDescription, IndexOptions, InsertOptions, UpdateOptions as DUpdateOptions, DeleteOptions, SelectOptions, UpsertQueryOptions, CreateExtensionOptions, DropExtensionOptions, ExtensionInfo, FdwForeignServerOptions, FdwAlterForeignServerOptions, FdwUserMappingOptions, FdwForeignTableOptions, FdwImportForeignSchemaOptions, ViewOptions, DropViewOptions, DropSchemaOptions, MaterializedViewOptions, RefreshOptions, DropMaterializedViewOptions } from '../dialect';
+import { Transaction, TransactionOptions, QueryResult, QueryOptions, StreamOptions, DataType, WhereOptions, Order, PartitionDefinition, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, FunctionOptions, DropFunctionOptions, TriggerOptions, DropTriggerOptions, SequenceOptions, DropSequenceOptions, PolicyOptions, DropPolicyOptions } from '../../types';
+/**
+ * CockroachDB-specific hash-sharded index options. Not part of the shared
+ * `IndexOptions` type (which is used by every dialect), so callers targeting
+ * CockroachDB can pass these alongside the common options via an
+ * intersection type.
+ *
+ * @see https://www.cockroachlabs.com/docs/stable/hash-sharded-indexes
+ */
+export interface CockroachHashShardedIndexOptions {
+    /** Number of buckets to shard the index into (CockroachDB `USING HASH WITH (bucket_count = N)`) */
+    bucketCount?: number;
+    /** Alias for `bucketCount` */
+    shard?: number;
+}
+/**
+ * CockroachDB multi-region table locality setting
+ * (`ALTER TABLE ... SET LOCALITY ...` / `CREATE TABLE ... LOCALITY ...`).
+ *
+ * Only meaningful for multi-region databases (i.e. databases that have had
+ * at least one region added via `ADD REGION`/`SET PRIMARY REGION`).
+ *
+ * @see https://www.cockroachlabs.com/docs/stable/table-localities
+ */
+export type CockroachLocality = {
+    type: 'global';
+} | {
+    type: 'regional-by-table';
+    region?: string;
+} | {
+    type: 'regional-by-row';
+    column?: string;
+};
+/**
+ * CockroachDB-specific table options: multi-region `LOCALITY` and column
+ * `FAMILY` grouping. Not part of the shared `TableOptions` type (which is
+ * used by every dialect), so callers targeting CockroachDB pass these
+ * alongside the common options via an intersection type.
+ */
+export interface CockroachTableOptions {
+    /** Multi-region table locality (`REGIONAL BY TABLE` / `REGIONAL BY ROW` / `GLOBAL`) */
+    locality?: CockroachLocality;
+    /** Column family groupings (CockroachDB storage-layout hint): `FAMILY name (col1, col2)` */
+    families?: {
+        name?: string;
+        columns: string[];
+    }[];
+}
+/**
+ * Options for `configureZone()` (`ALTER ... CONFIGURE ZONE USING ...`).
+ * Mirrors the subset of CockroachDB zone-configuration replication
+ * variables that are reasonable for an ORM to expose.
+ *
+ * @see https://www.cockroachlabs.com/docs/stable/configure-zone
+ */
+export interface CockroachZoneConfigOptions {
+    /** Number of replicas to maintain for ranges covered by this zone (`num_replicas`) */
+    numReplicas?: number;
+    /** Constraints on which nodes/localities may hold replicas (`constraints`), e.g. `'[+region=us-east1]'` */
+    constraints?: string;
+    /** Ordered lease-preference tiers (`lease_preferences`), e.g. `['[+region=us-east1]']` */
+    leasePreferences?: string[];
+    /** Garbage-collection TTL in seconds for MVCC versions (`gc.ttlseconds`) */
+    gcTtlSeconds?: number;
+    /** Minimum range size in bytes before CockroachDB tries to merge ranges (`range_min_bytes`) */
+    rangeMinBytes?: number;
+    /** Maximum range size in bytes before CockroachDB splits a range (`range_max_bytes`) */
+    rangeMaxBytes?: number;
+    /** Number of voting replicas (`num_voters`), for use with non-voting replicas */
+    numVoters?: number;
+}
+/** Target of a `CONFIGURE ZONE` / `SPLIT AT` / `UNSPLIT AT` statement. */
+export type CockroachZoneTarget = {
+    kind: 'table';
+    name: string;
+} | {
+    kind: 'index';
+    table: string;
+    index: string;
+} | {
+    kind: 'partition';
+    name: string;
+    table: string;
+    index?: string;
+} | {
+    kind: 'database';
+    name: string;
+};
+/**
+ * CockroachDB-specific insert option: opt into the native `UPSERT INTO`
+ * shorthand. Not part of the shared `InsertOptions` type (which is used by
+ * every dialect), so callers targeting CockroachDB pass `nativeUpsert`
+ * alongside the common options via this extended type.
+ *
+ * @see https://www.cockroachlabs.com/docs/stable/upsert
+ */
+export interface CockroachInsertOptions extends InsertOptions {
+    /**
+     * When true (and `upsert` is also true), emit CockroachDB's native
+     * `UPSERT INTO t (...) VALUES (...)` statement instead of
+     * `INSERT ... ON CONFLICT ... DO UPDATE`. Native `UPSERT` replaces the row
+     * matching the table's primary key wholesale and does not require (or
+     * accept) a conflict target, so `conflictFields` is ignored when this is
+     * set.
+     * @default false
+     */
+    nativeUpsert?: boolean;
+}
+/**
+ * CockroachDB-specific upsert option: opt into the native `UPSERT INTO`
+ * shorthand. Not part of the shared `UpsertQueryOptions` type (which is used
+ * by every dialect), so callers targeting CockroachDB pass `nativeUpsert`
+ * alongside the common options via this extended type.
+ *
+ * @see https://www.cockroachlabs.com/docs/stable/upsert
+ */
+export interface CockroachUpsertQueryOptions extends UpsertQueryOptions {
+    /**
+     * When true, emit CockroachDB's native `UPSERT INTO t (...) VALUES (...)`
+     * statement instead of `INSERT ... ON CONFLICT ... DO UPDATE`. Native
+     * `UPSERT` replaces the row matching the table's primary key wholesale and
+     * does not require (or accept) a conflict target, so `conflictFields` and
+     * `updateOnDuplicate` are ignored when this is set.
+     * @default false
+     */
+    nativeUpsert?: boolean;
+}
+/**
+ * Options for {@link CockroachDBDialect.runTransaction}. Not part of the
+ * shared `TransactionOptions` type (which is used by every dialect), so
+ * callers targeting CockroachDB pass `maxRetries` alongside the common
+ * transaction options via this extended type.
+ */
+export interface CockroachRunTransactionOptions extends TransactionOptions {
+    /**
+     * Maximum number of times to retry the transaction body after a
+     * serialization failure (SQLSTATE `40001` / "restart transaction") before
+     * giving up and rethrowing the error.
+     * @default 5
+     */
+    maxRetries?: number;
+    /**
+     * CockroachDB transaction priority (`SET TRANSACTION PRIORITY LOW|NORMAL|HIGH`).
+     * Higher-priority transactions are less likely to be aborted when they
+     * conflict with concurrent transactions, which reduces retry churn for known
+     * hot/critical transactions. Applied right after `BEGIN`.
+     * @see https://www.cockroachlabs.com/docs/stable/transactions#transaction-priorities
+     */
+    priority?: CockroachTransactionPriority;
+}
+/**
+ * CockroachDB transaction priority level for
+ * `SET TRANSACTION PRIORITY {LOW|NORMAL|HIGH}`.
+ */
+export type CockroachTransactionPriority = 'LOW' | 'NORMAL' | 'HIGH';
+/**
+ * CockroachDB dialect class that implements the Dialect interface
+ */
+export declare class CockroachDBDialect implements Dialect {
+    readonly name = "cockroachdb";
+    readonly library = "pg";
+    private pool;
+    private _isConnected;
+    private config;
+    private transactionDepth;
+    constructor(config: CockroachDBDialectOptions);
+    /**
+     * Determine whether an error is retryable, i.e. whether the client should
+     * retry the transaction that produced it.
+     *
+     * CockroachDB uses SQLSTATE 40001 ("serialization_failure", surfaced as the
+     * "restart transaction" error) to signal that a transaction could not be
+     * committed due to a conflict with a concurrent transaction under
+     * SERIALIZABLE isolation, and that the client should retry it from the
+     * beginning. See: https://www.cockroachlabs.com/docs/stable/transaction-retry-error-reference
+     *
+     * @param error - The error to check (expected to expose a `.code` property,
+     *   as errors from the `pg` driver do).
+     * @returns True if the error's SQLSTATE is 40001.
+     */
+    isRetryableError(error: any): boolean;
+    /**
+     * Connect to the CockroachDB database
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the CockroachDB database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get the current connection pool
+     */
+    getConnection(): Pool | null;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Execute a raw SQL query with retry support
+     */
+    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * Execute a query and stream results using CockroachDB cursor
+     * Uses server-side cursors for efficient memory usage with large datasets
+     * @param sql - The SQL query string
+     * @param options - Stream options
+     * @returns Readable stream for streaming results
+     */
+    queryStream(sql: string, options?: StreamOptions): import('stream').Readable;
+    /**
+     * Execute a function with retry logic for query execution
+     */
+    private executeWithRetry;
+    /**
+     * Escape a value for use in a query
+     */
+    escape(value: unknown): string;
+    /**
+     * Escape a string for SQL
+     */
+    private escapeString;
+    /**
+     * Format a date for CockroachDB
+     */
+    private formatDate;
+    /**
+     * Escape an identifier (table name, column name, etc.)
+     * CockroachDB uses double quotes for identifiers
+     */
+    escapeId(identifier: unknown): string;
+    /**
+     * Quote an identifier (column name, table name)
+     * CockroachDB uses double quotes for identifiers
+     */
+    quoteIdentifier(identifier: string): string;
+    /**
+     * Quote a table name
+     * Includes schema prefix if provided
+     */
+    quoteTable(tableName: string, schema?: string): string;
+    /**
+     * Get the database version
+     */
+    getDatabaseVersion(): Promise<string>;
+    /**
+     * Create a database schema
+     * @param schema - The schema name to create
+     */
+    createSchema(schema: string): Promise<void>;
+    /**
+     * Drop a database schema
+     * @param schema - The schema name to drop
+     * @param options - Drop options (e.g., cascade)
+     */
+    dropSchema(schema: string, options?: DropSchemaOptions): Promise<void>;
+    /**
+     * Show all schemas in the database
+     */
+    showAllSchemas(): Promise<string[]>;
+    /**
+     * List all schemas in the database
+     */
+    listSchemas(): Promise<string[]>;
+    /**
+     * Replace placeholders in SQL with actual values
+     * @param sql - SQL string with placeholders
+     * @param replacements - Object or array of replacement values
+     */
+    replaceReplacements(sql: string, replacements?: Record<string, unknown> | unknown[]): string;
+    /**
+     * Create a new table
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & CockroachTableOptions): Promise<void>;
+    /**
+     * Build constraint SQL for table creation
+     */
+    private buildConstraintSql;
+    /**
+     * Generate column definition SQL for CockroachDB
+     */
+    private getColumnDefinitionSql;
+    /**
+     * Get default value SQL
+     */
+    private getDefaultValue;
+    /**
+     * Drop a table
+     */
+    dropTable(tableName: string, options?: DropTableOptions): Promise<void>;
+    /**
+     * Create a partitioned table (CockroachDB)
+     *
+     * @param tableName - Name of the table to create
+     * @param columns - Column definitions
+     * @param options - Table options including partition configuration
+     */
+    createPartitionedTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & {
+        partitionBy: {
+            type: 'range' | 'list' | 'hash';
+            column: string | string[];
+        };
+        partitions?: PartitionDefinition[];
+    }): Promise<void>;
+    /**
+     * Create a partition for an existing partitioned table (CockroachDB)
+     *
+     * @param options - Partition creation options
+     */
+    createPartition(options: CreatePartitionOptions): Promise<void>;
+    /**
+     * Attach a partition to a partitioned table (CockroachDB)
+     *
+     * @param options - Partition attachment options
+     */
+    attachPartition(options: AttachPartitionOptions): Promise<void>;
+    /**
+     * Detach a partition from a partitioned table (CockroachDB)
+     *
+     * @param options - Partition detachment options
+     */
+    detachPartition(options: DetachPartitionOptions): Promise<void>;
+    /**
+     * Drop a partition (CockroachDB)
+     *
+     * @param partitionName - Name of the partition to drop
+     * @param options - Drop options
+     */
+    dropPartition(partitionName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Add a partition to an existing partitioned table (CockroachDB)
+     * @param tableName - Name of the partitioned table
+     * @param partitionName - Name for the new partition
+     * @param partitionSpec - Partition specification
+     */
+    addPartition(tableName: string, partitionName: string, partitionSpec: {
+        values?: string;
+        forValues?: string;
+    }): Promise<void>;
+    /**
+     * Build the `LOCALITY ...` clause fragment (without a leading space, but
+     * including the `LOCALITY` keyword itself) for a given locality setting.
+     * Shared by `createTable` and `setTableLocality`.
+     */
+    private buildLocalityClause;
+    /**
+     * Change the multi-region locality of an existing table
+     * (`ALTER TABLE ... SET LOCALITY ...`).
+     *
+     * Requires the database to already be multi-region (see
+     * `setPrimaryRegion`/`addRegion`).
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/table-localities
+     */
+    setTableLocality(tableName: string, locality: CockroachLocality): Promise<void>;
+    /**
+     * Add a region to a multi-region database (`ALTER DATABASE ... ADD REGION ...`).
+     *
+     * @param region - Region name (e.g. `'us-east1'`)
+     * @param options - `database` to target a database other than the current one
+     */
+    addRegion(region: string, options?: {
+        database?: string;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Remove a region from a multi-region database (`ALTER DATABASE ... DROP REGION ...`).
+     */
+    dropRegion(region: string, options?: {
+        database?: string;
+    }): Promise<void>;
+    /**
+     * Set (or change) the primary region of a database
+     * (`ALTER DATABASE ... {SET|PRIMARY REGION} ...`). Setting a primary
+     * region for the first time promotes the database to a multi-region
+     * database; CockroachDB automatically adds the region as a side effect if
+     * it hasn't been added yet.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/multiregion-overview
+     */
+    setPrimaryRegion(region: string, options?: {
+        database?: string;
+    }): Promise<void>;
+    /**
+     * Set the survival goal of a multi-region database
+     * (`ALTER DATABASE ... SURVIVE {ZONE|REGION} FAILURE`).
+     */
+    setSurvivalGoal(goal: 'zone' | 'region', options?: {
+        database?: string;
+    }): Promise<void>;
+    /**
+     * Resolve a `CockroachZoneTarget` to the SQL fragment that follows
+     * `ALTER ...` in `CONFIGURE ZONE`/`SPLIT AT`/`UNSPLIT AT` statements,
+     * e.g. `TABLE "orders"`, `INDEX "orders"@"idx_name"`, or
+     * `PARTITION "p1" OF TABLE "orders"`.
+     */
+    private resolveZoneTarget;
+    /**
+     * Configure replication/placement settings for a table, index, partition,
+     * or database (`ALTER ... CONFIGURE ZONE USING ...`).
+     *
+     * Exposes the subset of zone-configuration variables that are reasonable
+     * for an ORM to surface: replica count, placement constraints, lease
+     * preferences, GC TTL, and range size bounds. For anything more advanced,
+     * callers can fall back to raw `query()`.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/configure-zone
+     */
+    configureZone(target: CockroachZoneTarget, options: CockroachZoneConfigOptions): Promise<void>;
+    /**
+     * Reset a zone configuration back to its inherited default
+     * (`ALTER ... CONFIGURE ZONE DISCARD`).
+     */
+    resetZoneConfig(target: CockroachZoneTarget): Promise<void>;
+    /**
+     * Format a single split/unsplit key value for use inside a `VALUES (...)`
+     * tuple: quote strings, pass numbers/booleans through, and stringify
+     * `Date`s as ISO timestamps.
+     */
+    private formatSplitValue;
+    /**
+     * Manually split a range at the given key value(s)
+     * (`ALTER TABLE/INDEX ... SPLIT AT VALUES (...)`), to pre-emptively
+     * distribute a hot/monotonically-growing key range across nodes before
+     * CockroachDB's automatic range-size-based splitting would kick in.
+     *
+     * `values` is an array of row tuples matching the index prefix; pass
+     * multiple tuples to create multiple split points in one call.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/alter-table#split-at
+     */
+    splitAt(target: CockroachZoneTarget, values: unknown[][], options?: {
+        expiration?: string;
+    }): Promise<void>;
+    /**
+     * Undo a manual (or expired) range split
+     * (`ALTER TABLE/INDEX ... UNSPLIT AT VALUES (...)`), or unsplit every
+     * manually-created split point on the target when `values` is omitted
+     * (`UNSPLIT ALL`).
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/alter-table#unsplit-at
+     */
+    unsplitAt(target: CockroachZoneTarget, values?: unknown[][]): Promise<void>;
+    /**
+     * Create a database view
+     */
+    createView(viewName: string, query: string, options?: ViewOptions): Promise<void>;
+    /**
+     * Drop a database view
+     */
+    dropView(viewName: string, options?: DropViewOptions): Promise<void>;
+    /**
+     * Show all views in the database
+     */
+    showViews(): Promise<string[]>;
+    /**
+     * Create a materialized view
+     * @param options - Materialized view options
+     */
+    createMaterializedView(options: MaterializedViewOptions): Promise<void>;
+    /**
+     * Refresh a materialized view
+     * @param viewName - Name of the materialized view to refresh
+     * @param options - Refresh options
+     */
+    refreshMaterializedView(viewName: string, options?: RefreshOptions): Promise<void>;
+    /**
+     * Drop a materialized view
+     * @param viewName - Name of the materialized view to drop
+     * @param options - Drop options
+     */
+    dropMaterializedView(viewName: string, options?: DropMaterializedViewOptions): Promise<void>;
+    /**
+     * Check if a materialized view exists
+     *
+     * Queries `pg_class`/`pg_namespace` directly (filtering on
+     * `relkind = 'm'`) rather than the derived `pg_matviews` view. CockroachDB's
+     * `pg_catalog` compatibility layer is partial, and `pg_matviews` — itself
+     * normally just a view defined on top of `pg_class` in real Postgres — is
+     * not guaranteed to exist/be populated the same way on CockroachDB.
+     * `pg_class` is the more fundamental catalog and a safer bet for accurate
+     * results (an absent/empty `pg_matviews` would otherwise silently report a
+     * false "materialized view doesn't exist").
+     * @param viewName - Name of the materialized view
+     * @returns True if the materialized view exists
+     */
+    hasMaterializedView(viewName: string): Promise<boolean>;
+    /**
+     * Show all materialized views in the database
+     *
+     * See `hasMaterializedView` for why this queries `pg_class`/`pg_namespace`
+     * (`relkind = 'm'`) instead of the `pg_matviews` compatibility view.
+     */
+    showMaterializedViews(): Promise<string[]>;
+    /**
+     * Create a stored procedure (CockroachDB)
+     */
+    createStoredProcedure(options: StoredProcedureOptions): Promise<void>;
+    /**
+     * CockroachDB has no Foreign Data Wrapper (FDW) machinery: no
+     * `CREATE FOREIGN DATA WRAPPER`/`CREATE SERVER`/`CREATE FOREIGN TABLE`/
+     * `CREATE USER MAPPING`/`IMPORT FOREIGN SCHEMA` statements, and no
+     * `pg_foreign_data_wrapper`/`pg_foreign_server` catalogs. These methods
+     * exist only to satisfy the shared `Dialect` interface (which the
+     * Postgres dialect implements for real); rather than silently emitting
+     * Postgres-only DDL that would fail against a real CockroachDB cluster,
+     * they throw a clear "not supported" error. External-data access on
+     * CockroachDB instead goes through `IMPORT`/`EXPORT` or
+     * `CREATE EXTERNAL CONNECTION`, which are out of scope for this ORM's
+     * FDW-shaped API.
+     * @see https://www.cockroachlabs.com/docs/stable/create-external-connection
+     */
+    private static readonly FDW_NOT_SUPPORTED_MESSAGE;
+    /**
+     * Create a foreign data wrapper — not supported in CockroachDB.
+     * @param _fdwName - Foreign data wrapper name (unused; kept for interface parity)
+     * @param _options - Options (unused; kept for interface parity)
+     */
+    createForeignDataWrapper(_fdwName: string, _options?: {
+        handler?: string;
+    }): Promise<void>;
+    dropForeignDataWrapper(_fdwName: string, _options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    createForeignServer(_serverName: string, _fdwName: string, _options?: {
+        options?: Record<string, string>;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    dropForeignServer(_serverName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    createForeignTable(_tableName: string, _columns: Record<string, {
+        type: string;
+    }>, _options?: {
+        serverName?: string;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    changeOwner(newOwner: string, tableName: string): Promise<void>;
+    addConstraint(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    removeConstraint(tableName: string, constraintName: string): Promise<void>;
+    createSecurityPolicy(_policyName: string, _tableName: string, _options?: {
+        predicate?: string;
+    }): Promise<void>;
+    dropSecurityPolicy(_policyName: string, _tableName: string): Promise<void>;
+    /**
+     * Drop a stored procedure
+     */
+    dropStoredProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     */
+    dropProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Create a stored procedure (alias for createStoredProcedure)
+     */
+    createProcedure(options: StoredProcedureOptions): Promise<void>;
+    /**
+     * Execute a stored procedure
+     */
+    executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    /**
+     * Check if a stored procedure exists
+     */
+    hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>;
+    /**
+     * Create a user-defined function (CockroachDB)
+     *
+     * CockroachDB has supported `CREATE FUNCTION` for SQL and PL/pgSQL
+     * functions since v22.2/23.1, and unlike `CREATE PROCEDURE` (see
+     * `createStoredProcedure`), functions can be used directly in SELECT
+     * lists, computed column expressions, and CHECK constraints. A function
+     * must declare a `RETURNS` type, and may optionally declare a volatility
+     * category:
+     *  - `VOLATILE` (the default when omitted): may modify the database
+     *    and/or return different results on successive calls with the same
+     *    arguments.
+     *  - `STABLE`: cannot modify the database and returns the same result
+     *    for the same arguments within a single statement; lets the
+     *    optimizer avoid re-evaluating it per-row when safe.
+     *  - `IMMUTABLE`: cannot modify the database and always returns the same
+     *    result for the same arguments. Required for a function to be used
+     *    in a computed column expression.
+     * @see https://www.cockroachlabs.com/docs/stable/create-function
+     */
+    createFunction(options: FunctionOptions): Promise<void>;
+    /**
+     * Drop a user-defined function
+     */
+    dropFunction(functionName: string, options?: DropFunctionOptions): Promise<void>;
+    /**
+     * Check if a user-defined function exists
+     */
+    hasFunction(functionName: string, schema?: string): Promise<boolean>;
+    /**
+     * Create a trigger
+     *
+     * CockroachDB's trigger support (added as a preview feature and
+     * subsequently stabilized) is deliberately narrower than Postgres':
+     *  - Only row-level triggers are supported (`FOR EACH ROW`); there is no
+     *    `FOR EACH STATEMENT` execution.
+     *  - `INSTEAD OF` triggers are not supported (CockroachDB views are not
+     *    updatable in the way Postgres views can be).
+     *  - The `REFERENCING` clause (transition tables, e.g.
+     *    `REFERENCING NEW TABLE AS ...`) is not supported.
+     *  - Constraint triggers (`CREATE CONSTRAINT TRIGGER`) are not supported.
+     * Rather than silently emitting Postgres-only DDL that will fail (or
+     * behave unexpectedly) against CockroachDB, these unsupported options
+     * throw a clear error.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/triggers
+     */
+    createTrigger(options: TriggerOptions): Promise<void>;
+    /**
+     * Drop a trigger
+     */
+    dropTrigger(triggerName: string, tableName: string, options?: DropTriggerOptions): Promise<void>;
+    /**
+     * List triggers defined on a table.
+     *
+     * Uses CockroachDB's own `SHOW TRIGGERS FROM <table>` introspection
+     * statement (in the same family as `SHOW INDEXES FROM`/`SHOW CONSTRAINTS
+     * FROM` used elsewhere in this dialect) rather than querying the
+     * `pg_trigger` catalog directly. CockroachDB's `pg_catalog` compatibility
+     * layer is partial, and there is no guarantee `pg_trigger` is populated
+     * for CockroachDB-native triggers the same way it is in real Postgres, so
+     * relying on it risks silently reporting "no trigger" when one exists.
+     */
+    showTriggers(tableName: string): Promise<any[]>;
+    /**
+     * Check if a trigger exists
+     */
+    hasTrigger(triggerName: string, tableName: string): Promise<boolean>;
+    /**
+     * Create a sequence
+     */
+    createSequence(options: SequenceOptions): Promise<void>;
+    /**
+     * Drop a sequence
+     */
+    dropSequence(sequenceName: string, options?: DropSequenceOptions): Promise<void>;
+    /**
+     * Get next value from a sequence
+     */
+    nextSequenceValue(sequenceName: string): Promise<number>;
+    /**
+     * Check if a sequence exists
+     */
+    hasSequence(sequenceName: string): Promise<boolean>;
+    /**
+     * List all sequences in the database (CockroachDB)
+     * @returns Array of sequence names
+     */
+    listSequences(): Promise<string[]>;
+    /**
+     * Create a policy (CockroachDB RLS)
+     */
+    createPolicy(options: PolicyOptions): Promise<void>;
+    /**
+     * Drop a policy (CockroachDB RLS)
+     */
+    dropPolicy(policyName: string, tableName: string, options?: DropPolicyOptions): Promise<void>;
+    /**
+     * Enable row-level security on a table (CockroachDB)
+     */
+    enableRLS(tableName: string, schema?: string): Promise<void>;
+    /**
+     * Enable row-level security on a table (alias for enableRLS)
+     */
+    enableRowLevelSecurity(tableName: string, schema?: string): Promise<void>;
+    /**
+     * Disable row-level security on a table (CockroachDB)
+     */
+    disableRLS(tableName: string, schema?: string): Promise<void>;
+    /**
+     * Check if a policy exists (CockroachDB RLS)
+     */
+    hasPolicy(policyName: string, tableName: string): Promise<boolean>;
+    /**
+     * Add comment to a table
+     */
+    commentTable(tableName: string, comment: string): Promise<void>;
+    /**
+     * Add comment to a column
+     */
+    commentColumn(tableName: string, columnName: string, comment: string): Promise<void>;
+    /**
+     * Create a partial index (index with WHERE clause)
+     */
+    createPartialIndex(tableName: string, indexName: string, fields: string[], where: string, options?: IndexOptions): Promise<void>;
+    /**
+     * Create an expression index
+     */
+    createExpressionIndex(tableName: string, indexName: string, expression: string, options?: IndexOptions): Promise<void>;
+    /**
+     * Create a fulltext index (CockroachDB)
+     * Uses GIN index for fulltext search
+     * @param tableName - Table name
+     * @param indexName - Index name
+     * @param fields - Fields to index
+     * @param options - Fulltext index options
+     */
+    createFulltextIndex(tableName: string, indexName: string, fields: string[], options?: {
+        parser?: string;
+        comment?: string;
+    }): Promise<void>;
+    /**
+     * Create a spatial index (CockroachDB)
+     * Uses GIST index for spatial data
+     * @param tableName - Table name
+     * @param indexName - Index name
+     * @param fields - Fields to index
+     * @param options - Spatial index options
+     */
+    createSpatialIndex(tableName: string, indexName: string, fields: string[], options?: {
+        storage?: string;
+        srid?: number;
+    }): Promise<void>;
+    /**
+     * Bulk insert records into a table
+     */
+    bulkInsert(tableName: string, records: Record<string, any>[], _options?: any): Promise<QueryResult>;
+    /**
+     * Add a foreign key to a table
+     */
+    addForeignKey(tableName: string, columnName: string, referencedTableName: string, referencedColumnName: string, options?: {
+        name?: string;
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION';
+    }): Promise<void>;
+    /**
+     * Rename a column
+     */
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string): Promise<void>;
+    /**
+     * Create an identity column
+     */
+    createIdentityColumn(tableName: string, columnName: string, options?: {
+        startWith?: number;
+        incrementBy?: number;
+        minvalue?: number;
+        maxvalue?: number;
+        cycle?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a computed column (generated column)
+     */
+    createComputedColumn(tableName: string, columnName: string, expression: string, options?: {
+        persisted?: boolean;
+        type?: string;
+    }): Promise<void>;
+    /**
+     * CockroachDB does NOT implement PostgreSQL's extension mechanism the way
+     * Postgres does. `CREATE EXTENSION`/`DROP EXTENSION` are accepted by CRDB
+     * purely as no-op compatibility shims for a small, fixed allowlist of
+     * extension names (kept in sync with CockroachDB's documented "Supported
+     * extensions" list) so that ORMs/tools which unconditionally issue
+     * `CREATE EXTENSION IF NOT EXISTS <name>` don't fail outright. No actual
+     * extension code is loaded and most Postgres extensions (arbitrary compiled
+     * extensions, most contrib modules, etc.) are NOT usable at all. Callers
+     * asking for anything outside this allowlist get a clear error instead of
+     * a misleading "success" that doesn't provide any real functionality.
+     */
+    private static readonly SUPPORTED_EXTENSION_SHIMS;
+    private assertExtensionShimSupported;
+    /**
+     * Create a CockroachDB extension (no-op compatibility shim; see
+     * SUPPORTED_EXTENSION_SHIMS above for CockroachDB's partial extension compatibility)
+     * @param extensionName - Name of the extension to create
+     * @param options - Extension options
+     */
+    createExtension(extensionName: string, options?: CreateExtensionOptions): Promise<void>;
+    /**
+     * Drop a CockroachDB extension (no-op compatibility shim; see
+     * SUPPORTED_EXTENSION_SHIMS above for CockroachDB's partial extension compatibility)
+     * @param extensionName - Name of the extension to drop
+     * @param options - Drop options
+     */
+    dropExtension(extensionName: string, options?: DropExtensionOptions): Promise<void>;
+    /**
+     * Get all installed CockroachDB extensions
+     * @returns Array of extension information
+     */
+    getExtensions(): Promise<ExtensionInfo[]>;
+    /**
+     * Check if a CockroachDB extension is installed. Extensions outside
+     * CockroachDB's small no-op compatibility allowlist (see
+     * SUPPORTED_EXTENSION_SHIMS above) can never be "installed" on CockroachDB,
+     * so this returns false for them without a round-trip to the server.
+     * @param extensionName - Name of the extension
+     * @returns True if the extension is installed
+     */
+    hasExtension(extensionName: string): Promise<boolean>;
+    buildCreateServerQuery(_name: string, _opts: FdwForeignServerOptions): string;
+    buildAlterServerQuery(_name: string, _opts: FdwAlterForeignServerOptions): string;
+    buildDropServerQuery(_name: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    /**
+     * Return the SQL to list all foreign servers from the catalog — not
+     * supported in CockroachDB (no `pg_foreign_server`/`pg_foreign_data_wrapper`).
+     */
+    getServersQuery(): string;
+    buildCreateUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildAlterUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildDropUserMappingQuery(_serverName: string, _user: string, _opts?: {
+        ifExists?: boolean;
+    }): string;
+    /**
+     * Create a user mapping for a foreign server — not supported in CockroachDB.
+     */
+    createUserMapping(_userName: string, _serverName: string, _options?: {
+        username?: string;
+        password?: string;
+    }): Promise<void>;
+    /**
+     * Drop a user mapping for a foreign server — not supported in CockroachDB.
+     */
+    dropUserMapping(_userName: string, _serverName: string, _options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    buildCreateForeignTableQuery(_tableName: string, _opts: FdwForeignTableOptions): string;
+    buildDropForeignTableQuery(_tableName: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    buildImportForeignSchemaQuery(_remoteSchema: string, _serverName: string, _opts?: FdwImportForeignSchemaOptions): string;
+    /**
+     * Add a column to a table
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Remove a column from a table
+     */
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    /**
+     * Change a column definition
+     */
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Show all tables in the database
+     *
+     * Uses CockroachDB's `SHOW TABLES` statement (rather than querying
+     * information_schema directly, as the Postgres dialect does) so this
+     * dialect exercises CockroachDB-specific introspection syntax. `SHOW
+     * TABLES` returns rows shaped like
+     * `{ schema_name, table_name, type, owner, estimated_row_count, locality }`
+     * for the current database's `public` schema by default.
+     */
+    showTables(): Promise<string[]>;
+    /**
+     * Get table status (CockroachDB implementation)
+     */
+    getTableStatus(tableName?: string): Promise<Record<string, any>[]>;
+    /**
+     * Get table create statement (CockroachDB implementation)
+     */
+    getCreateTable(tableName: string): Promise<string>;
+    /**
+     * Check if a table has partitions (CockroachDB implementation)
+     */
+    hasPartition(tableName: string): Promise<boolean>;
+    /**
+     * Show constraints for a table
+     *
+     * Uses CockroachDB's `SHOW CONSTRAINTS FROM <table>` statement, which
+     * returns rows shaped like
+     * `{ table_name, constraint_name, constraint_type, details, validated }`.
+     */
+    showConstraints(tableName: string): Promise<any[]>;
+    /**
+     * Show indexes for a table
+     *
+     * Uses CockroachDB's `SHOW INDEXES FROM <table>` statement, which returns
+     * rows shaped like
+     * `{ table_name, index_name, non_unique, seq_in_index, column_name,
+     *    direction, storing, implicit }`.
+     */
+    showIndexes(tableName: string): Promise<any[]>;
+    /**
+     * Inspect the range (shard) distribution of a table or index via
+     * CockroachDB's `SHOW RANGES FROM TABLE|INDEX ...`. Each row describes one
+     * range: its start/end keys, lease holder, and replica placement. Useful for
+     * diagnosing hotspots and verifying `splitAt()`/`configureZone()` results
+     * without dropping to raw SQL.
+     *
+     * @param target - `{ kind: 'table', name }` or `{ kind: 'index', table,
+     *   index }` naming what to inspect (same target shape as
+     *   {@link configureZone}/{@link splitAt}).
+     * @see https://www.cockroachlabs.com/docs/stable/show-ranges
+     */
+    showRanges(target: CockroachZoneTarget): Promise<any[]>;
+    /**
+     * Show the single range that would contain a given primary-key row
+     * (`SHOW RANGE FROM TABLE <t> FOR ROW (val, ...)`), reporting its lease
+     * holder and replica placement. Handy for pinpointing which node owns a
+     * specific hot key.
+     *
+     * @param tableName - Table to look up the row's range in.
+     * @param rowValues - The row's primary-key column value(s), in key order.
+     * @see https://www.cockroachlabs.com/docs/stable/show-range-for-row
+     */
+    showRangeForRow(tableName: string, rowValues: unknown[]): Promise<any[]>;
+    /**
+     * Return the cost-based optimizer's table statistics
+     * (`SHOW STATISTICS FOR TABLE <t>`): column sets, row counts, distinct
+     * counts, null counts and histogram ids the planner uses for cardinality
+     * estimation.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/show-statistics
+     */
+    showStatistics(tableName: string): Promise<any[]>;
+    /**
+     * Trigger a fresh collection of table statistics for the optimizer
+     * (`ANALYZE <t>`, an alias of `CREATE STATISTICS ... FROM <t>`). Run after a
+     * large bulk load/mutation so the planner has accurate cardinality estimates.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/create-statistics
+     */
+    analyzeTable(tableName: string): Promise<void>;
+    /**
+     * Describe a table (get column information)
+     *
+     * Uses CockroachDB's `SHOW COLUMNS FROM <table>` statement, which returns
+     * rows shaped like
+     * `{ column_name, data_type, is_nullable, column_default,
+     *    generation_expression, indices, is_hidden }`, plus
+     * `SHOW CONSTRAINTS FROM <table>` to determine which column(s) form the
+     * primary key.
+     */
+    describeTable(tableName: string): Promise<TableDescription>;
+    /**
+     * Rename a table
+     */
+    renameTable(oldName: string, newName: string): Promise<void>;
+    /**
+     * Resolve and validate the requested hash-sharded index bucket count
+     * (`bucketCount`/`shard`) from an options object. Returns `undefined` if
+     * neither is set.
+     */
+    private resolveHashBucketCount;
+    /**
+     * Add an index to a table
+     *
+     * Note: unlike Postgres, CockroachDB does not support (or need)
+     * `CREATE INDEX CONCURRENTLY` — index backfills are already online and
+     * non-blocking by default. If a caller requests `concurrently`, it is
+     * ignored (with a warning) rather than emitted in the SQL.
+     */
+    addIndex(tableName: string, indexName: string, fields?: string[], options?: IndexOptions & CockroachHashShardedIndexOptions): Promise<void>;
+    /**
+     * Remove an index from a table
+     */
+    removeIndex(tableName: string, indexName: string): Promise<void>;
+    /**
+     * Create an index on a table with full options support
+     *
+     * Note: CockroachDB does not support `CREATE INDEX CONCURRENTLY` — index
+     * creation is already online/non-blocking, so a `concurrently` flag (if
+     * present on `indexDef`) is ignored with a warning instead of being
+     * emitted in the SQL.
+     */
+    createIndex(tableName: string, indexDef: {
+        name: string;
+        unique?: boolean;
+        type?: string;
+        using?: string;
+        fields: string[];
+        where?: WhereOptions;
+        expression?: string;
+        include?: string[];
+        concurrently?: boolean;
+        /** Hash-sharded index bucket count (CockroachDB `USING HASH WITH (bucket_count = N)`) */
+        bucketCount?: number;
+        /** Alias for `bucketCount` */
+        shard?: number;
+    }): Promise<void>;
+    /**
+     * Create a GIN index for full-text search
+     * CockroachDB-specific GIN (Generalized Inverted Index) for tsvector
+     */
+    createGINIndex(tableName: string, indexName: string, column: string, options?: {
+        config?: string;
+        storageParameters?: Record<string, string | number>;
+    }): Promise<void>;
+    /**
+     * Create an inverted (GIN) index over a JSONB column so containment/path
+     * queries (`@>`, `->`, `->>`) on it can be index-accelerated. Unlike
+     * {@link createGINIndex} (which wraps the column in `to_tsvector(...)` for
+     * full-text search), this indexes the raw JSONB value directly:
+     * `CREATE [UNIQUE] INVERTED INDEX <name> ON <table> (<column>)`.
+     *
+     * CockroachDB spells inverted indexes as `INVERTED INDEX ... (col)`
+     * (equivalent to Postgres's `USING GIN (col)`); this helper emits the
+     * CockroachDB-native form. Also usable for `ARRAY` columns.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/inverted-indexes
+     */
+    createInvertedIndex(tableName: string, indexName: string, column: string, options?: {
+        ifNotExists?: boolean;
+        storageParameters?: Record<string, string | number>;
+    }): Promise<void>;
+    /**
+     * Build a to_tsvector expression
+     * SQL: to_tsvector([config,] document)
+     */
+    buildTsVector(column: string | string[], config?: string): string;
+    /**
+     * Build a to_tsquery expression
+     * SQL: to_tsquery([config,] query)
+     */
+    buildTsQuery(query: string, config?: string): string;
+    /**
+     * Build a plainto_tsquery expression (for phrase searching)
+     * SQL: plainto_tsquery([config,] query)
+     * Converts a phrase into a tsquery that matches documents containing all the words
+     */
+    buildPlainTsQuery(query: string, config?: string): string;
+    /**
+     * Build a phraseto_tsquery expression (for exact phrase matching)
+     * SQL: phraseto_tsquery([config,] query)
+     * Converts a phrase into a tsquery that matches documents containing the exact phrase
+     */
+    buildPhraseTsQuery(query: string, config?: string): string;
+    /**
+     * Build a websearch_to_tsquery expression (for web search style queries)
+     * SQL: websearch_to_tsquery([config,] query)
+     * Supports web search operators like +, -, "quotes", etc.
+     */
+    buildWebsearchTsQuery(query: string, config?: string): string;
+    /**
+     * Build a ts_rank expression for ranking full-text search results
+     * SQL: ts_rank([weights,] vector, query [, normalization])
+     */
+    buildTsRank(vector: string, query: string, options?: {
+        weights?: number[];
+        normalization?: number;
+    }): string;
+    /**
+     * Create a GIST index for spatial data
+     * CockroachDB GIST (Generalized Search Tree) index for geometry/geography columns
+     */
+    createGISTIndex(tableName: string, indexName: string, column: string, options?: {
+        /** Use geography instead of geometry */
+        geography?: boolean;
+        /** Geometry type constraint (e.g., 'POINT', 'POLYGON') */
+        geometryType?: string;
+        /** SRID constraint (e.g., 4326 for WGS84) */
+        srid?: number;
+        /** Storage parameters */
+        fillFactor?: number;
+    }): Promise<void>;
+    /**
+     * Create a GIN index for spatial data (PostGIS 2.1+)
+     * GIN indexes are slower to build but faster for very large datasets with many overlapping geometries
+     */
+    createGINSpatialIndex(tableName: string, indexName: string, column: string): Promise<void>;
+    /**
+     * ST_Distance - calculate distance between two geometries
+     * For geography, returns distance in meters
+     */
+    stDistance(geom1: string, geom2: string, useGeography?: boolean): string;
+    /**
+     * ST_DWithin - check if geometries are within a given distance
+     * For geography, distance is in meters
+     */
+    stDWithin(geom1: string, geom2: string, distance: number, useGeography?: boolean): string;
+    /**
+     * ST_Within - check if geometry A is within geometry B
+     */
+    stWithin(geom1: string, geom2: string): string;
+    /**
+     * ST_Contains - check if geometry A contains geometry B
+     */
+    stContains(geom1: string, geom2: string): string;
+    /**
+     * ST_Intersects - check if two geometries intersect
+     */
+    stIntersects(geom1: string, geom2: string): string;
+    /**
+     * ST_Crosses - check if two geometries cross
+     */
+    stCrosses(geom1: string, geom2: string): string;
+    /**
+     * ST_Overlaps - check if two geometries overlap
+     */
+    stOverlaps(geom1: string, geom2: string): string;
+    /**
+     * ST_Touches - check if two geometries touch
+     */
+    stTouches(geom1: string, geom2: string): string;
+    /**
+     * ST_Equals - check if two geometries are equal
+     */
+    stEquals(geom1: string, geom2: string): string;
+    /**
+     * ST_IsValid - check if a geometry is valid
+     */
+    stIsValid(geom: string): string;
+    /**
+     * ST_GeomFromText - create geometry from WKT text
+     */
+    stGeomFromText(wkt: string, srid?: number): string;
+    /**
+     * ST_GeomFromGeoJSON - create geometry from GeoJSON
+     */
+    stGeomFromGeoJSON(geojson: string, srid?: number): string;
+    /**
+     * ST_AsGeoJSON - convert geometry to GeoJSON
+     */
+    stAsGeoJSON(geom: string, options?: {
+        precision?: number;
+        longCRS?: boolean;
+    }): string;
+    /**
+     * ST_AsText - convert geometry to WKT
+     */
+    stAsText(geom: string): string;
+    /**
+     * ST_Centroid - get the centroid of a geometry
+     */
+    stCentroid(geom: string): string;
+    /**
+     * ST_Area - calculate the area of a polygon
+     * For geography, returns area in square meters
+     */
+    stArea(geom: string, useGeography?: boolean): string;
+    /**
+     * ST_Length - calculate the length of a line
+     * For geography, returns length in meters
+     */
+    stLength(geom: string, useGeography?: boolean): string;
+    /**
+     * ST_Point - create a point from coordinates
+     */
+    stPoint(long: string, lat: string): string;
+    /**
+     * ST_SetSRID - set the SRID of a geometry
+     */
+    stSetSRID(geom: string, srid: number): string;
+    /**
+     * ST_SRID - get the SRID of a geometry
+     */
+    stSRID(geom: string): string;
+    /**
+     * ST_X - get the X coordinate of a point
+     */
+    stX(geom: string): string;
+    /**
+     * ST_Y - get the Y coordinate of a point
+     */
+    stY(geom: string): string;
+    /**
+     * ST_Distance_Sphere - calculate distance using sphere (less accurate but faster)
+     * Returns distance in meters
+     */
+    stDistanceSphere(geom1: string, geom2: string): string;
+    /**
+     * ST_Distance_Spheroid - calculate distance using spheroid (accurate)
+     * Returns distance in meters
+     */
+    stDistanceSpheroid(geom1: string, geom2: string): string;
+    /**
+     * Drop an index from a table
+     */
+    dropIndex(tableName: string, indexName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a constraint on a table
+     */
+    createConstraint(tableName: string, constraintDef: {
+        name: string;
+        type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
+        fields?: string[];
+        references?: {
+            table: string;
+            field: string;
+            onDelete?: string;
+            onUpdate?: string;
+        };
+        check?: string;
+        deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
+    }): Promise<void>;
+    /**
+     * Drop a constraint from a table
+     */
+    dropConstraint(tableName: string, constraintName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Begin a new transaction
+     */
+    startTransaction(options?: CockroachRunTransactionOptions): Promise<Transaction>;
+    /**
+     * Set the priority of the *current* transaction
+     * (`SET TRANSACTION PRIORITY {LOW|NORMAL|HIGH}`). Must be called on a
+     * transaction's own client, before any statement in the transaction reads or
+     * writes data. Prefer passing `priority` to {@link startTransaction} /
+     * {@link runTransaction}; this helper is for adjusting an already-open
+     * transaction created elsewhere.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/set-transaction
+     */
+    setTransactionPriority(transaction: Transaction, priority: CockroachTransactionPriority): Promise<void>;
+    /**
+     * Run a function inside a CockroachDB transaction, automatically retrying
+     * the *entire transaction body* when it fails with a serialization failure
+     * (SQLSTATE `40001`, surfaced as a "restart transaction" error).
+     *
+     * Under SERIALIZABLE isolation (CockroachDB's default and only isolation
+     * level), conflicting concurrent transactions routinely abort with
+     * `40001`; CockroachDB's documented client contract is to retry the whole
+     * transaction from the beginning rather than treating it as a fatal error.
+     * This implements that contract using the standard
+     * `SAVEPOINT cockroach_restart` pattern: a savepoint is created right after
+     * `BEGIN`, and on a retryable error the transaction is rolled back to that
+     * savepoint (instead of being aborted outright) so `fn` can be re-run.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/transaction-retry-error-reference
+     * @see https://www.cockroachlabs.com/docs/stable/transactions#client-side-intervention
+     *
+     * @param fn - Callback that receives the transaction and performs the work
+     *   to (re)try. It may be invoked more than once, so it should be
+     *   idempotent / avoid externally-visible side effects other than through
+     *   the database.
+     * @param options - Transaction options, plus an optional `maxRetries`
+     *   (defaults to 5) capping how many times `fn` will be retried after a
+     *   `40001` before the error is rethrown.
+     */
+    runTransaction<T>(fn: (tx: CockroachDBTransaction) => Promise<T>, options?: CockroachRunTransactionOptions): Promise<T>;
+    /**
+     * Commit a transaction
+     */
+    commitTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Rollback a transaction
+     */
+    rollbackTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Get the SQL for a data type
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Get the SQL for an ARRAY type
+     */
+    getArrayTypeSql(elementType: DataType): string;
+    /**
+     * Get the isolation level SQL
+     */
+    private getIsolationLevelSql;
+    /**
+     * Build a WHERE clause from a WhereOptions object
+     */
+    buildWhereClause(where: WhereOptions, options?: {
+        replacements?: Record<string, unknown>;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an ORDER BY clause
+     */
+    buildOrderClause(order: Order, options?: {
+        replacements?: Record<string, unknown>;
+    }): string;
+    /**
+     * Build a LIMIT/OFFSET clause
+     */
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    /**
+     * Build an INSERT query with RETURNING support
+     */
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: CockroachInsertOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPSERT query for CockroachDB
+     * Uses `ON CONFLICT ... DO UPDATE SET` syntax by default, or CockroachDB's
+     * native `UPSERT INTO ... VALUES (...)` shorthand when `options.nativeUpsert`
+     * is set (which replaces the row matching the primary key wholesale and
+     * needs no conflict target).
+     * @see https://www.cockroachlabs.com/docs/stable/upsert
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, options?: CockroachUpsertQueryOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an increment query
+     * @param tableName - Table name
+     * @param fields - Fields to increment
+     * @param where - Where clause
+     * @param options - Query options (by: number)
+     */
+    buildIncrementQuery(tableName: string, fields: string | string[] | Record<string, number>, where: WhereOptions, options?: {
+        by?: number;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPDATE query with RETURNING support
+     */
+    buildUpdateQuery(tableName: string, values: Record<string, unknown>, where: WhereOptions, options?: DUpdateOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a DELETE query with RETURNING support
+     */
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Check if a value is a function expression (fn('COUNT', ...))
+     */
+    private isFnExpression;
+    /**
+     * Check if a value is a column expression (col('name'))
+     */
+    private isColExpression;
+    /**
+     * Check if a value is a literal expression (literal('sql'))
+     */
+    /**
+     * Render a literal expression, substituting any `bindings` into its `?`
+     * placeholders with dialect-correct escaping. `literalExpr(sql)` with no
+     * bindings is unchanged; `literalExpr('x > ?', [v])` no longer requires the
+     * caller to concatenate the value into the string themselves.
+     */
+    private literalSql;
+    private isLiteralExpression;
+    /**
+     * Compile a function expression to SQL
+     */
+    private compileFnExpression;
+    /**
+     * Build SELECT clause with support for function expressions and aliases
+     * Handles: 'field', ['field'], ['field', 'alias'], [fn('COUNT', 'id'), 'count']
+     */
+    private buildSelectClause;
+    /**
+     * Build GROUP BY clause with support for function expressions and aliases
+     * Handles: 'field', ['field1', 'field2'], [[fn('COUNT', 'id'), 'count']]
+     */
+    private buildGroupByClause;
+    /**
+     * Build a WHERE clause condition using standard operators (Op.gt, Op.eq, etc.)
+     * CockroachDB uses $1, $2, etc. for parameter placeholders
+     */
+    private buildCondition;
+    /**
+     * Build a HAVING clause with support for standard Op operators
+     */
+    private buildHavingClause;
+    /**
+     * Build the expression used after `AS OF SYSTEM TIME` for CockroachDB
+     * time-travel reads.
+     *
+     * Accepts:
+     *  - A relative interval shorthand, e.g. `'-10s'`, `'-500ms'`, `'-1h'`.
+     *  - An absolute ISO-8601 timestamp, e.g. `'2024-01-01T00:00:00Z'`.
+     *  - The literal function call `follower_read_timestamp()` (unquoted).
+     *
+     * The value is validated against a strict allow-list pattern before being
+     * embedded in the SQL string (rather than passed as a bound parameter,
+     * which CockroachDB's `AS OF SYSTEM TIME` clause does not accept) to avoid
+     * SQL injection.
+     *
+     * @see https://www.cockroachlabs.com/docs/stable/as-of-system-time
+     */
+    private buildAsOfSystemTimeClause;
+    /**
+     * Run a SELECT query as of a historical timestamp using CockroachDB's
+     * `AS OF SYSTEM TIME` time-travel read feature.
+     *
+     * @param options - Standard SelectOptions plus the historical timestamp.
+     * @param asOfSystemTime - Relative interval (e.g. `'-10s'`), ISO timestamp,
+     *   or `'follower_read_timestamp()'`.
+     */
+    queryAsOfSystemTime(options: SelectOptions, asOfSystemTime: string): Promise<QueryResult>;
+    /**
+     * Build a SELECT query with CockroachDB-specific features
+     */
+    buildSelectQuery(options: SelectOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Escape a value for use in a CockroachDB array literal
+     */
+    escapeArray(values: unknown[]): string;
+    /**
+     * Build an array contains operator query (@>)
+     * SELECT * FROM table WHERE column @> ARRAY['elem1', 'elem2']
+     */
+    buildArrayContains(column: string, values: unknown[]): string;
+    /**
+     * Build an array contained by operator query (<@)
+     * SELECT * FROM table WHERE column <@ ARRAY['elem1', 'elem2']
+     */
+    buildArrayContainedBy(column: string, values: unknown[]): string;
+    /**
+     * Build an array overlaps operator query (&&)
+     * SELECT * FROM table WHERE column && ARRAY['elem1', 'elem2']
+     */
+    buildArrayOverlaps(column: string, values: unknown[]): string;
+    /**
+     * Build an array ANY operator query
+     * SELECT * FROM table WHERE 'value' = ANY(column)
+     */
+    buildArrayAny(column: string, value: unknown): string;
+    /**
+     * Build an array ALL operator query
+     * SELECT * FROM table WHERE 'value' = ALL(column)
+     * or with comparison: SELECT * FROM table WHERE value > ALL(column)
+     */
+    buildArrayAll(column: string, value: unknown, operator?: string): string;
+    /**
+     * Build a full-text search query
+     */
+    buildFullTextSearchQuery(tableName: string, searchColumns: string[], searchTerm: string, options?: {
+        language?: string;
+        ranking?: 'ts_rank' | 'ts_rank_cd';
+        orderBy?: Order;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON/JSONB path query
+     */
+    buildJsonPathQuery(column: string, path: string, value: unknown, operator: '=' | '!=' | '>' | '<' | '>=' | '<=' | '~' | '~*' | '@>' | '<@' | '?' | '?|'): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Get CockroachDB specific lock options
+     */
+    getLockOptions(lock: any): {
+        sql: string;
+        params: unknown[];
+    };
+    /**
+     * Escape a single-quoted string value (replace ' with '').
+     */
+    private escapeStringValue;
+    /**
+     * Build the shared WITH-clause attribute list used by both CREATE USER and
+     * ALTER USER.  Returns a (possibly empty) array of attribute tokens.
+     */
+    private buildUserAttributes;
+    /**
+     * Build a CREATE USER statement.
+     *
+     * CockroachDB treats users as roles with LOGIN.  Supported options:
+     *   ifNotExists, password, superuser, createdb, createrole, login,
+     *   replication, bypassrls, maxConnections, accountLocked, expirePassword,
+     *   defaultRole, requireSSL (noted but skipped — not a standard PG attribute).
+     */
+    buildCreateUserQuery(username: string, options?: any): string;
+    /**
+     * Build an ALTER USER statement.
+     *
+     * Supports the same attribute options as buildCreateUserQuery plus
+     * `options.renameTo` to rename the role.
+     */
+    buildAlterUserQuery(username: string, options: any): string;
+    /**
+     * Build a DROP USER statement.
+     *
+     * Options: ifExists, cascade, restrict.
+     */
+    buildDropUserQuery(username: string, options?: any): string;
+    /**
+     * Return a query that lists all CockroachDB users (roles with LOGIN).
+     */
+    getUsersQuery(): string;
+    /**
+     * Create a database user
+     */
+    createUser(username: string, options?: Record<string, any>): Promise<void>;
+    /**
+     * Map a generic privilege name to a CockroachDB privilege name.
+     * Returns null when the privilege has no CockroachDB equivalent and
+     * should be silently skipped.
+     */
+    private mapPrivilege;
+    /**
+     * Build the ON <scope> clause for GRANT / REVOKE.
+     *
+     * Scope shapes:
+     *   { level: 'global' }
+     *   { level: 'database', database: 'dbname' }
+     *   { level: 'schema',   schema: 'schemaname' }
+     *   { level: 'table',    table: 'tablename' }
+     *   { level: 'column',   table: 'tablename', columns: ['col1', 'col2'] }
+     *   { level: 'sequence', schema: 'schemaname' }
+     */
+    private buildGrantScope;
+    /**
+     * Build a GRANT statement.
+     *
+     * options.privileges  — string | string[]  (e.g. ['SELECT', 'INSERT'])
+     * options.on          — scope object (see buildGrantScope)
+     * options.to          — string | string[]  (grantees)
+     * options.withGrantOption — boolean
+     * options.asUser      — string (GRANTED BY, PG 14+)
+     *
+     * For column-level grants (options.on.level === 'column') the columns are
+     * embedded in each privilege token: SELECT (col1, col2).
+     */
+    buildGrantQuery(options: any): string;
+    /**
+     * Build a REVOKE statement.
+     *
+     * options.privileges      — string | string[]
+     * options.on              — scope object (same as buildGrantQuery)
+     * options.from            — string | string[]  (revokees)
+     * options.grantOptionFor  — boolean (revoke only the GRANT OPTION)
+     * options.cascade         — boolean
+     * options.restrict        — boolean
+     */
+    buildRevokeQuery(options: any): string;
+    /**
+     * Return a query that shows the privileges granted to a specific user/role.
+     * The optional `host` parameter is ignored — CockroachDB has no host concept.
+     */
+    buildShowGrantsQuery(username: string, _host?: string): string;
+    /**
+     * CockroachDB applies privilege changes automatically — FLUSH PRIVILEGES is
+     * a MySQL concept.  Return a no-op with an explanatory comment.
+     */
+    buildFlushPrivilegesQuery(): string;
+    /**
+     * Build a CREATE ROLE statement.
+     *
+     * Unlike CREATE USER, NOLOGIN is the default for roles.  Pass
+     * `options.login = true` to enable login.
+     *
+     * Supported options: ifNotExists, login, password, superuser, createdb,
+     * createrole, inherit, replication, bypassrls, maxConnections,
+     * expirePassword, accountLocked.
+     */
+    buildCreateRoleQuery(roleName: string, options?: any): string;
+    /**
+     * Build a DROP ROLE statement.
+     *
+     * Options: ifExists, cascade.
+     */
+    buildDropRoleQuery(roleName: string, options?: any): string;
+    /**
+     * Build a GRANT <role> TO <members> statement.
+     *
+     * Options: withAdminOption.
+     */
+    buildGrantRoleQuery(role: string, to: string | string[], options?: any): string;
+    /**
+     * Build a REVOKE <role> FROM <members> statement.
+     *
+     * Options: adminOptionFor, cascade.
+     */
+    buildRevokeRoleQuery(role: string, from: string | string[], options?: any): string;
+    /**
+     * Return a query that lists all CockroachDB roles that cannot log in
+     * (i.e. "group roles" as opposed to user roles).
+     */
+    getRolesQuery(): string;
+    /**
+     * Generate SQL for creating a CockroachDB database
+     */
+    createDatabaseSQL(options: {
+        name: string;
+        encoding?: string;
+        lcCollate?: string;
+        lcCtype?: string;
+        template?: string;
+        tablespace?: string;
+        isTemplate?: boolean;
+    }): string;
+    /**
+     * Generate SQL for dropping a CockroachDB database
+     */
+    dropDatabaseSQL(name: string): string;
+    /**
+     * Generate SQL for creating a savepoint
+     */
+    createSavepointSQL(name?: string): string;
+    /**
+     * Generate SQL for releasing a savepoint
+     */
+    releaseSavepointSQL(name: string): string;
+    /**
+     * Generate SQL for rolling back to a savepoint
+     */
+    rollbackToSavepointSQL(name: string): string;
+    /**
+     * Build a JSON_TABLE-equivalent expression to shred a JSON array into relational rows.
+     * Not supported: CockroachDB implements a subset of Postgres's JSONB function surface
+     * and has neither a native `JSON_TABLE` (PG17+) nor `json_to_recordset`/
+     * `jsonb_to_recordset` (verified absent from CockroachDB's function reference as of
+     * v23.x/v24.x). There is no row-shredding equivalent to fall back to.
+     */
+    buildJsonTable(_jsonExpression: string, _rowPath: string, _columns: Array<{
+        name: string;
+        type?: string;
+        path?: string;
+        forOrdinality?: boolean;
+    }>, _alias: string): string;
+}
+/**
+ * CockroachDB-specific transaction class with isolation level support and savepoints
+ */
+export declare class CockroachDBTransaction implements Transaction {
+    id: string;
+    finished: boolean;
+    options: TransactionOptions;
+    parent: Transaction | null;
+    savepoints: string[];
+    client: PoolClient | null;
+    private savepointCount;
+    constructor(client: PoolClient, depth: number, options?: TransactionOptions);
+    /**
+     * Create a savepoint
+     */
+    createSavepoint(name?: string): Promise<string>;
+    /**
+     * Rollback to a savepoint
+     */
+    rollbackToSavepoint(name: string): Promise<void>;
+    /**
+     * Release a savepoint
+     */
+    releaseSavepoint(name: string): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+export interface CockroachDBDialectOptions extends DialectOptions {
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    ssl?: any;
+    max?: number;
+    idleTimeoutMillis?: number;
+    connectionTimeoutMillis?: number;
+    statementTimeout?: number;
+    queryTimeout?: number;
+    types?: any;
+}
+/**
+ * Create a new CockroachDB dialect instance
+ */
+export declare function createCockroachDBDialect(options?: CockroachDBDialectOptions): CockroachDBDialect;
+export default CockroachDBDialect;