ts-prorm-orm 1.1.0 → 1.2.0

package/dist/dialects/dialect.d.ts

@@ -0,0 +1,1653 @@
+/**
+ * Base dialect interface for the ORM
+ * Each database dialect implements this interface
+ */
+import { Transaction, TransactionOptions, QueryResult, QueryOptions, DataType, WhereOptions, Order, IncludeOptions, PartitionBound, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions, RefreshOptions, MaterializedViewOptions, DropMaterializedViewOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, TriggerOptions, DropTriggerOptions, SequenceOptions, DropSequenceOptions, PolicyOptions, DropPolicyOptions, StreamOptions } from '../types';
+import type { Readable } from 'stream';
+export interface Dialect {
+    /**
+     * The name of the dialect
+     */
+    readonly name: string;
+    /**
+     * The database library or driver being used
+     */
+    readonly library: string;
+    /**
+     * Connect to the database
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get the current connection
+     */
+    getConnection(): any;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Execute a raw query
+     * @param sql - The SQL query string
+     * @param options - Query options
+     */
+    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * Execute a query and stream the results back as a Node.js Readable
+     * (object mode — one row, or one model instance when `options.mapToModel`
+     * is set, per chunk) instead of buffering the whole result set in memory.
+     * Used by `Model.findAllStream()`/`findAllIterate()` for processing large
+     * tables without loading them all into memory at once.
+     *
+     * Native server-side cursor support (postgres/mysql/cockroachdb) is used
+     * where the driver has it; other dialects fall back to LIMIT/OFFSET-paged
+     * queries — correct and dialect-agnostic, though it does more round trips
+     * than a real cursor for very large result sets.
+     * @param sql - The SQL query string to stream results for
+     * @param options - Streaming options (batch size, backpressure watermark, model mapping)
+     * @example
+     * const stream = dialect.queryStream('SELECT * FROM users', { batchSize: 500 });
+     * for await (const row of stream) { console.log(row); }
+     */
+    queryStream(sql: string, options?: StreamOptions): Readable;
+    /**
+     * Escape a value for use in a query
+     * @param value - The value to escape
+     */
+    escape(value: any): string;
+    /**
+     * Escape an identifier (table name, column name, etc.)
+     * @param identifier - The identifier to escape
+     */
+    escapeId(identifier: string): string;
+    /**
+     * Quote an identifier (column name, table name)
+     * @param identifier - The identifier to quote
+     */
+    quoteIdentifier(identifier: string): string;
+    /**
+     * Quote a table name
+     * @param tableName - The table name to quote
+     * @param schema - Optional schema to prefix the table with
+     */
+    quoteTable(tableName: string, schema?: string): string;
+    /**
+     * Create a schema
+     * @param schema - The schema name to create
+     */
+    createSchema(schema: string): Promise<void>;
+    /**
+     * Drop a 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[]>;
+    /**
+     * Generate SQL for creating a database
+     * @param options - Database creation options
+     */
+    createDatabaseSQL(options: {
+        name: string;
+        encoding?: string;
+        lcCollate?: string;
+        lcCtype?: string;
+        template?: string;
+        tablespace?: string;
+        collate?: string;
+        isTemplate?: boolean;
+    }): string;
+    /**
+     * Generate SQL for dropping a database
+     * @param name - Database name to drop
+     */
+    dropDatabaseSQL(name: string): string;
+    /**
+     * Generate SQL for creating a savepoint
+     * @param name - Savepoint name (optional, will be generated if not provided)
+     */
+    createSavepointSQL(name?: string): string;
+    /**
+     * Generate SQL for releasing a savepoint
+     * @param name - Savepoint name to release
+     */
+    releaseSavepointSQL(name: string): string;
+    /**
+     * Generate SQL for rolling back to a savepoint
+     * @param name - Savepoint name to rollback to
+     */
+    rollbackToSavepointSQL(name: string): string;
+    /**
+     * Create a PostgreSQL extension
+     * @param extensionName - Name of the extension to create
+     * @param options - Extension options
+     */
+    createExtension(extensionName: string, options?: CreateExtensionOptions): Promise<void>;
+    /**
+     * Drop a PostgreSQL extension
+     * @param extensionName - Name of the extension to drop
+     * @param options - Drop options
+     */
+    dropExtension(extensionName: string, options?: DropExtensionOptions): Promise<void>;
+    /**
+     * Get all installed PostgreSQL extensions
+     * @returns Array of extension information
+     */
+    getExtensions(): Promise<ExtensionInfo[]>;
+    /**
+     * Check if a PostgreSQL extension is installed
+     * @param extensionName - Name of the extension
+     * @returns True if the extension is installed
+     */
+    hasExtension(extensionName: string): Promise<boolean>;
+    /**
+     * Get database version
+     */
+    getDatabaseVersion(): Promise<string>;
+    /**
+     * Create a new table
+     * @param tableName - Name of the table
+     * @param columns - Column definitions
+     * @param options - Additional options
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions): Promise<void>;
+    /**
+     * Drop a table
+     * @param tableName - Name of the table
+     * @param options - Additional options
+     */
+    dropTable(tableName: string, options?: DropTableOptions): Promise<void>;
+    /**
+     * Create a partitioned table (PostgreSQL 10+)
+     * @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?: {
+            name: string;
+            bound?: PartitionBound;
+            tablespace?: string;
+            storageParameters?: Record<string, string | number>;
+        }[];
+    }): Promise<void>;
+    /**
+     * Create a partition for an existing partitioned table (PostgreSQL 10+)
+     * @param options - Partition creation options
+     */
+    createPartition(options: CreatePartitionOptions): Promise<void>;
+    /**
+     * Attach a partition to a partitioned table (PostgreSQL 11+)
+     * @param options - Partition attachment options
+     */
+    attachPartition(options: AttachPartitionOptions): Promise<void>;
+    /**
+     * Detach a partition from a partitioned table (PostgreSQL 11+)
+     * @param options - Partition detachment options
+     */
+    detachPartition(options: DetachPartitionOptions): Promise<void>;
+    /**
+     * Drop a partition (PostgreSQL 10+)
+     * @param partitionName - Name of the partition to drop
+     * @param options - Drop options
+     */
+    dropPartition(partitionName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a database view
+     * @param viewName - Name of the view to create
+     * @param query - The SELECT query for the view
+     * @param options - View options (e.g., replace if exists)
+     */
+    createView(viewName: string, query: string, options?: ViewOptions): Promise<void>;
+    /**
+     * Drop a database view
+     * @param viewName - Name of the view to drop
+     * @param options - Drop options
+     */
+    dropView(viewName: string, options?: DropViewOptions): Promise<void>;
+    /**
+     * Add a column to a table
+     * @param tableName - Name of the table
+     * @param columnName - Name of the new column
+     * @param definition - Column definition
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Remove a column from a table
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column to remove
+     */
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    /**
+     * Change a column definition
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column to change
+     * @param definition - New column definition
+     */
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Rename a column
+     * @param tableName - Name of the table
+     * @param oldColumnName - Current column name
+     * @param newColumnName - New column name
+     */
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string): Promise<void>;
+    /**
+     * Add a foreign key to a table
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column
+     * @param referencedTableName - Name of the referenced table
+     * @param referencedColumnName - Name of the referenced column
+     * @param options - Foreign key options
+     */
+    addForeignKey(tableName: string, columnName: string, referencedTableName: string, referencedColumnName: string, options?: any): Promise<void>;
+    /**
+     * Bulk insert records into a table
+     * @param tableName - Name of the table
+     * @param records - Array of records to insert
+     * @param options - Insert options
+     */
+    bulkInsert(tableName: string, records: Record<string, any>[], options?: any): Promise<QueryResult>;
+    /**
+     * Show all tables in the database
+     */
+    showTables(): Promise<string[]>;
+    /**
+     * Show all views in the database
+     */
+    showViews(): Promise<string[]>;
+    /**
+     * Show constraints for a table
+     */
+    showConstraints(tableName: string): Promise<any[]>;
+    /**
+     * Add a constraint to a table
+     */
+    addConstraint(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    /**
+     * Remove a constraint from a table
+     */
+    removeConstraint(tableName: string, constraintName: string): Promise<void>;
+    /**
+     * Show indexes for a table
+     */
+    showIndexes(tableName: string): Promise<any[]>;
+    /**
+     * Describe a table (get column information)
+     * @param tableName - Name of the table
+     */
+    describeTable(tableName: string): Promise<TableDescription>;
+    /**
+     * Rename a table
+     * @param oldName - Current table name
+     * @param newName - New table name
+     */
+    renameTable(oldName: string, newName: string): Promise<void>;
+    /**
+     * Add an index to a table
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index
+     * @param fields - Fields to index
+     * @param options - Index options
+     */
+    addIndex(tableName: string, indexName: string, fields: string[], options?: IndexOptions): Promise<void>;
+    /**
+     * Remove an index from a table
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index
+     */
+    removeIndex(tableName: string, indexName: string): Promise<void>;
+    /**
+     * Create an index on a table with full options support
+     * @param tableName - Name of the table
+     * @param indexDef - Index definition
+     */
+    createIndex(tableName: string, indexDef: IndexDefinition): Promise<void>;
+    /**
+     * Create a fulltext index on a table
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index
+     * @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 on a table
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index
+     * @param fields - Fields to index
+     * @param options - Spatial index options
+     */
+    createSpatialIndex(tableName: string, indexName: string, fields: string[], options?: {
+        storage?: string;
+        srid?: number;
+    }): Promise<void>;
+    /**
+     * Drop an index from a table
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index
+     * @param options - Drop options
+     */
+    dropIndex(tableName: string, indexName: string, options?: DropIndexOptions): Promise<void>;
+    /**
+     * Create a constraint on a table
+     * @param tableName - Name of the table
+     * @param constraintDef - Constraint definition
+     */
+    createConstraint(tableName: string, constraintDef: ConstraintDefinition): Promise<void>;
+    /**
+     * Drop a constraint from a table
+     * @param tableName - Name of the table
+     * @param constraintName - Name of the constraint
+     * @param options - Drop options
+     */
+    dropConstraint(tableName: string, constraintName: string, options?: DropConstraintOptions): Promise<void>;
+    /**
+     * Change owner of a table or view
+     */
+    changeOwner(newOwner: string, tableName: string): Promise<void>;
+    /**
+     * Create a foreign data wrapper (PostgreSQL)
+     */
+    createForeignDataWrapper(fdwName: string, options?: {
+        handler?: string;
+    }): Promise<void>;
+    /**
+     * Drop a foreign data wrapper (PostgreSQL)
+     */
+    dropForeignDataWrapper(fdwName: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a foreign server (PostgreSQL)
+     */
+    createForeignServer(serverName: string, fdwName: string, options?: {
+        options?: Record<string, string>;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Drop a foreign server (PostgreSQL)
+     */
+    dropForeignServer(serverName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a foreign table (PostgreSQL)
+     */
+    createForeignTable(tableName: string, columns: Record<string, {
+        type: string;
+    }>, options?: {
+        serverName?: string;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a security policy (MSSQL Row-Level Security)
+     */
+    createSecurityPolicy(policyName: string, tableName: string, options?: {
+        predicate?: string;
+    }): Promise<void>;
+    /**
+     * Drop a security policy (MSSQL Row-Level Security)
+     */
+    dropSecurityPolicy(policyName: string, tableName: string): Promise<void>;
+    /**
+     * Begin a new transaction
+     * @param options - Transaction options
+     */
+    startTransaction(options?: TransactionOptions): Promise<Transaction>;
+    /**
+     * Commit a transaction
+     * @param transaction - The transaction to commit
+     */
+    commitTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Rollback a transaction
+     * @param transaction - The transaction to rollback
+     */
+    rollbackTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Get the SQL for a data type
+     * @param dataType - The data type
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Build a WHERE clause from a WhereOptions object
+     * @param where - The where options
+     * @param options - Build options
+     */
+    buildWhereClause(where: WhereOptions, options?: BuildOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build an ORDER BY clause
+     * @param order - The order options
+     * @param options - Build options
+     */
+    buildOrderClause(order: Order, options?: BuildOptions): string;
+    /**
+     * Build a LIMIT/OFFSET clause
+     * @param limit - Limit value
+     * @param offset - Offset value
+     */
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    /**
+     * Build an INSERT query
+     * @param tableName - Table name
+     * @param values - Values to insert
+     * @param options - Query options
+     */
+    buildInsertQuery(tableName: string, values: Record<string, any>, options?: InsertOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build an UPDATE query
+     * @param tableName - Table name
+     * @param values - Values to update
+     * @param where - Where clause
+     * @param options - Query options
+     */
+    buildUpdateQuery(tableName: string, values: Record<string, any>, where: WhereOptions, options?: UpdateOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build a DELETE query
+     * @param tableName - Table name
+     * @param where - Where clause
+     * @param options - Query options
+     */
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build a SELECT query
+     * @param options - Select options
+     */
+    buildSelectQuery(options: SelectOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build an UPSERT query (insert or update on conflict)
+     * @param tableName - Table name
+     * @param values - Values to insert/update
+     * @param options - Upsert options
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, any>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build an increment query
+     * @param tableName - Table name
+     * @param fields - Fields to increment (field name or array of field names, or object with values)
+     * @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: any[];
+    };
+    /**
+     * Replace placeholders in SQL with actual values
+     * Supports both named (:param) and positional (?) placeholders
+     * @param sql - SQL string with placeholders
+     * @param replacements - Values to replace (object for named, array for positional)
+     * @returns SQL with placeholders replaced with escaped values
+     */
+    replaceReplacements(sql: string, replacements?: Record<string, unknown> | unknown[]): string;
+    buildCreateServerQuery(name: string, opts: FdwForeignServerOptions): string;
+    buildAlterServerQuery(name: string, opts: FdwAlterForeignServerOptions): string;
+    buildDropServerQuery(name: string, opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): 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
+     * @param userName - User name
+     * @param serverName - Foreign server name
+     * @param options - User mapping options
+     */
+    createUserMapping(userName: string, serverName: string, options?: any): Promise<void>;
+    /**
+     * Drop a user mapping for a foreign server
+     * @param userName - User name
+     * @param serverName - Foreign server name
+     */
+    dropUserMapping(userName: string, serverName: string, options?: any): 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;
+    getServersQuery(): string;
+    buildCreateUserQuery(username: string, options?: any): string;
+    buildAlterUserQuery(username: string, options: any): string;
+    buildDropUserQuery(username: string, options?: any): string;
+    getUsersQuery(): string;
+    buildGrantQuery(options: any): string;
+    buildRevokeQuery(options: any): string;
+    buildShowGrantsQuery(username: string, host?: string): string;
+    buildFlushPrivilegesQuery(): string;
+    buildCreateRoleQuery(roleName: string, options?: any): string;
+    buildDropRoleQuery(roleName: string, options?: any): string;
+    buildGrantRoleQuery(role: string, to: any, options?: any): string;
+    buildRevokeRoleQuery(role: string, from: any, options?: any): string;
+    getRolesQuery(): string;
+    createStoredProcedure(options: StoredProcedureOptions): Promise<void>;
+    createProcedure(options: StoredProcedureOptions): Promise<void>;
+    dropStoredProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    dropProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>;
+}
+export interface ColumnDefinition {
+    type: DataType;
+    allowNull?: boolean;
+    defaultValue?: any;
+    primaryKey?: boolean;
+    autoIncrement?: boolean;
+    unique?: boolean | string;
+    references?: {
+        table: string;
+        field: string | string[];
+        onDelete?: string;
+        onUpdate?: string;
+    };
+    comment?: string;
+    /** Column-level character set (MySQL/MariaDB, e.g. 'utf8mb4') */
+    charset?: string;
+    /** Column-level collation (MySQL/MariaDB, e.g. 'utf8mb4_unicode_ci') */
+    collate?: string;
+    /**
+     * SQL Server: mark the column as `SPARSE`. Sparse columns optimize storage
+     * for columns whose values are NULL most of the time, at the cost of extra
+     * storage overhead for non-NULL values. Only valid on nullable columns —
+     * SQL Server requires `SPARSE` columns to allow NULL.
+     */
+    sparse?: boolean;
+    /**
+     * Marks the column INVISIBLE (MySQL 8.0+ / MariaDB 10.3+). Invisible
+     * columns are hidden from `SELECT *` and don't require a value on
+     * INSERT, which makes them useful for zero-downtime column rollout: add
+     * the column invisible, backfill it, then flip it visible once ready.
+     * Columns are visible by default (false/undefined).
+     */
+    invisible?: boolean;
+}
+export interface TableOptions {
+    ifNotExists?: boolean;
+    engine?: string;
+    charset?: string;
+    collate?: string;
+    comment?: string;
+    initialAutoIncrement?: number;
+    /** Row format for MySQL/MariaDB (e.g., 'DYNAMIC', 'FIXED', 'COMPRESSED') */
+    rowFormat?: string;
+    indexes?: TableIndex[];
+    constraints?: TableConstraint[];
+    /** Unique keys to create with the table */
+    uniqueKeys?: Record<string, string[]>;
+    /** PostgreSQL tablespace */
+    tablespace?: string;
+    /** PostgreSQL: inherit from parent table */
+    inherit?: string;
+    /** PostgreSQL: partition by clause */
+    partitionBy?: string;
+    /**
+     * System-versioned (temporal/bitemporal history) table support, e.g.
+     * MariaDB/SQL Server `SYSTEM_VERSIONING = ON` (plain `boolean`) or SAP
+     * HANA `PERIOD FOR SYSTEM_TIME (...) WITH SYSTEM VERSIONING`, which also
+     * accepts a config object naming the history table and period columns.
+     * Dialects that don't support system-versioned tables should ignore this
+     * option.
+     */
+    systemVersioning?: boolean | {
+        /** Name of the history table that stores prior row versions. When
+         * omitted, the dialect's default/implicit history table naming
+         * applies (e.g. HANA auto-generates one when no `HISTORY TABLE`
+         * clause is given). */
+        historyTable?: string;
+        /** Name of the "row start"/valid-from period column. Defaults to
+         * `valid_from` when omitted. */
+        validFromColumn?: string;
+        /** Name of the "row end"/valid-to period column. Defaults to
+         * `valid_to` when omitted. */
+        validToColumn?: string;
+    };
+}
+export interface TableIndex {
+    name?: string;
+    unique?: boolean;
+    type?: string;
+    using?: string;
+    fields: string[];
+    where?: WhereOptions;
+    /** Expression for expression-based indexes (e.g., LOWER(column)) */
+    expression?: string;
+    /** Include columns for covering index (PostgreSQL 11+, MySQL 8.0.17+) */
+    include?: string[];
+}
+export interface TableConstraint {
+    name?: string;
+    type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
+    fields?: string[];
+    references?: {
+        table: string;
+        field: string | string[];
+        onDelete?: string;
+        onUpdate?: string;
+    };
+    check?: string;
+}
+export interface DropTableOptions {
+    ifExists?: boolean;
+    cascade?: boolean;
+}
+export interface TableDescription {
+    [columnName: string]: {
+        type: string;
+        allowNull: boolean;
+        defaultValue: any;
+        primaryKey: boolean;
+        autoIncrement: boolean;
+    };
+}
+export interface IndexOptions {
+    /** Explicit index name (used by the `(tableName, fields, options)` addIndex shorthand) */
+    name?: string;
+    unique?: boolean;
+    type?: string;
+    using?: string;
+    where?: WhereOptions;
+    /** Expression for expression-based indexes (e.g., LOWER(column)) */
+    expression?: string;
+    /** Include columns for covering index (PostgreSQL 11+, MySQL 8.0.17+) */
+    include?: string[];
+    /** If true, does not throw error if index already exists */
+    ifNotExists?: boolean;
+    /** Oracle: tablespace for the index */
+    tablespace?: string;
+    /** Oracle: compress index storage */
+    compress?: boolean | number;
+    /**
+     * Create the index as invisible/ignored to the query optimizer (MySQL
+     * 8.0+ uses `INVISIBLE`; MariaDB 10.6+ uses `IGNORED` — the keyword
+     * differs between the two dialects even though the concept is the
+     * same). Useful for zero-downtime index rollout: add the index
+     * invisible, let it build and backfill, then flip it visible once
+     * verified. Indexes are visible/not-ignored by default.
+     */
+    invisible?: boolean;
+}
+export interface IndexDefinition {
+    name: string;
+    unique?: boolean;
+    type?: string;
+    using?: string;
+    fields: string[];
+    where?: WhereOptions;
+    /** See {@link IndexOptions.invisible}. */
+    invisible?: boolean;
+}
+export interface DropIndexOptions {
+    ifExists?: boolean;
+    cascade?: boolean;
+}
+export interface ConstraintDefinition {
+    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';
+}
+export interface DropConstraintOptions {
+    ifExists?: boolean;
+    cascade?: boolean;
+}
+/**
+ * Options for creating a view
+ */
+export interface ViewOptions {
+    /** If true, replaces an existing view with the same name */
+    replace?: boolean;
+    /** Optional comment for the view */
+    comment?: string;
+    /** Schema to create the view in (PostgreSQL) */
+    schema?: string;
+}
+/**
+ * Options for dropping a view
+ */
+export interface DropViewOptions {
+    /** If true, does not throw error if view does not exist */
+    ifExists?: boolean;
+    /** If true, also drops dependent views (PostgreSQL) */
+    cascade?: boolean;
+}
+export interface DropSchemaOptions {
+    ifExists?: boolean;
+    cascade?: boolean;
+}
+/**
+ * Options for creating a PostgreSQL extension
+ */
+export interface CreateExtensionOptions {
+    /** If true, uses CREATE EXTENSION IF NOT EXISTS */
+    ifNotExists?: boolean;
+    /** Schema to install the extension into */
+    schema?: string;
+    /** Version of the extension to install */
+    version?: string;
+}
+/**
+ * Options for dropping a PostgreSQL extension
+ */
+export interface DropExtensionOptions {
+    /** If true, uses DROP EXTENSION IF EXISTS */
+    ifExists?: boolean;
+    /** If true, uses CASCADE to drop dependent objects */
+    cascade?: boolean;
+}
+/**
+ * Extension information returned by getExtensions
+ */
+export interface ExtensionInfo {
+    name: string;
+    defaultVersion: string | null;
+    installedVersion: string | null;
+    comment: string | null;
+}
+/**
+ * Options for creating a PostgreSQL enum type (`CREATE TYPE name AS ENUM (...)`)
+ */
+export interface CreateEnumTypeOptions {
+    /** Schema to create the type in */
+    schema?: string;
+    /**
+     * If true, checks whether the type already exists first (via `pg_type`) and
+     * skips creation if so. Postgres has no native `CREATE TYPE IF NOT EXISTS`.
+     */
+    ifNotExists?: boolean;
+}
+/**
+ * Options for dropping a PostgreSQL type (`DROP TYPE ...`)
+ */
+export interface DropTypeOptions {
+    /** If true, uses DROP TYPE IF EXISTS */
+    ifExists?: boolean;
+    /** If true, uses CASCADE to drop dependent objects */
+    cascade?: boolean;
+    /** Schema the type lives in */
+    schema?: string;
+}
+/**
+ * Options for creating a PostgreSQL domain (`CREATE DOMAIN name AS base_type ...`)
+ */
+export interface CreateDomainOptions {
+    /** Schema to create the domain in */
+    schema?: string;
+    /**
+     * Optional default value. Strings are single-quoted and escaped unless they
+     * look like a raw SQL expression (wrapped in the caller's own quoting is
+     * not performed automatically for anything other than plain strings).
+     */
+    default?: string | number | boolean;
+    /** Emits `COLLATE collation` */
+    collation?: string;
+    /** Emits `NOT NULL` (mutually exclusive in intent with allowing NULL, but Postgres allows either) */
+    notNull?: boolean;
+    /**
+     * One or more `CHECK` expressions, e.g. `['VALUE > 0']`, each emitted as
+     * `CONSTRAINT name CHECK (expression)` when a corresponding name is given,
+     * or a bare `CHECK (expression)` otherwise.
+     */
+    checks?: Array<{
+        name?: string;
+        expression: string;
+    }>;
+}
+/**
+ * Options for dropping a PostgreSQL domain (`DROP DOMAIN ...`)
+ */
+export interface DropDomainOptions {
+    /** If true, uses DROP DOMAIN IF EXISTS */
+    ifExists?: boolean;
+    /** If true, uses CASCADE to drop dependent objects */
+    cascade?: boolean;
+    /** Schema the domain lives in */
+    schema?: string;
+}
+export interface ViewOptions {
+    /** Replace the view if it already exists (CREATE OR REPLACE) */
+    replace?: boolean;
+    /** Materialized view (PostgreSQL) */
+    materialized?: boolean;
+    /** View comment */
+    comment?: string;
+}
+export interface FdwForeignServerOptions {
+    fdw: string;
+    options?: Record<string, string>;
+    version?: string;
+    ifNotExists?: boolean;
+}
+export interface FdwAlterForeignServerOptions {
+    options?: Record<string, string>;
+    addOptions?: Record<string, string>;
+    setOptions?: Record<string, string>;
+    dropOptions?: string[];
+    version?: string;
+}
+export interface FdwUserMappingOptions {
+    serverName: string;
+    user: string;
+    options?: Record<string, string>;
+    ifNotExists?: boolean;
+}
+export interface FdwForeignTableColumnDef {
+    type: string;
+    options?: string;
+}
+export interface FdwForeignTableOptions {
+    serverName: string;
+    schema?: string;
+    columns: Record<string, FdwForeignTableColumnDef>;
+    options?: Record<string, string>;
+    ifNotExists?: boolean;
+}
+export interface FdwImportForeignSchemaOptions {
+    localSchema?: string;
+    limitTo?: string[];
+    except?: string[];
+    options?: Record<string, string>;
+}
+export interface DropViewOptions {
+    ifExists?: boolean;
+    cascade?: boolean;
+}
+export interface BuildOptions {
+    replacements?: Record<string, any>;
+    model?: any;
+    include?: IncludeOptions[];
+}
+export interface InsertOptions {
+    /** Schema to use for the table */
+    schema?: string;
+    returning?: boolean | string[];
+    upsert?: boolean;
+    conflictFields?: string[];
+    /** Fields to update on conflict (MySQL: ON DUPLICATE KEY UPDATE, PostgreSQL/SQLite: ON CONFLICT DO UPDATE, MariaDB: ON DUPLICATE KEY UPDATE) */
+    updateOnDuplicate?: string[];
+}
+export interface UpsertQueryOptions {
+    /** Fields to use for conflict resolution (ON CONFLICT for PostgreSQL/SQLite, ON DUPLICATE KEY for MySQL/MariaDB) */
+    conflictFields?: string[];
+    /** Schema to use for the table */
+    schema?: string;
+    /** Fields to update on conflict. If not specified, all fields will be updated */
+    updateOnDuplicate?: string[];
+    /** Whether to return the record after upsert */
+    returning?: boolean | string[];
+    /** Model raw attributes for type casting */
+    model?: any;
+}
+export interface UpdateOptions {
+    limit?: number;
+    returning?: boolean | string[];
+}
+export interface DeleteOptions {
+    limit?: number;
+    returning?: boolean | string[];
+    truncate?: boolean;
+}
+export interface SelectOptions {
+    tableName: string;
+    /** Schema to use for the table */
+    schema?: string;
+    attributes?: string[] | {
+        include?: string[];
+        exclude?: string[];
+    };
+    where?: WhereOptions;
+    include?: IncludeOptions[];
+    order?: Order;
+    limit?: number | string;
+    offset?: number | string;
+    group?: string | string[];
+    having?: WhereOptions;
+    raw?: boolean;
+    lock?: any;
+    subQuery?: boolean;
+    benchmark?: boolean;
+    distinct?: boolean;
+    /** Column to use with DISTINCT for count queries (e.g., COUNT(DISTINCT col)) */
+    col?: string;
+    distinctOn?: string[];
+    /**
+     * When true, uses table aliases to distinguish duplicate column names
+     * This is needed when including multiple tables that have columns with the same name
+     */
+    duplicate?: boolean;
+    /**
+     * UNION type for combining multiple queries
+     */
+    unionType?: 'UNION' | 'UNION ALL' | 'EXCEPT' | 'INTERSECT';
+    /**
+     * Array of union queries to combine with the main query
+     */
+    union?: Array<{
+        model: any;
+        where?: WhereOptions;
+        attributes?: string[] | {
+            include?: string[];
+            exclude?: string[];
+        };
+        order?: Order;
+        limit?: number | string;
+        offset?: number | string;
+        include?: IncludeOptions[];
+        as?: string;
+    }>;
+    /**
+     * Common Table Expressions (CTEs) to prepend to the query as a `WITH` clause.
+     * Each entry becomes `name [(columns)] AS (query)`. If any entry sets
+     * `recursive: true`, the whole clause is emitted as `WITH RECURSIVE`.
+     */
+    cte?: CTEOption[];
+    /**
+     * PostgreSQL `TABLESAMPLE` clause, appended right after the `FROM` table:
+     * `FROM table TABLESAMPLE BERNOULLI(10) REPEATABLE(seed)`. `percent` is the
+     * sampling percentage (0-100). `seed`, if provided, produces a repeatable
+     * sample via `REPEATABLE(seed)`.
+     */
+    sample?: {
+        method: 'BERNOULLI' | 'SYSTEM';
+        percent: number;
+        seed?: number;
+    };
+}
+/**
+ * A single Common Table Expression definition used by `SelectOptions.cte`.
+ */
+export interface CTEOption {
+    /** Name the CTE is referenced by in the main query (and in itself, for recursive CTEs). */
+    name: string;
+    /** The CTE body: either a raw SQL string or a nested SelectOptions to be compiled. */
+    query: string | SelectOptions;
+    /** Marks this CTE as recursive, causing `WITH RECURSIVE` to be used. */
+    recursive?: boolean;
+    /** Optional explicit column list: `name (col1, col2, ...) AS (...)`. */
+    columns?: string[];
+}
+export interface DialectOptions {
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    storage?: string;
+    timezone?: string;
+    isolationLevel?: string;
+}
+/**
+ * Abstract base class for database dialects
+ * Provides common functionality for all dialect implementations
+ */
+export declare abstract class BaseDialect implements Dialect {
+    abstract readonly name: string;
+    abstract readonly library: string;
+    protected _connection: any;
+    protected _connected: boolean;
+    protected dialectName: string;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract getConnection(): any;
+    abstract isConnected(): boolean;
+    abstract query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    abstract queryStream(sql: string, options?: StreamOptions): Readable;
+    abstract escape(value: any): string;
+    abstract escapeId(identifier: string): string;
+    abstract quoteIdentifier(identifier: string): string;
+    abstract quoteTable(tableName: string, schema?: string): string;
+    abstract getDatabaseVersion(): Promise<string>;
+    abstract createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions): Promise<void>;
+    abstract dropTable(tableName: string, options?: DropTableOptions): Promise<void>;
+    /**
+     * Create a partitioned table (PostgreSQL 10+)
+     */
+    abstract createPartitionedTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & {
+        partitionBy: {
+            type: 'range' | 'list' | 'hash';
+            column: string | string[];
+        };
+        partitions?: {
+            name: string;
+            bound?: PartitionBound;
+            tablespace?: string;
+            storageParameters?: Record<string, string | number>;
+        }[];
+    }): Promise<void>;
+    /**
+     * Create a partition for an existing partitioned table (PostgreSQL 10+)
+     */
+    abstract createPartition(options: CreatePartitionOptions): Promise<void>;
+    /**
+     * Attach a partition to a partitioned table (PostgreSQL 11+)
+     */
+    abstract attachPartition(options: AttachPartitionOptions): Promise<void>;
+    /**
+     * Detach a partition from a partitioned table (PostgreSQL 11+)
+     */
+    abstract detachPartition(options: DetachPartitionOptions): Promise<void>;
+    /**
+     * Drop a partition (PostgreSQL 10+)
+     */
+    abstract dropPartition(partitionName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a database view
+     * @param viewName - Name of the view to create
+     * @param query - The SELECT query for the view
+     * @param options - View options
+     */
+    abstract createView(viewName: string, query: string, options?: ViewOptions): Promise<void>;
+    /**
+     * Drop a database view
+     * @param viewName - Name of the view to drop
+     * @param options - Drop options
+     */
+    abstract dropView(viewName: string, options?: DropViewOptions): Promise<void>;
+    /**
+     * Create a materialized view (PostgreSQL only)
+     * @param options - Materialized view options
+     */
+    abstract createMaterializedView(options: MaterializedViewOptions): Promise<void>;
+    /**
+     * Refresh a materialized view (PostgreSQL only)
+     * @param viewName - Name of the materialized view to refresh
+     * @param options - Refresh options
+     */
+    abstract refreshMaterializedView(viewName: string, options?: RefreshOptions): Promise<void>;
+    /**
+     * Drop a materialized view (PostgreSQL only)
+     * @param viewName - Name of the materialized view to drop
+     * @param options - Drop options
+     */
+    abstract dropMaterializedView(viewName: string, options?: DropMaterializedViewOptions): Promise<void>;
+    /**
+     * Check if a materialized view exists (PostgreSQL only)
+     * @param viewName - Name of the materialized view
+     * @returns True if the materialized view exists
+     */
+    abstract hasMaterializedView(viewName: string): Promise<boolean>;
+    /**
+     * Create a stored procedure
+     * @param options - Stored procedure options
+     */
+    abstract createStoredProcedure(options: StoredProcedureOptions): Promise<void>;
+    /**
+     * Create a stored procedure (alias for createStoredProcedure)
+     * @param options - Stored procedure options
+     */
+    createProcedure(options: StoredProcedureOptions): Promise<void>;
+    /**
+     * Drop a stored procedure
+     * @param procedureName - Name of the stored procedure
+     * @param options - Drop options
+     */
+    abstract dropStoredProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     * @param procedureName - Name of the stored procedure
+     * @param options - Drop options
+     */
+    dropProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Execute a stored procedure
+     * @param options - Execute options
+     * @returns Query result
+     */
+    abstract executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    /**
+     * Check if a stored procedure exists
+     * @param procedureName - Name of the stored procedure
+     * @param schema - Schema name (PostgreSQL)
+     * @returns True if the stored procedure exists
+     */
+    abstract hasStoredProcedure(procedureName: string, schema?: string): Promise<boolean>;
+    /**
+     * Create a trigger
+     * @param options - Trigger options
+     */
+    abstract createTrigger(options: TriggerOptions): Promise<void>;
+    /**
+     * Drop a trigger
+     * @param triggerName - Name of the trigger
+     * @param tableName - Table the trigger is attached to
+     * @param options - Drop options
+     */
+    abstract dropTrigger(triggerName: string, tableName: string, options?: DropTriggerOptions): Promise<void>;
+    /**
+     * Check if a trigger exists
+     * @param triggerName - Name of the trigger
+     * @param tableName - Table the trigger is attached to
+     * @returns True if the trigger exists
+     */
+    abstract hasTrigger(triggerName: string, tableName: string): Promise<boolean>;
+    /**
+     * Create a sequence (PostgreSQL)
+     * @param options - Sequence options
+     */
+    abstract createSequence(options: SequenceOptions): Promise<void>;
+    /**
+     * Drop a sequence (PostgreSQL)
+     * @param sequenceName - Name of the sequence
+     * @param options - Drop options
+     */
+    abstract dropSequence(sequenceName: string, options?: DropSequenceOptions): Promise<void>;
+    /**
+     * Get next value from a sequence (PostgreSQL)
+     * @param sequenceName - Name of the sequence
+     * @returns Next sequence value
+     */
+    abstract nextSequenceValue(sequenceName: string): Promise<number>;
+    /**
+     * Check if a sequence exists (PostgreSQL)
+     * @param sequenceName - Name of the sequence
+     * @returns True if the sequence exists
+     */
+    abstract hasSequence(sequenceName: string): Promise<boolean>;
+    /**
+     * Create a policy (PostgreSQL RLS)
+     * @param options - Policy options
+     */
+    abstract createPolicy(options: PolicyOptions): Promise<void>;
+    /**
+     * Drop a policy (PostgreSQL RLS)
+     * @param policyName - Name of the policy
+     * @param tableName - Table name
+     * @param options - Drop options
+     */
+    abstract dropPolicy(policyName: string, tableName: string, options?: DropPolicyOptions): Promise<void>;
+    /**
+     * Enable row-level security on a table (PostgreSQL)
+     * @param tableName - Table name
+     * @param schema - Schema name
+     */
+    abstract enableRLS(tableName: string, schema?: string): Promise<void>;
+    /**
+     * Disable row-level security on a table (PostgreSQL)
+     * @param tableName - Table name
+     * @param schema - Schema name
+     */
+    abstract disableRLS(tableName: string, schema?: string): Promise<void>;
+    /**
+     * Check if a policy exists (PostgreSQL RLS)
+     * @param policyName - Name of the policy
+     * @param tableName - Table name
+     * @returns True if the policy exists
+     */
+    abstract hasPolicy(policyName: string, tableName: string): Promise<boolean>;
+    /**
+     * Add comment to a table
+     * @param tableName - Table name
+     * @param comment - Comment text
+     */
+    abstract commentTable(tableName: string, comment: string): Promise<void>;
+    /**
+     * Add comment to a column
+     * @param tableName - Table name
+     * @param columnName - Column name
+     * @param comment - Comment text
+     */
+    abstract commentColumn(tableName: string, columnName: string, comment: string): Promise<void>;
+    /**
+     * Create a partial index (index with WHERE clause)
+     * @param tableName - Table name
+     * @param indexName - Index name
+     * @param fields - Fields to index
+     * @param where - WHERE clause for partial index
+     * @param options - Additional index options
+     */
+    abstract createPartialIndex(tableName: string, indexName: string, fields: string[], where: string, options?: IndexOptions): Promise<void>;
+    /**
+     * Create an expression index
+     * @param tableName - Table name
+     * @param indexName - Index name
+     * @param expression - Expression for the index
+     * @param options - Additional index options
+     */
+    abstract createExpressionIndex(tableName: string, indexName: string, expression: string, options?: IndexOptions): Promise<void>;
+    /**
+     * Create an identity column
+     * @param tableName - Table name
+     * @param columnName - Column name
+     * @param options - Identity options
+     */
+    abstract createIdentityColumn(tableName: string, columnName: string, options?: {
+        startWith?: number;
+        incrementBy?: number;
+        minvalue?: number;
+        maxvalue?: number;
+        cycle?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a computed column
+     * @param tableName - Table name
+     * @param columnName - Column name
+     * @param expression - Expression for computed column
+     * @param options - Computed column options
+     */
+    abstract createComputedColumn(tableName: string, columnName: string, expression: string, options?: {
+        persisted?: boolean;
+        type?: string;
+    }): Promise<void>;
+    abstract addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    abstract removeColumn(tableName: string, columnName: string): Promise<void>;
+    abstract changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Rename a column (default throws error)
+     */
+    renameColumn(_tableName: string, _oldColumnName: string, _newColumnName: string): Promise<void>;
+    /**
+     * Add a foreign key (default throws error)
+     */
+    addForeignKey(_tableName: string, _columnName: string, _referencedTableName: string, _referencedColumnName: string, _options?: any): Promise<void>;
+    /**
+     * Bulk insert records (default implementation)
+     */
+    bulkInsert(tableName: string, records: Record<string, any>[], _options?: any): Promise<QueryResult>;
+    abstract showTables(): Promise<string[]>;
+    abstract showViews(): Promise<string[]>;
+    abstract showMaterializedViews(): Promise<string[]>;
+    abstract showConstraints(tableName: string): Promise<any[]>;
+    abstract addConstraint(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    abstract removeConstraint(tableName: string, constraintName: string): Promise<void>;
+    abstract showIndexes(tableName: string): Promise<any[]>;
+    abstract describeTable(tableName: string): Promise<TableDescription>;
+    abstract renameTable(oldName: string, newName: string): Promise<void>;
+    abstract addIndex(tableName: string, indexName: string, fields: string[], options?: IndexOptions): Promise<void>;
+    abstract removeIndex(tableName: string, indexName: string): Promise<void>;
+    abstract createIndex(tableName: string, indexDef: IndexDefinition): Promise<void>;
+    /**
+     * Create a fulltext index (default throws error)
+     */
+    createFulltextIndex(_tableName: string, _indexName: string, _fields: string[], _options?: {
+        parser?: string;
+        comment?: string;
+    }): Promise<void>;
+    /**
+     * Create a spatial index (default throws error)
+     */
+    createSpatialIndex(_tableName: string, _indexName: string, _fields: string[], _options?: {
+        storage?: string;
+        srid?: number;
+    }): Promise<void>;
+    abstract dropIndex(tableName: string, indexName: string, options?: DropIndexOptions): Promise<void>;
+    abstract createConstraint(tableName: string, constraintDef: ConstraintDefinition): Promise<void>;
+    abstract dropConstraint(tableName: string, constraintName: string, options?: DropConstraintOptions): Promise<void>;
+    abstract changeOwner(newOwner: string, tableName: string): Promise<void>;
+    abstract createForeignDataWrapper(fdwName: string, options?: {
+        handler?: string;
+    }): Promise<void>;
+    abstract dropForeignDataWrapper(fdwName: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    abstract createForeignServer(serverName: string, fdwName: string, options?: {
+        options?: Record<string, string>;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    abstract dropForeignServer(serverName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    abstract createForeignTable(tableName: string, columns: Record<string, {
+        type: string;
+    }>, options?: {
+        serverName?: string;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    abstract createSecurityPolicy(policyName: string, tableName: string, options?: {
+        predicate?: string;
+    }): Promise<void>;
+    abstract dropSecurityPolicy(policyName: string, tableName: string): Promise<void>;
+    abstract startTransaction(options?: TransactionOptions): Promise<Transaction>;
+    abstract commitTransaction(transaction: Transaction): Promise<void>;
+    abstract rollbackTransaction(transaction: Transaction): Promise<void>;
+    abstract getDataTypeSql(dataType: DataType): string;
+    abstract buildWhereClause(where: WhereOptions, options?: BuildOptions): {
+        sql: string;
+        values: any[];
+    };
+    abstract buildOrderClause(order: Order, options?: BuildOptions): string;
+    abstract buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    abstract buildInsertQuery(tableName: string, values: Record<string, any>, options?: InsertOptions): {
+        sql: string;
+        values: any[];
+    };
+    abstract buildUpdateQuery(tableName: string, values: Record<string, any>, where: WhereOptions, options?: UpdateOptions): {
+        sql: string;
+        values: any[];
+    };
+    abstract buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: any[];
+    };
+    abstract buildSelectQuery(options: SelectOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Create a schema
+     * @param schema - The schema name to create
+     */
+    abstract createSchema(schema: string): Promise<void>;
+    /**
+     * Drop a schema
+     * @param schema - The schema name to drop
+     * @param options - Drop options
+     */
+    abstract dropSchema(schema: string, options?: DropSchemaOptions): Promise<void>;
+    /**
+     * Show all schemas in the database
+     */
+    abstract showAllSchemas(): Promise<string[]>;
+    /**
+     * List all schemas in the database
+     */
+    listSchemas(): Promise<string[]>;
+    /**
+     * Generate SQL for creating a database (default implementation)
+     * @param options - Database creation options
+     */
+    createDatabaseSQL(options: {
+        name: string;
+        encoding?: string;
+        lcCollate?: string;
+        lcCtype?: string;
+        template?: string;
+        tablespace?: string;
+        collate?: string;
+        isTemplate?: boolean;
+    }): string;
+    /**
+     * Generate SQL for dropping a database
+     * @param name - Database name to drop
+     */
+    dropDatabaseSQL(name: string): string;
+    /**
+     * Generate SQL for creating a savepoint
+     * @param name - Savepoint name (optional, will be generated if not provided)
+     */
+    createSavepointSQL(name?: string): string;
+    /**
+     * Generate SQL for releasing a savepoint
+     * @param name - Savepoint name to release
+     */
+    releaseSavepointSQL(name: string): string;
+    /**
+     * Generate SQL for rolling back to a savepoint
+     * @param name - Savepoint name to rollback to
+     */
+    rollbackToSavepointSQL(name: string): string;
+    /**
+     * Create a PostgreSQL extension (only supported in PostgreSQL)
+     * @param extensionName - Name of the extension to create
+     * @param options - Extension options
+     */
+    createExtension(_extensionName: string, _options?: CreateExtensionOptions): Promise<void>;
+    /**
+     * Drop a PostgreSQL extension (only supported in PostgreSQL)
+     * @param extensionName - Name of the extension to drop
+     * @param options - Drop options
+     */
+    dropExtension(_extensionName: string, _options?: DropExtensionOptions): Promise<void>;
+    /**
+     * Get all installed PostgreSQL extensions (only supported in PostgreSQL)
+     * @returns Array of extension information
+     */
+    getExtensions(): Promise<ExtensionInfo[]>;
+    /**
+     * Check if a PostgreSQL extension is installed (only supported in PostgreSQL)
+     * @param extensionName - Name of the extension
+     * @returns True if the extension is installed
+     */
+    hasExtension(_extensionName: string): Promise<boolean>;
+    /**
+     * Create a PostgreSQL enum type (only supported in PostgreSQL)
+     */
+    createEnumType(_name: string, _values: string[], _options?: CreateEnumTypeOptions): Promise<void>;
+    /**
+     * Drop a PostgreSQL type (only supported in PostgreSQL)
+     */
+    dropType(_name: string, _options?: DropTypeOptions): Promise<void>;
+    /**
+     * Create a PostgreSQL domain (only supported in PostgreSQL)
+     */
+    createDomain(_name: string, _baseType: string, _options?: CreateDomainOptions): Promise<void>;
+    /**
+     * Drop a PostgreSQL domain (only supported in PostgreSQL)
+     */
+    dropDomain(_name: string, _options?: DropDomainOptions): Promise<void>;
+    buildCreateServerQuery(_name: string, _opts: FdwForeignServerOptions): string;
+    buildAlterServerQuery(_name: string, _opts: FdwAlterForeignServerOptions): string;
+    buildDropServerQuery(_name: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    buildCreateUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildAlterUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildDropUserMappingQuery(_serverName: string, _user: string, _opts?: {
+        ifExists?: boolean;
+    }): string;
+    /**
+     * Create a user mapping (default throws error)
+     */
+    createUserMapping(_userName: string, _serverName: string, _options?: any): Promise<void>;
+    /**
+     * Drop a user mapping (default throws error)
+     */
+    dropUserMapping(_userName: string, _serverName: string, _options?: any): 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;
+    getServersQuery(): string;
+    buildCreateUserQuery(_username: string, _options?: any): string;
+    buildAlterUserQuery(_username: string, _options: any): string;
+    buildDropUserQuery(_username: string, _options?: any): string;
+    getUsersQuery(): string;
+    buildGrantQuery(_options: any): string;
+    buildRevokeQuery(_options: any): string;
+    buildShowGrantsQuery(_username: string, _host?: string): string;
+    buildFlushPrivilegesQuery(): string;
+    buildCreateRoleQuery(_roleName: string, _options?: any): string;
+    buildDropRoleQuery(_roleName: string, _options?: any): string;
+    buildGrantRoleQuery(_role: string, _to: any, _options?: any): string;
+    buildRevokeRoleQuery(_role: string, _from: any, _options?: any): string;
+    getRolesQuery(): string;
+    /**
+     * Build an UPSERT query (insert or update on conflict)
+     * @param tableName - Table name
+     * @param values - Values to insert/update
+     * @param options - Upsert options
+     */
+    abstract buildUpsertQuery(tableName: string, values: Record<string, any>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build an UPSERT query (insert or update on conflict)
+     * @param tableName - Table name
+     * @param values - Values to insert/update
+     * @param options - Upsert options
+     */
+    abstract buildUpsertQuery(tableName: string, values: Record<string, any>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build an increment query
+     * @param tableName - Table name
+     * @param fields - Fields to increment
+     * @param where - Where clause
+     * @param options - Query options (by: number)
+     */
+    abstract buildIncrementQuery(tableName: string, fields: string | string[] | Record<string, number>, where: WhereOptions, options?: {
+        by?: number;
+    }): {
+        sql: string;
+        values: any[];
+    };
+    /**
+     * Build a JSON/JSONB path query
+     * Default implementation using common JSON extraction syntax
+     *
+     * @param column - The JSON/JSONB column name
+     * @param path - The JSON path to access (e.g., 'key' or 'key.subkey')
+     * @param value - The value to compare against (optional)
+     * @param operator - The comparison operator to use (defaults to =)
+     * @returns SQL fragment and values for the JSON query
+     */
+    buildJsonQuery(column: string, path: string, value?: unknown, operator?: string): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Format a value for SQL based on its type
+     */
+    protected formatValue(value: any): string;
+    /**
+     * Format a date for SQL
+     */
+    protected formatDate(date: Date): string;
+    /**
+     * Replace placeholders in SQL with actual values
+     * Supports both named (:param) and positional (?) placeholders
+     * Properly escapes values to prevent SQL injection
+     */
+    replaceReplacements(sql: string, replacements?: Record<string, unknown> | unknown[]): string;
+    /**
+     * Replace positional (?) placeholders with escaped values
+     */
+    protected replacePositionalReplacements(sql: string, replacements: unknown[]): string;
+    /**
+     * Replace named (:param) placeholders with escaped values
+     */
+    protected replaceNamedReplacements(sql: string, replacements: Record<string, unknown>): string;
+    /**
+     * Escape a replacement value for safe inclusion in SQL
+     */
+    protected escapeReplacement(value: unknown): string;
+    /**
+     * Parse a value from the database
+     */
+    protected parseValue(value: any, type: DataType): any;
+    /**
+     * Get the isolation level SQL
+     */
+    protected getIsolationLevelSql(isolationLevel?: string): string;
+    /**
+     * Resolve the 'all' include option to actual include configurations
+     */
+    protected resolveAllInclude(include: IncludeOptions, parentAlias: string, depth: number): IncludeOptions[];
+    /**
+     * Generate column list with proper aliasing to avoid duplicates
+     */
+    protected generateSelectColumns(mainTableName: string, mainTableAlias: string, attributes?: string[] | {
+        include?: string[];
+        exclude?: string[];
+    }, includes?: Array<{
+        tableName: string;
+        alias: string;
+    }>): string;
+    /**
+     * Flatten nested includes to handle 'all' option
+     */
+    protected flattenIncludesWithAll(includes: IncludeOptions[], parentAlias?: string, depth?: number): IncludeOptions[];
+}
+/**
+ * Dialect registry for managing available dialects
+ */
+export declare class DialectRegistry {
+    private static dialects;
+    /**
+     * Register a new dialect
+     */
+    static register(name: string, factory: new (options: DialectOptions) => Dialect): void;
+    /**
+     * Get a dialect by name
+     */
+    static get(name: string): new (options: DialectOptions) => Dialect;
+    /**
+     * Check if a dialect is registered
+     */
+    static has(name: string): boolean;
+    /**
+     * Get all registered dialect names
+     */
+    static getAvailable(): string[];
+}
+export type { RefreshOptions, MaterializedViewOptions, DropMaterializedViewOptions, RefreshMethod, BuildMode, RefreshOn, } from '../types';
+export type { RefreshStrategy as ViewRefreshStrategy } from '../decorators/view';