ts-prorm-orm 1.1.0 → 1.2.0

package/dist/prorm.d.ts

@@ -0,0 +1,2093 @@
+/**
+ * Main Prorm ORM class
+ */
+import { EventEmitter } from 'events';
+import { Dialect, ColumnDefinition, TableOptions, CreateExtensionOptions, DropExtensionOptions, ExtensionInfo } from './dialects/dialect';
+import { ForeignDataManager, ForeignServerOptions, UserMappingOptions, ForeignTableOptions, ImportForeignSchemaOptions, ServerInfo } from './foreign-data';
+import { UserManager } from './user-management';
+import { DatabaseConnectionPool } from './connection-pool';
+import { PrormOptions, ModelStatic, ModelOptions as ModelOptionsType, AttributeOptions, DestroyOptions, ReloadOptions, Transaction, TransactionOptions, DataType } from './types';
+import { ExternalStoreRegistry } from './external-fields';
+import type { RegisterStoreOptions } from './external-fields';
+import { Logger } from './logging';
+import { ValidationError } from './errors';
+import { type IsolationLevelValue } from './sql-constants';
+type AnyModel = any;
+/**
+ * Hook types for the ORM
+ */
+export type HookCallback = (...args: any[]) => void | Promise<void>;
+/**
+ * Connection type for hook callbacks
+ */
+export interface Connection {
+    id: string;
+    createdAt: number;
+    [key: string]: any;
+}
+/**
+ * Hook manager for Prorm instance
+ */
+export declare class HooksManager {
+    private beforeDefineHooks;
+    private afterDefineHooks;
+    private beforeSyncHooks;
+    private afterSyncHooks;
+    private beforeConnectHooks;
+    private afterConnectHooks;
+    private beforeDisconnectHooks;
+    private afterDisconnectHooks;
+    private beforeDestroyHooks;
+    private afterDestroyHooks;
+    private beforeUpsertHooks;
+    private afterUpsertHooks;
+    private beforeReloadHooks;
+    /**
+     * Register a beforeDefine hook
+     */
+    beforeDefine(callback: HookCallback): void;
+    /**
+     * Register an afterDefine hook
+     */
+    afterDefine(callback: HookCallback): void;
+    /**
+     * Register a beforeSync hook
+     */
+    beforeSync(callback: HookCallback): void;
+    /**
+     * Register an afterSync hook
+     */
+    afterSync(callback: HookCallback): void;
+    /**
+     * Register a beforeConnect hook
+     */
+    beforeConnect(callback: HookCallback): void;
+    /**
+     * Register an afterConnect hook
+     */
+    afterConnect(callback: HookCallback): void;
+    /**
+     * Register a beforeDisconnect hook
+     */
+    beforeDisconnect(callback: HookCallback): void;
+    /**
+     * Register an afterDisconnect hook
+     */
+    afterDisconnect(callback: HookCallback): void;
+    /**
+     * Register a beforeDestroy hook
+     */
+    beforeDestroy(callback: HookCallback): void;
+    /**
+     * Register an afterDestroy hook
+     */
+    afterDestroy(callback: HookCallback): void;
+    /**
+     * Register a beforeUpsert hook
+     */
+    beforeUpsert(callback: HookCallback): void;
+    /**
+     * Register an afterUpsert hook
+     */
+    afterUpsert(callback: HookCallback): void;
+    /**
+     * Register a beforeReload hook
+     */
+    beforeReload(callback: HookCallback): void;
+    /**
+     * Execute all beforeDefine hooks
+     */
+    runBeforeDefine(modelName: string, attributes: Record<string, AttributeOptions>, options: ModelOptionsType): Promise<void>;
+    /**
+     * Execute all afterDefine hooks
+     */
+    runAfterDefine(model: ModelStatic<AnyModel>): Promise<void>;
+    /**
+     * Execute all beforeSync hooks
+     */
+    runBeforeSync(options: SyncOptions): Promise<void>;
+    /**
+     * Execute all afterSync hooks
+     */
+    runAfterSync(options: SyncOptions): Promise<void>;
+    /**
+     * Execute all beforeConnect hooks
+     */
+    runBeforeConnect(): Promise<void>;
+    /**
+     * Execute all afterConnect hooks
+     * @param connection - The connection object to pass to hooks
+     */
+    runAfterConnect(connection: Connection): Promise<void>;
+    /**
+     * Execute all beforeDisconnect hooks
+     * @param connection - The connection object to pass to hooks
+     */
+    runBeforeDisconnect(connection: Connection): Promise<void>;
+    /**
+     * Execute all afterDisconnect hooks
+     * @param connection - The connection object to pass to hooks
+     */
+    runAfterDisconnect(connection: Connection): Promise<void>;
+    /**
+     * Execute all beforeDestroy hooks
+     * @param options - The destroy options
+     */
+    runBeforeDestroy(options: DestroyOptions): Promise<void>;
+    /**
+     * Execute all afterDestroy hooks
+     * @param options - The destroy options
+     */
+    runAfterDestroy(options: DestroyOptions): Promise<void>;
+    /**
+     * Execute all beforeUpsert hooks
+     * @param options - The upsert options
+     */
+    runBeforeUpsert(options: any): Promise<void>;
+    /**
+     * Execute all afterUpsert hooks
+     * @param options - The upsert options
+     */
+    runAfterUpsert(options: any): Promise<void>;
+    /**
+     * Execute all beforeReload hooks
+     * @param options - The reload options
+     */
+    runBeforeReload(options: ReloadOptions): Promise<void>;
+    /**
+     * Add a hook by name
+     * @param hookName - The name of the hook (e.g., 'beforeDefine', 'afterSync')
+     * @param callback - The hook callback function
+     */
+    addHook(hookName: string, callback: HookCallback): void;
+    /**
+     * Clear all hooks
+     */
+    clearHooks(): void;
+}
+/**
+ * Options for sync method
+ */
+export interface SyncOptions {
+    /**
+     * If true, drops all tables and recreates them.
+     * WARNING: This will destroy all data in the tables!
+     * @default false
+     */
+    force?: boolean;
+    /**
+     * If true, alter tables to match model definitions.
+     * This will add new columns, remove extra columns, and change column types as needed.
+     * Preserves existing data in the table.
+     * Can be an object with { drop: false } to prevent dropping columns
+     * @default false
+     */
+    alter?: boolean | {
+        drop?: boolean;
+    };
+    /**
+     * Regular expression to match the database name.
+     * Sync will only proceed if the database name matches this pattern.
+     * Useful for development vs production environments.
+     * Example: /test/ - only syncs if database name contains "test"
+     */
+    match?: RegExp;
+    /**
+     * Custom logging function
+     */
+    logging?: boolean | ((sql: string, timing?: number) => void);
+    /**
+     * If true, run sync hooks (beforeSync, afterSync, etc.)
+     * @default true
+     */
+    hooks?: boolean;
+    /**
+     * If true, also sync indexes
+     * @default true
+     */
+    indexes?: boolean;
+    /**
+     * If true, also sync foreign key constraints
+     * @default true
+     */
+    constraints?: boolean;
+}
+/**
+ * Represents a raw SQL literal value
+ * Used for inserting raw SQL expressions into queries
+ *
+ * @example
+ * // Use in default values
+ * createdAt: { type: DATE, defaultValue: prorm.literal('NOW()') }
+ *
+ * @example
+ * // Use in updates
+ * User.update({ count: prorm.literal('count + 1') }, {...})
+ *
+ * @example
+ * // Use in select with calculations
+ * User.findAll({ attributes: [[prorm.literal('1 + 1'), 'two']] })
+ */
+export declare class Literal {
+    readonly val: string;
+    constructor(sql: string);
+    /**
+     * Get the raw SQL string
+     */
+    toString(): string;
+}
+/**
+ * Class representing a column reference for use with Prorm functions
+ * Used to create properly quoted column identifiers
+ *
+ * @example
+ * // Single column: col('name') -> "name"
+ * // Table and column: col('User', 'name') -> "User"."name"
+ * // Dot notation: col('table.column') -> "table"."column"
+ */
+export declare class Col {
+    private readonly col;
+    /**
+     * Create a column reference
+     * @param tableOrColumn - Table name (if second param provided) or column name
+     * @param column - Column name (if first param is table name)
+     */
+    constructor(tableOrColumn: string, column?: string);
+    /**
+     * Get the SQL representation of the column
+     */
+    toSql(): string;
+    /**
+     * Get the column as a string
+     */
+    toString(): string;
+}
+/**
+ * Query types for raw SQL queries
+ */
+export declare enum QueryTypes {
+    SELECT = "SELECT",
+    INSERT = "INSERT",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+    BULKDELETE = "BULKDELETE",
+    BULKINSERT = "BULKINSERT",
+    UPSERT = "UPSERT",
+    VERSION = "VERSION",
+    SHOWTABLES = "SHOWTABLES",
+    DESCRIBE = "DESCRIBE",
+    RAW = "RAW"
+}
+/**
+ * Options for raw query execution
+ */
+export interface RawQueryResult {
+    rows: unknown[];
+    count: number;
+    isSelect: boolean;
+}
+export interface QueryOptions {
+    /**
+     * Query type - determines how results are processed
+     * Forces the query type for result handling
+     * - SELECT: Returns array of rows
+     * - INSERT: Returns [rows, created]
+     * - UPDATE: Returns affected count
+     * - DELETE: Returns affected count
+     * - BULKDELETE: Returns affected count
+     * - UPSERT: Returns [rows, created]
+     */
+    type?: QueryTypes | 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'BULKDELETE' | 'UPSERT' | 'BULKINSERT' | 'VERSION' | 'SHOWTABLES' | 'DESCRIBE' | 'RAW';
+    /**
+     * Replacements for named (:param) or positional (?) placeholders
+     * For named: { username: 'john' } replaces :username in SQL
+     * For positional: ['john', 'smith'] replaces ? in order
+     */
+    replacements?: Record<string, unknown> | unknown[];
+    /**
+     * Return raw results without model instantiation
+     */
+    raw?: boolean;
+    /**
+     * Whether to log the query
+     */
+    logging?: boolean | ((sql: string, timing?: number) => void);
+    /**
+     * When true, logs query execution time
+     */
+    benchmark?: boolean;
+    /**
+     * Transaction to use for the query
+     */
+    transaction?: Transaction;
+    /**
+     * Retry configuration for query execution
+     * On connection failure or retryable errors, retry up to max times
+     * @param max - Maximum number of retry attempts
+     * @param match - Array of error message patterns that trigger retry
+     *
+     * @example
+     * // Retry on connection refused or timeout errors
+     * await prorm.query('SELECT * FROM users', {
+     *   retry: { max: 3, match: ['Connection refused', 'Timeout', 'ECONNREFUSED'] }
+     * });
+     */
+    retry?: {
+        max: number;
+        match?: string[];
+    };
+    /**
+     * Map raw query results to a model instance
+     * When true, maps the result rows to ModelInstance objects using the provided model
+     * @default false
+     */
+    mapToModel?: boolean;
+    /**
+     * Model to use for mapping raw results to model instances
+     * Used together with mapToModel to create ModelInstance objects from raw query results
+     */
+    model?: ModelStatic<any>;
+}
+/**
+ * Main Prorm class with error handling and logging
+ */
+export declare class Prorm extends EventEmitter {
+    private dialect;
+    private _fdwManager;
+    private _userManager;
+    private _models;
+    /**
+     * Get all models as an object for backward compatibility
+     * Allows accessing models via prorm.models.ModelName
+     */
+    get models(): Record<string, ModelStatic<AnyModel>>;
+    /**
+     * Sequelize-style model manager, exposing the registered models along
+     * with a few convenience accessors on top of the internal model map.
+     */
+    get modelManager(): {
+        models: Record<string, ModelStatic<AnyModel>>;
+        all: ModelStatic<AnyModel>[];
+        getModel(name: string): ModelStatic<AnyModel> | undefined;
+        addModel(name: string, model: ModelStatic<AnyModel>): void;
+        removeModel(name: string): boolean;
+    };
+    private currentTransaction;
+    private _rootTransactionQueue;
+    private modelDefinitions;
+    associations: Map<string, any>;
+    /**
+     * Decorator-declared associations waiting for their target model to be
+     * registered. See `_flushPendingAssociations()`.
+     */
+    private _pendingAssociations;
+    /** Model classes registered via `addModel`, consulted for @View/@Trigger DDL. */
+    private _decoratedClasses;
+    /** Classes registered via `registerProcedures`, for @Procedure/@SqlFunction DDL. */
+    private _procedureClasses;
+    /**
+     * Object/key-value stores backing @ExternalField properties. Public so the
+     * instance accessors built in `_wrapInstance` can resolve them.
+     */
+    readonly externalStores: ExternalStoreRegistry;
+    private pendingTableCreates;
+    private config;
+    private _isConnected;
+    private logger;
+    private loggingOptions;
+    private hooksManager;
+    private modelHooks;
+    /**
+     * The connection pool instance
+     * @example
+     * // Get pool statistics
+     * console.log('Pool size:', prorm.pool.size);
+     * console.log('Available:', prorm.pool.available);
+     * console.log('Used:', prorm.pool.used);
+     * console.log('Pending:', prorm.pool.pending);
+     *
+     * // Listen to pool events
+     * prorm.pool.on('acquire', (connection) => {
+     *   console.log('Connection acquired:', connection?.id);
+     * });
+     * prorm.pool.on('release', (connection) => {
+     *   console.log('Connection released:', connection?.id);
+     * });
+     * prorm.pool.on('error', (err) => {
+     *   console.error('Pool error:', err);
+     * });
+     *
+     * // Manually acquire a connection
+     * const conn = await prorm.pool.acquire();
+     *
+     * // Release a connection
+     * prorm.pool.release(conn);
+     *
+     * // Destroy a connection
+     * await prorm.pool.destroy(conn);
+     */
+    pool: DatabaseConnectionPool | null;
+    /**
+     * Create a new Prorm instance
+     * @param options - Configuration options
+     *
+     * @example
+     * // Basic usage with console logging
+     * const prorm = new Prorm({
+     *   dialect: 'sqlite',
+     *   storage: ':memory:',
+     *   logging: console.log
+     * });
+     *
+     * @example
+     * // Custom logging function that receives SQL and timing
+     * const prorm = new Prorm({
+     *   dialect: 'sqlite',
+     *   storage: ':memory:',
+     *   logging: (sql, timing) => {
+     *     console.log(`Query took ${timing}ms: ${sql}`);
+     *   }
+     * });
+     *
+     * @example
+     * // Enable benchmark mode for query timing
+     * const prorm = new Prorm({
+     *   dialect: 'sqlite',
+     *   storage: ':memory:',
+     *   logging: console.log
+     * });
+     *
+     * // Now all queries will log execution time
+     * await User.findAll({ benchmark: true });
+     *
+     * @example
+     * // Listen to query events
+     * prorm.on('query', (event) => {
+     *   console.log('Query executed:', event.sql, 'Duration:', event.duration, 'ms');
+     * });
+     *
+     * // Listen to slow query events
+     * prorm.on('slowQuery', (event) => {
+     *   console.warn('Slow query detected:', event.sql, 'Duration:', event.duration, 'ms', 'Threshold:', event.threshold);
+     * });
+     */
+    constructor(options: PrormOptions);
+    /**
+     * Create a literal/raw SQL expression
+     * Use this to insert raw SQL into queries without parameter escaping
+     *
+     * @param sql - The raw SQL expression
+     * @returns A Literal instance that can be used in queries
+     *
+     * @example
+     * // Use in default values
+     * const User = prorm.define('User', {
+     *   createdAt: { type: DATE, defaultValue: prorm.literal('NOW()') },
+     *   updatedAt: { type: DATE, defaultValue: prorm.literal("strftime('%Y-%m-%d %H:%M:%S', 'now')") }
+     * });
+     *
+     * @example
+     * // Use in updates (increment counter)
+     * await User.update(
+     *   { count: prorm.literal('count + 1') },
+     *   { where: { id: 1 } }
+     * );
+     *
+     * @example
+     * // Use in complex calculations in select
+     * const users = await User.findAll({
+     *   attributes: [
+     *     'id',
+     *     'name',
+     *     [prorm.literal('price * quantity'), 'total']
+     *   ]
+     * });
+     *
+     * @example
+     * // Use in subqueries
+     * const posts = await Post.findAll({
+     *   where: {
+     *     userId: prorm.literal('(SELECT id FROM users WHERE active = 1 LIMIT 1)')
+     *   }
+     * });
+     */
+    literal(sql: string): Literal;
+    /**
+     * Set up the connection pool with event forwarding
+     * @param poolOptions - Pool configuration options
+     */
+    private setupPool;
+    /**
+     * Get the connection pool instance
+     * @returns The connection pool or null if not configured
+     */
+    getPool(): DatabaseConnectionPool | null;
+    /**
+     * Get pool statistics
+     * @returns Pool statistics or null if pool not configured
+     */
+    getPoolStats(): {
+        size: number;
+        available: number;
+        inUse: number;
+        pending: number;
+    } | null;
+    /**
+     * Set up error event handling
+     */
+    private setupErrorHandling;
+    /**
+     * Get the logger instance
+     */
+    getLogger(): Logger;
+    /**
+     * Set logging level
+     */
+    setLoggingLevel(level: 'debug' | 'info' | 'warn' | 'error'): void;
+    /**
+     * Emit error event with proper error handling
+     */
+    private emitError;
+    /**
+     * Wrap query execution with error handling
+     */
+    private executeWithErrorHandling;
+    /**
+     * Wrap query with timing and logging
+     * @param sql - The SQL query string
+     * @param operation - The operation to execute
+     * @param options - Optional logging options to override instance-level logging
+     */
+    private executeWithLogging;
+    /**
+     * Set up query logging event handlers
+     * This enables external listeners to react to each query execution
+     */
+    private setupQueryLogging;
+    /**
+     * Create the appropriate dialect instance
+     */
+    private createDialect;
+    /**
+     * Connect to the database and authenticate
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the database and close the connection pool
+     */
+    close(): Promise<void>;
+    /**
+     * Add a hook to the Prorm instance
+     * @param hookName - The name of the hook (e.g., 'beforeDefine', 'afterSync', 'beforeConnect')
+     * @param handler - The hook handler function
+     * @returns The Prorm instance for chaining
+     *
+     * @example
+     * prorm.addHook('beforeDefine', ({ modelName, attributes }) => {
+     *   console.log('Defining model:', modelName);
+     * });
+     *
+     * @example
+     * prorm.addHook('beforeConnect', async () => {
+     *   console.log('About to connect to database');
+     * });
+     */
+    addHook(hookName: string, handler: HookCallback): this;
+    /**
+     * Check if connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Authenticate the connection by running a test query
+     * @returns Promise that resolves if connection is successful
+     * @throws Error if connection fails
+     *
+     * @example
+     * await prorm.authenticate();
+     * console.log('Connection OK');
+     */
+    authenticate(): Promise<void>;
+    /**
+     * Get the dialect name
+     * @returns The dialect name (e.g., 'sqlite', 'postgres', 'mysql')
+     */
+    getDialect(): string;
+    /**
+     * Get the dialect instance
+     * @returns The dialect instance or null if not initialized
+     */
+    getDialectInstance(): Dialect | null;
+    /**
+     * Get the query interface for DDL operations
+     */
+    getQueryInterface(): any;
+    /**
+     * 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?: {
+                from: string | number | Date;
+                to?: string | number | Date;
+                values?: (string | number)[];
+                modulus?: number;
+                remainder?: number;
+            };
+            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: {
+        parentTable: string;
+        name: string;
+        bound?: {
+            from: string | number | Date;
+            to?: string | number | Date;
+            values?: (string | number)[];
+            modulus?: number;
+            remainder?: number;
+        };
+        tablespace?: string;
+        storageParameters?: Record<string, string | number>;
+    }): Promise<void>;
+    /**
+     * Attach a partition to a partitioned table (PostgreSQL 11+)
+     *
+     * @param options - Partition attachment options
+     */
+    attachPartition(options: {
+        parentTable: string;
+        partitionName: string;
+    }): Promise<void>;
+    /**
+     * Detach a partition from a partitioned table (PostgreSQL 11+)
+     *
+     * @param options - Partition detachment options
+     */
+    detachPartition(options: {
+        partitionName: string;
+        validate?: boolean;
+    }): 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>;
+    /**
+     * Disable foreign key checks for the current session
+     * @returns Promise that resolves when foreign key checks are disabled
+     */
+    disableForeignKeyChecks(): Promise<void>;
+    /**
+     * Enable foreign key checks for the current session
+     * @returns Promise that resolves when foreign key checks are enabled
+     */
+    enableForeignKeyChecks(): Promise<void>;
+    /**
+     * Set the transaction isolation level
+     * @param level - The isolation level to set
+     * @returns Promise that resolves when the isolation level is set
+     */
+    setIsolationLevel(level: IsolationLevelValue): Promise<void>;
+    /**
+     * Get SQL for disabling foreign key checks for the current dialect
+     * @returns SQL string for disabling foreign key checks
+     */
+    getDisableForeignKeyChecksSQL(): string;
+    /**
+     * Get SQL for enabling foreign key checks for the current dialect
+     * @returns SQL string for enabling foreign key checks
+     */
+    getEnableForeignKeyChecksSQL(): string;
+    /**
+     * Get SQL for setting transaction isolation level for the current dialect
+     * @param level - The isolation level
+     * @returns SQL string for setting the isolation level
+     */
+    getSetIsolationLevelSQL(level: IsolationLevelValue): string;
+    /**
+     * Disable unique key checks for the current session (MySQL/MariaDB only)
+     * @returns Promise that resolves when unique key checks are disabled
+     */
+    disableUniqueKeyChecks(): Promise<void>;
+    /**
+     * Enable unique key checks for the current session (MySQL/MariaDB only)
+     * @returns Promise that resolves when unique key checks are enabled
+     */
+    enableUniqueKeyChecks(): Promise<void>;
+    /**
+     * Get SQL constants for the current dialect
+     * @returns SQL constants for the current dialect
+     */
+    getSQLConstants(): object;
+    /**
+     * Get the database name
+     * @returns The database name from the configuration
+     */
+    getDatabase(): string;
+    /**
+     * Get the host name
+     * @returns The host from the configuration
+     */
+    getHost(): string;
+    /**
+     * Get the port number
+     * @returns The port from the configuration
+     */
+    getPort(): number | string;
+    /**
+     * Get the username
+     * @returns The username from the configuration
+     */
+    getUsername(): string;
+    /**
+     * Get all registered models
+     */
+    getModels(): Map<string, ModelStatic<AnyModel>>;
+    /**
+     * Get all models as an object (for backward compatibility)
+     */
+    get allModels(): Record<string, ModelStatic<AnyModel>>;
+    /**
+     * Get a model by name
+     */
+    model(name: string): ModelStatic<AnyModel> | undefined;
+    /**
+     * Get a model by name (alias for model())
+     * @param modelName - The name of the model to retrieve
+     * @returns The model static or undefined if not found
+     *
+     * @example
+     * const User = prorm.getModel('User');
+     */
+    getModel(modelName: string): ModelStatic<AnyModel> | undefined;
+    /**
+     * Check if a model is registered with Prorm
+     * @param modelName - The name of the model to check
+     * @returns True if the model is registered, false otherwise
+     *
+     * @example
+     * const hasUser = prorm.hasModel('User');
+     */
+    hasModel(modelName: string): boolean;
+    /**
+     * Get the table name for a model, including schema if defined
+     * @param model - The model to get the table name for
+     * @returns The full table name with schema (e.g., "schema.tableName" or just "tableName")
+     */
+    getTableName(model: ModelStatic<AnyModel> | string): string;
+    /**
+     * Check if a table exists in the database
+     * @param tableName - The table name to check (can include schema for PostgreSQL)
+     * @returns True if the table exists, false otherwise
+     */
+    tableExists(tableName: string): Promise<boolean>;
+    /**
+     * Create a materialized view (PostgreSQL only)
+     * @param options - Materialized view options
+     * @returns Promise<void>
+     *
+     * @example
+     * await prorm.createMaterializedView({
+     *   name: 'user_stats',
+     *   query: 'SELECT user_id, COUNT(*) as order_count FROM orders GROUP BY user_id',
+     *   uniqueIndex: 'user_stats_user_id_key',
+     * });
+     */
+    createMaterializedView(options: {
+        name: string;
+        query: string;
+        schema?: string;
+        ifNotExists?: boolean;
+        replace?: boolean;
+        withData?: boolean;
+        uniqueIndex?: string;
+        comment?: string;
+    }): Promise<void>;
+    /**
+     * Refresh a materialized view (PostgreSQL only)
+     * @param viewName - Name of the materialized view to refresh
+     * @param options - Refresh options
+     * @returns Promise<void>
+     *
+     * @example
+     * // Simple refresh
+     * await prorm.refreshMaterializedView('user_stats');
+     *
+     * // Concurrent refresh (requires unique index)
+     * await prorm.refreshMaterializedView('user_stats', { concurrently: true });
+     *
+     * // Refresh without data
+     * await prorm.refreshMaterializedView('user_stats', { withNoData: true });
+     */
+    refreshMaterializedView(viewName: string, options?: {
+        concurrently?: boolean;
+        withNoData?: boolean;
+    }): Promise<void>;
+    /**
+     * Drop a materialized view (PostgreSQL only)
+     * @param viewName - Name of the materialized view to drop
+     * @param options - Drop options
+     * @returns Promise<void>
+     *
+     * @example
+     * await prorm.dropMaterializedView('user_stats');
+     * await prorm.dropMaterializedView('user_stats', { ifExists: true, cascade: true });
+     */
+    dropMaterializedView(viewName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Check if a materialized view exists (PostgreSQL only)
+     * @param viewName - Name of the materialized view
+     * @returns True if the materialized view exists
+     *
+     * @example
+     * const exists = await prorm.hasMaterializedView('user_stats');
+     */
+    hasMaterializedView(viewName: string): Promise<boolean>;
+    /**
+     * Show all materialized views in the database (PostgreSQL only)
+     * @returns Array of materialized view names
+     *
+     * @example
+     * const views = await prorm.showMaterializedViews();
+     */
+    showMaterializedViews(): Promise<string[]>;
+    /**
+     * Define a new model
+     * @param modelName - Name of the model
+     * @param attributes - Model attributes
+     * @param options - Model options
+     */
+    define<T = AnyModel>(modelName: string, attributes: Record<string, AttributeOptions>, options?: ModelOptionsType): ModelStatic<any>;
+    /**
+     * Add a model defined with decorators
+     * @param modelClass - The model class (decorated with @Table)
+     * @returns The registered model
+     *
+     * @example
+     * ```typescript
+     * import { Model, DataTypes } from 'orm';
+     * import { Table, Column, PrimaryKey, AutoIncrement } from 'orm/decorators';
+     *
+     * @Table({ tableName: 'users' })
+     * export class User extends Model {
+     *   @Column(DataTypes.INTEGER)
+     *   @PrimaryKey
+     *   @AutoIncrement
+     *   declare id: number;
+     *
+     *   @Column(DataTypes.STRING)
+     *   declare name: string;
+     * }
+     *
+     * prorm.addModel(User);
+     * ```
+     */
+    addModel<T = AnyModel>(modelClass: new () => T): ModelStatic<any>;
+    /**
+     * Create table from model definition
+     */
+    private createTableFromModel;
+    /**
+     * Apply replacements to SQL query
+     * Supports both named (:param) and positional (?) placeholders
+     */
+    private applyReplacements;
+    /**
+     * Determine query type from SQL statement
+     */
+    private determineQueryType;
+    /**
+     * Execute a raw query
+     * @param sql - The SQL query string with optional placeholders
+     * @param options - Query options including replacements
+     * @returns Query results (array for SELECT, [rows, created] for INSERT, count for UPDATE/DELETE)
+     *
+     * @example
+     * // Named replacements
+     * await prorm.query('SELECT * FROM users WHERE status = :status', {
+     *   replacements: { status: 'active' }
+     * });
+     *
+     * @example
+     * // IN clause with array replacement
+     * await prorm.query('SELECT * FROM users WHERE id IN (:ids)', {
+     *   replacements: { ids: [1, 2, 3] }
+     * });
+     *
+     * @example
+     * // Positional replacements
+     * await prorm.query('SELECT * FROM users WHERE name = ?', {
+     *   replacements: ['john']
+     * });
+     *
+     * @example
+     * // Map raw results to model instances
+     * const users = await prorm.query('SELECT * FROM users', {
+     *   model: User,
+     *   mapToModel: true
+     * });
+     * // Returns ModelInstance objects instead of plain objects
+     */
+    query(sql: string, options?: QueryOptions): Promise<unknown[] | [unknown[], boolean] | number>;
+    /**
+     * Create a savepoint within a transaction
+     * @param name - Optional savepoint name
+     * @param options - Query options including transaction
+     * @returns The savepoint name
+     */
+    createSavepoint(name?: string, options?: QueryOptions): Promise<string>;
+    /**
+     * Release a savepoint
+     * @param name - Savepoint name to release
+     * @param options - Query options including transaction
+     */
+    releaseSavepoint(name: string, options?: QueryOptions): Promise<void>;
+    /**
+     * Rollback to a savepoint
+     * @param name - Savepoint name to rollback to
+     * @param options - Query options including transaction
+     */
+    rollbackToSavepoint(name: string, options?: QueryOptions): Promise<void>;
+    /**
+     * Execute a raw query and return structured result
+     * @param sql - The SQL query string with optional placeholders
+     * @param options - Query options including replacements
+     * @returns Structured result with rows, count, and isSelect flag
+     */
+    queryWithMetadata(sql: string, options?: QueryOptions): Promise<RawQueryResult>;
+    /**
+     * Execute a query within a transaction (callback mode) or return a transaction object (manual mode).
+     *
+     * Callback mode: `prorm.transaction(async (t) => { ... })`
+     * Manual mode: `const t = await prorm.transaction(); await t.commit();`
+     */
+    transaction<T>(callbackOrOptions?: ((transaction: any) => Promise<T>) | TransactionOptions, options?: TransactionOptions): Promise<T | any>;
+    private _savepointCounter;
+    private _attachSavepointMethods;
+    /**
+     * Get the current transaction
+     */
+    getTransaction(): Transaction | null;
+    /**
+     * Set the current transaction
+     */
+    setTransaction(transaction: Transaction | null): void;
+    /**
+     * Register a hook to be called before a model is defined
+     * @param callback - Function to call before model definition
+     *
+     * @example
+     * prorm.beforeDefine((model, attributes, options) => {
+     *   console.log('Defining:', model.name);
+     * });
+     */
+    beforeDefine(callback: HookCallback): void;
+    /**
+     * Register a hook to be called after a model is defined
+     * @param callback - Function to call after model definition
+     *
+     * @example
+     * prorm.afterDefine((model) => {
+     *   console.log('Defined:', model.name);
+     * });
+     */
+    afterDefine(callback: HookCallback): void;
+    /**
+     * Register a hook to be called before sync
+     * @param callback - Function to call before sync
+     *
+     * @example
+     * prorm.beforeSync((options) => {
+     *   console.log('About to sync with options:', options);
+     * });
+     */
+    beforeSync(callback: HookCallback): void;
+    /**
+     * Register a hook to be called after sync
+     * @param callback - Function to call after sync
+     *
+     * @example
+     * prorm.afterSync((options) => {
+     *   console.log('Sync complete with options:', options);
+     * });
+     */
+    afterSync(callback: HookCallback): void;
+    /**
+     * Register a hook to be called before connection
+     * @param callback - Function to call before connecting
+     *
+     * @example
+     * prorm.beforeConnect(() => {
+     *   console.log('About to connect to database');
+     * });
+     */
+    beforeConnect(callback: HookCallback): void;
+    /**
+     * Register a hook to be called after connection
+     * @param callback - Function to call after connecting, receives connection object
+     *
+     * @example
+     * prorm.afterConnect((connection) => {
+     *   console.log('Connected to database', connection.id);
+     * });
+     */
+    afterConnect(callback: HookCallback): void;
+    /**
+     * Register a hook to be called before disconnection
+     * @param callback - Function to call before disconnecting, receives connection object
+     *
+     * @example
+     * prorm.beforeDisconnect((connection) => {
+     *   console.log('About to disconnect', connection.id);
+     * });
+     */
+    beforeDisconnect(callback: HookCallback): void;
+    /**
+     * Register a hook to be called after disconnection
+     * @param callback - Function to call after disconnecting, receives connection object
+     *
+     * @example
+     * prorm.afterDisconnect((connection) => {
+     *   console.log('Disconnected from database', connection.id);
+     * });
+     */
+    afterDisconnect(callback: HookCallback): void;
+    /**
+     * Register a hook to be called before destroy
+     * @param callback - Function to call before destroy
+     *
+     * @example
+     * prorm.beforeDestroy((options) => {
+     *   console.log('About to destroy records');
+     * });
+     */
+    beforeDestroy(callback: HookCallback): void;
+    /**
+     * Register a hook to be called after destroy
+     * @param callback - Function to call after destroy
+     *
+     * @example
+     * prorm.afterDestroy((options) => {
+     *   console.log('Records destroyed');
+     * });
+     */
+    afterDestroy(callback: HookCallback): void;
+    /**
+     * Register a hook to be called before upsert
+     * @param callback - Function to call before upsert
+     *
+     * @example
+     * prorm.beforeUpsert((options) => {
+     *   console.log('About to upsert record');
+     * });
+     */
+    beforeUpsert(callback: HookCallback): void;
+    /**
+     * Register a hook to be called after upsert
+     * @param callback - Function to call after upsert
+     *
+     * @example
+     * prorm.afterUpsert((options) => {
+     *   console.log('Record upserted');
+     * });
+     */
+    afterUpsert(callback: HookCallback): void;
+    /**
+     * Register a hook to be called before reload
+     * @param callback - Function to call before reload
+     *
+     * @example
+     * prorm.beforeReload((options) => {
+     *   console.log('About to reload record');
+     * });
+     */
+    beforeReload(callback: HookCallback): void;
+    /**
+     * Show all tables
+     */
+    showTables(): Promise<string[]>;
+    /**
+     * Alias for showSchemas - Show all schemas
+     * For PostgreSQL, returns all schemas in the database
+     * For MySQL/MariaDB, returns all databases
+     * For SQLite, returns ['main']
+     */
+    showAllSchemas(): Promise<string[]>;
+    /**
+     * Create a PostgreSQL extension
+     * @param extensionName - Name of the extension to create (e.g., 'uuid-ossp', 'postgis', 'pg_trgm')
+     * @param options - Extension options (ifNotExists, schema, version)
+     * @returns Promise that resolves when the extension is created
+     *
+     * @example
+     * // Create the uuid-ossp extension for UUID generation
+     * await prorm.createExtension('uuid-ossp');
+     *
+     * @example
+     * // Create PostGIS extension for spatial data
+     * await prorm.createExtension('postgis', { ifNotExists: true });
+     *
+     * @example
+     * // Create pg_trgm extension with specific version
+     * await prorm.createExtension('pg_trgm', { version: '1.5' });
+     */
+    createExtension(extensionName: string, options?: CreateExtensionOptions): Promise<void>;
+    /**
+     * Drop a PostgreSQL extension
+     * @param extensionName - Name of the extension to drop
+     * @param options - Drop options (ifExists, cascade)
+     * @returns Promise that resolves when the extension is dropped
+     *
+     * @example
+     * // Drop an extension
+     * await prorm.dropExtension('uuid-ossp');
+     *
+     * @example
+     * // Drop extension with cascade (drops dependent objects)
+     * await prorm.dropExtension('postgis', { cascade: true });
+     */
+    dropExtension(extensionName: string, options?: DropExtensionOptions): Promise<void>;
+    /**
+     * Get all installed PostgreSQL extensions
+     * @returns Promise that resolves to an array of extension information
+     *
+     * @example
+     * const extensions = await prorm.getExtensions();
+     * console.log(extensions);
+     * // Output: [
+     * //   { name: 'uuid-ossp', defaultVersion: null, installedVersion: '1.0', comment: null },
+     * //   { name: 'pg_trgm', defaultVersion: null, installedVersion: '1.5', comment: null }
+     * // ]
+     */
+    getExtensions(): Promise<ExtensionInfo[]>;
+    /**
+     * Check if a PostgreSQL extension is installed
+     * @param extensionName - Name of the extension to check
+     * @returns Promise that resolves to true if the extension is installed
+     *
+     * @example
+     * const hasUuid = await prorm.hasExtension('uuid-ossp');
+     * if (hasUuid) {
+     *   console.log('UUID extension is available');
+     * }
+     */
+    hasExtension(extensionName: string): Promise<boolean>;
+    /**
+     * Check if a PostgreSQL extension is installed (alias for hasExtension).
+     * Returns false for non-PostgreSQL dialects instead of throwing.
+     */
+    extensionExists(extensionName: string): Promise<boolean>;
+    /**
+     * Lazily-created ForeignDataManager instance for this Prorm connection.
+     * Provides the full FDW management surface (servers, user mappings, foreign tables).
+     *
+     * @example
+     * await prorm.fdw.createServer('remote_pg', { fdw: 'postgres_fdw', options: { host: 'db2.example.com', dbname: 'sales', port: '5432' } });
+     */
+    get fdw(): ForeignDataManager;
+    /**
+     * Lazily-created UserManager instance for this Prorm connection.
+     * Provides the full user / role / privilege management surface.
+     *
+     * @example
+     * await prorm.users.createUser('app', { host: '%', password: 'secret' });
+     */
+    get users(): UserManager;
+    createUser(username: string, options?: any): Promise<void>;
+    alterUser(username: string, options: any): Promise<void>;
+    dropUser(username: string, options?: any): Promise<void>;
+    getUsers(): Promise<import('./user-management').UserInfo[]>;
+    userExists(username: string, host?: string): Promise<boolean>;
+    grant(options: any): Promise<void>;
+    revoke(options: any): Promise<void>;
+    grantRole(role: string, to: string | string[], options?: any): Promise<void>;
+    revokeRole(role: string, from: string | string[], options?: any): Promise<void>;
+    createRole(roleName: string, options?: any): Promise<void>;
+    dropRole(roleName: string, options?: any): Promise<void>;
+    flushPrivileges(): Promise<void>;
+    showGrants(username: string, host?: string): Promise<any[]>;
+    getRoles(): Promise<string[]>;
+    /**
+     * CREATE FOREIGN SERVER shortcut.
+     *
+     * @example
+     * await prorm.createServer('remote_pg', {
+     *   fdw: 'postgres_fdw',
+     *   options: { host: 'remotehost', dbname: 'remotedb', port: '5432' },
+     *   ifNotExists: true,
+     * });
+     */
+    createServer(name: string, options: ForeignServerOptions): Promise<void>;
+    /**
+     * DROP FOREIGN SERVER shortcut.
+     */
+    dropServer(name: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * List all foreign servers visible in the current PostgreSQL database.
+     */
+    getServers(): Promise<ServerInfo[]>;
+    /**
+     * CREATE USER MAPPING shortcut.
+     *
+     * @example
+     * await prorm.createUserMapping({
+     *   serverName: 'remote_pg',
+     *   user: 'CURRENT_USER',
+     *   options: { user: 'remoteuser', password: 'secret' },
+     * });
+     */
+    createUserMapping(options: UserMappingOptions): Promise<void>;
+    /**
+     * DROP USER MAPPING shortcut.
+     */
+    dropUserMapping(serverName: string, user?: string): Promise<void>;
+    /**
+     * CREATE FOREIGN TABLE shortcut.
+     *
+     * @example
+     * await prorm.createForeignTable('remote_orders', {
+     *   serverName: 'remote_pg',
+     *   columns: {
+     *     id:         { type: 'INTEGER' },
+     *     total:      { type: 'NUMERIC(12,2)' },
+     *     created_at: { type: 'TIMESTAMP' },
+     *   },
+     *   options: { schema_name: 'public', table_name: 'orders' },
+     * });
+     */
+    createForeignTable(tableName: string, options: ForeignTableOptions): Promise<void>;
+    /**
+     * IMPORT FOREIGN SCHEMA shortcut.
+     *
+     * @example
+     * await prorm.importForeignSchema('public', 'remote_pg', {
+     *   localSchema: 'remote_mirror',
+     *   limitTo: ['users', 'orders'],
+     * });
+     */
+    importForeignSchema(remoteSchema: string, serverName: string, options?: ImportForeignSchemaOptions): Promise<void>;
+    /**
+     * Define a foreign table and register a read-only model for it.
+     *
+     * Works like `define()` but issues CREATE FOREIGN TABLE in the database and
+     * returns a model whose `findAll` / `findOne` / `findByPk` are usable for
+     * read-only queries.  Write operations (create/update/destroy) are not
+     * prevented at the ORM level but will fail at the database level because
+     * PostgreSQL foreign tables are read-only by default.
+     *
+     * @param tableName  - The local foreign table name
+     * @param options    - Foreign table options (serverName, columns, etc.)
+     * @returns The model class registered under `tableName`
+     *
+     * @example
+     * const RemoteUser = await prorm.defineForeignTable('remote_users', {
+     *   serverName: 'remote_pg',
+     *   columns: {
+     *     id:    { type: 'INTEGER' },
+     *     email: { type: 'TEXT' },
+     *     name:  { type: 'VARCHAR(255)' },
+     *   },
+     *   ifNotExists: true,
+     * });
+     * const users = await RemoteUser.findAll({ where: { name: 'Alice' } });
+     */
+    defineForeignTable(tableName: string, options: ForeignTableOptions): Promise<any>;
+    /**
+     * Get database version
+     */
+    getDatabaseVersion(): Promise<string>;
+    /**
+     * Get database name
+     */
+    getDatabaseName(): string;
+    /**
+     * Create a database schema
+     * @param name - Name of the schema to create
+     * @returns Promise that resolves when the schema is created
+     *
+     * @example
+     * // Create a new schema
+     * await prorm.createSchema('mySchema');
+     */
+    createSchema(name: string): Promise<void>;
+    /**
+     * Drop a database schema
+     * @param name - Name of the schema to drop
+     * @param options - Options for dropping the schema (cascade, ifExists)
+     * @returns Promise that resolves when the schema is dropped
+     *
+     * @example
+     * // Drop a schema
+     * await prorm.dropSchema('mySchema');
+     *
+     * @example
+     * // Drop schema with cascade (drop all objects in schema)
+     * await prorm.dropSchema('mySchema', { cascade: true });
+     */
+    dropSchema(name: string, options?: {
+        cascade?: boolean;
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Show all schemas
+     * @returns Promise that resolves to an array of schema names
+     *
+     * @example
+     * // Get all schemas
+     * const schemas = await prorm.showSchemas();
+     * console.log(schemas); // ['public', 'mySchema', ...]
+     */
+    showSchemas(): Promise<string[]>;
+    /**
+     * Get the full table name with schema prefix
+     * @param tableName - The table name
+     * @param schema - Optional schema name
+     * @param schemaDelimiter - Optional delimiter (default: '.')
+     * @returns Full table name with schema prefix
+     */
+    getTableNameWithSchema(tableName: string, schema?: string, schemaDelimiter?: string): string;
+    /**
+     * Create a database trigger
+     * @param options - Trigger creation options
+     * @returns Promise that resolves when the trigger is created
+     *
+     * @example
+     * // Create an INSERT trigger in PostgreSQL
+     * await prorm.createTrigger({
+     *   tableName: 'users',
+     *   triggerName: 'set_created_at',
+     *   timing: 'BEFORE',
+     *   event: 'INSERT',
+     *   body: 'NEW.created_at = NOW();',
+     *   rowLevel: true
+     * });
+     *
+     * @example
+     * // Create an UPDATE trigger in MySQL
+     * await prorm.createTrigger({
+     *   tableName: 'users',
+     *   triggerName: 'update_timestamp',
+     *   timing: 'BEFORE',
+     *   event: 'UPDATE',
+     *   body: 'SET NEW.updated_at = NOW();'
+     * });
+     */
+    createTrigger(options: {
+        tableName: string;
+        triggerName: string;
+        timing: 'BEFORE' | 'AFTER' | 'INSTEAD OF';
+        event: 'INSERT' | 'UPDATE' | 'DELETE' | 'INSERT UPDATE' | 'INSERT DELETE' | 'UPDATE DELETE' | 'INSERT UPDATE DELETE';
+        body: string;
+        schema?: string;
+        rowLevel?: boolean;
+        constraint?: string;
+        updateColumns?: string[];
+        functionName?: string;
+        functionArgs?: any[];
+    }): Promise<void>;
+    /**
+     * Drop a database trigger
+     * @param options - Trigger drop options
+     * @returns Promise that resolves when the trigger is dropped
+     *
+     * @example
+     * // Drop a trigger
+     * await prorm.dropTrigger({
+     *   tableName: 'users',
+     *   triggerName: 'set_created_at'
+     * });
+     *
+     * @example
+     * // Drop trigger with IF EXISTS (PostgreSQL)
+     * await prorm.dropTrigger({
+     *   tableName: 'users',
+     *   triggerName: 'old_trigger',
+     *   ifExists: true
+     * });
+     */
+    dropTrigger(options: {
+        tableName: string;
+        triggerName: string;
+        schema?: string;
+        ifExists?: boolean;
+        cascade?: boolean;
+        constraint?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a custom aggregate function (algorithm) in PostgreSQL
+     * PostgreSQL supports creating custom aggregate functions using CREATE AGGREGATE
+     *
+     * @param options - Algorithm creation options
+     * @returns Promise that resolves when the algorithm is created
+     *
+     * @example
+     * // Create a custom aggregate function in PostgreSQL
+     * await prorm.createAlgorithm({
+     *   name: 'my_aggregate',
+     *   arguments: ['integer'],
+     *   stateType: 'integer',
+     *   stateFunction: 's = s + $1',
+     *   finalFunction: 's = s'
+     * });
+     *
+     * @example
+     * // Create a custom aggregate with multiple parameters
+     * await prorm.createAlgorithm({
+     *   name: 'weighted_avg',
+     *   arguments: ['numeric', 'numeric'],
+     *   stateType: 'numeric',
+     *   stateFunction: 's = s + ($1 * $2)',
+     *   finalFunction: 's = s'
+     * });
+     */
+    createAlgorithm(options: {
+        /** Name of the aggregate function to create */
+        name: string;
+        /** Input data types for the aggregate */
+        arguments: string[];
+        /** The state type (intermediate state data type) */
+        stateType: string;
+        /** The state transition function body */
+        stateFunction: string;
+        /** The final function body (optional) */
+        finalFunction?: string;
+        /** The initial condition value (optional) */
+        initialCondition?: string;
+        /** Schema name (optional) */
+        schema?: string;
+        /** If true, replaces existing aggregate (PostgreSQL 9.5+) */
+        replace?: boolean;
+        /** Parallel mode: UNSAFE, SAFE, or RESTRICTED */
+        parallel?: 'UNSAFE' | 'SAFE' | 'RESTRICTED';
+        /** Language for the function (default: sql) */
+        language?: string;
+    }): Promise<void>;
+    /**
+     * Drop a custom aggregate function (algorithm) from PostgreSQL
+     *
+     * @param options - Algorithm drop options
+     * @returns Promise that resolves when the algorithm is dropped
+     *
+     * @example
+     * // Drop an algorithm
+     * await prorm.dropAlgorithm({
+     *   name: 'my_aggregate',
+     *   arguments: ['integer']
+     * });
+     *
+     * @example
+     * // Drop algorithm with IF EXISTS
+     * await prorm.dropAlgorithm({
+     *   name: 'my_aggregate',
+     *   arguments: ['integer'],
+     *   ifExists: true
+     * });
+     */
+    dropAlgorithm(options: {
+        /** Name of the aggregate function to drop */
+        name: string;
+        /** Input data types for the aggregate */
+        arguments: string[];
+        /** Schema name (optional) */
+        schema?: string;
+        /** If true, uses IF EXISTS (PostgreSQL 9.3+) */
+        ifExists?: boolean;
+        /** If true, CASCADE dependent objects */
+        cascade?: boolean;
+        /** If true, RESTRICT if dependent objects exist */
+        restrict?: boolean;
+    }): Promise<void>;
+    /**
+     * Add a new column to a table
+     */
+    addColumn(tableName: string, columnName: string, attribute: AttributeOptions): Promise<void>;
+    /**
+     * Remove a column from a table
+     */
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    /**
+     * Change a column definition
+     */
+    changeColumn(tableName: string, columnName: string, attribute: AttributeOptions): Promise<void>;
+    /**
+     * Rename a table
+     */
+    renameTable(oldName: string, newName: string): Promise<void>;
+    /**
+     * Add an index
+     */
+    addIndex(tableName: string, indexName: string, fields: string[], options?: {
+        unique?: boolean;
+        type?: string;
+    }): Promise<void>;
+    /**
+     * Remove an index
+     */
+    removeIndex(tableName: string, indexName: string): Promise<void>;
+    /**
+     * Describe a table
+     */
+    describeTable(tableName: string): Promise<Record<string, unknown>>;
+    /**
+     * Sync all models to database
+     *
+     * @param options - Sync options
+     * @returns Promise that resolves when sync is complete
+     *
+     * @example
+     * // Safe sync - creates missing tables only (default)
+     * await prorm.sync()
+     *
+     * @example
+     * // Force sync - drops all tables and recreates them (destroys data!)
+     * await prorm.sync({ force: true })
+     *
+     * @example
+     * // Alter sync - modifies tables to match models (preserves data)
+     * await prorm.sync({ alter: true })
+     *
+     * @example
+     * // Conditional sync - only syncs if database name matches pattern
+     * await prorm.sync({ match: /test/ })
+     */
+    /**
+     * Create a new database with the specified options.
+     * Supports PostgreSQL, MySQL, and MariaDB.
+     *
+     * @example
+     * // Create database with PostgreSQL
+     * await prorm.createDatabase({
+     *   name: 'myapp',
+     *   encoding: 'UTF8',
+     *   lcCollate: 'en_US.UTF-8',
+     *   lcCtype: 'en_US.UTF-8',
+     *   template: 'template0',
+     * });
+     *
+     * @example
+     * // Create database with MySQL/MariaDB
+     * await prorm.createDatabase({
+     *   name: 'myapp',
+     *   encoding: 'UTF8',
+     *   collate: 'utf8mb4_unicode_ci',
+     * });
+     */
+    createDatabase(options: {
+        name: string;
+        encoding?: string;
+        lcCollate?: string;
+        lcCtype?: string;
+        template?: string;
+        tablespace?: string;
+        collate?: string;
+        isTemplate?: boolean;
+    }): Promise<void>;
+    /**
+     * Drop a database if it exists.
+     *
+     * @example
+     * await prorm.dropDatabase('olddb');
+     */
+    dropDatabase(name: string): Promise<void>;
+    sync(options?: SyncOptions): Promise<this>;
+    /**
+     * Register a class carrying `@Procedure` / `@SqlFunction` annotations so that
+     * `sync()` creates them.
+     *
+     * Procedures are declared on plain classes rather than models, so there is no
+     * other point at which the ORM would learn about them.
+     */
+    /**
+     * Register an object or key-value store for use by `@ExternalField`.
+     *
+     * Accepts any of the shipped stores (S3, MinIO, R2, GCS, Azure Blob, Redis,
+     * ...) directly - the differing method names are normalized internally - or
+     * any object implementing `ExternalStoreAdapter`.
+     *
+     * ```typescript
+     * const s3 = new S3Store({ region: 'us-east-1' });
+     * await s3.connect();
+     * prorm.registerStore('assets', s3, { defaultBucket: 'avatars' });
+     * ```
+     */
+    registerStore(name: string, store: unknown, options?: RegisterStoreOptions): this;
+    registerProcedures(procedureClass: Function): this;
+    /**
+     * Apply the DDL declared by annotations: `@View`, `@MaterializedView`,
+     * `@Trigger` on model classes, and `@Procedure` / `@SqlFunction` on classes
+     * passed to `registerProcedures()`.
+     *
+     * These registries previously generated correct SQL that nothing executed -
+     * `ViewRegistry`, `getTriggers` and `ProcedureRegistry` were referenced only
+     * from inside `src/decorators/`, so annotating a class produced a string the
+     * user still had to fetch and hand to `prorm.query()` themselves.
+     */
+    private syncSchemaObjects;
+    /**
+     * Bind every queued decorator association whose target model is registered.
+     *
+     * Called after each `addModel()`, and again by `sync()` so that a model graph
+     * registered in any order ends up fully wired before tables are created.
+     * Associations whose target is still unregistered stay queued.
+     */
+    private _flushPendingAssociations;
+    /**
+     * Names of models referenced by a decorator association that were never
+     * registered, so callers can report them rather than silently skipping.
+     */
+    private _unresolvedAssociationTargets;
+    /**
+     * Issue a real `SELECT COUNT(...)` for a model.
+     *
+     * Honors `where`, paranoid filtering, filtering (`required`) includes,
+     * `distinct`/`col` and `group`:
+     *  - `col` picks the counted expression (`COUNT("col")`)
+     *  - `distinct: true` counts distinct values of `col`, or of the primary key
+     *  - `group` returns the number of groups
+     */
+    private _countRows;
+    /**
+     * The view of this instance that the shared eager-loader needs.
+     */
+    private eagerLoadContext;
+    /**
+     * Order models so that every table is created after the tables it references.
+     *
+     * Table creation used to follow `modelDefinitions` insertion order, i.e. the
+     * order the user happened to call `define()` in, while `createTableFromModel`
+     * simultaneously emitted REFERENCES clauses. On any dialect that validates
+     * foreign keys at creation time, defining `Post` before `User` failed. The
+     * ordering is derived from the association graph so declaration order stops
+     * mattering.
+     *
+     * Cycles (two models referencing each other) can't be resolved by ordering
+     * alone; those models are emitted last in declaration order, which is the same
+     * behaviour as before for that case.
+     */
+    private orderModelsByDependency;
+    /**
+     * Default sync mode - creates missing tables only (safe)
+     */
+    private syncCreate;
+    /**
+     * Force sync mode - drops all tables and recreates them
+     */
+    private syncForce;
+    /**
+     * Alter sync mode - modifies tables to match models (preserves data)
+     */
+    private syncAlter;
+    /**
+     * Alter a table to match model definition
+     */
+    private alterTable;
+    /**
+     * Build column definitions from model attributes
+     */
+    private buildColumnDefinitions;
+    /**
+     * Check if a column needs to be changed
+     */
+    private columnNeedsChange;
+    /**
+     * Normalize column type for comparison
+     */
+    private normalizeType;
+    /**
+     * Get the migration configuration
+     */
+    getMigrator(): any;
+    /**
+     * Run pending migrations
+     */
+    migrate(options?: {
+        migration?: string;
+    }): Promise<any>;
+    /**
+     * Revert migrations
+     */
+    migrateUndo(options?: {
+        steps?: number;
+        migration?: string;
+    }): Promise<any>;
+    /**
+     * Get migration status
+     */
+    migrateStatus(): Promise<any>;
+    /**
+     * Create a SQL function expression
+     * @param fnName - The SQL function name (e.g., 'COUNT', 'UPPER', 'YEAR', 'SUM', 'AVG', 'LOWER')
+     * @param args - The arguments to the function (column names, column references, or other functions)
+     * @returns A Fn object that can be used in query attributes
+     *
+     * @example
+     * // COUNT(id) -> COUNT(id)
+     * prorm.fn('COUNT', 'id')
+     *
+     * // UPPER(name) -> UPPER(name)
+     * prorm.fn('UPPER', prorm.col('name'))
+     *
+     * // YEAR(createdAt) -> YEAR(createdAt)
+     * prorm.fn('YEAR', 'createdAt')
+     *
+     * // COUNT with column reference
+     * prorm.fn('COUNT', prorm.col('id'))
+     *
+     * // Nested function: UPPER(LOWER(name))
+     * prorm.fn('UPPER', prorm.fn('LOWER', 'name'))
+     *
+     * // Use in findAll
+     * User.findAll({
+     *   attributes: ['role', [prorm.fn('COUNT', prorm.col('id')), 'count']]
+     * })
+     */
+    fn(fnName: string, ...args: (string | Col | Fn | Literal)[]): Fn;
+    /**
+     * Create a column reference for use in SQL functions
+     * @param tableOrColumn - Table name (if second param provided) or column name
+     * @param column - Column name (if first param is table name)
+     * @returns A Col object that can be used as an argument to prorm.fn()
+     *
+     * @example
+     * // Reference a column in a function
+     * prorm.fn('COUNT', prorm.col('id'))
+     *
+     * // Reference with table name: col('User', 'name') -> "User"."name"
+     * prorm.fn('UPPER', prorm.col('User', 'name'))
+     *
+     * // Dot notation: col('table.column') -> "table"."column"
+     * prorm.fn('UPPER', prorm.col('User.name'))
+     *
+     * // Use in findAll
+     * User.findAll({
+     *   attributes: ['role', [prorm.fn('COUNT', prorm.col('id')), 'count']]
+     * })
+     */
+    col(tableOrColumn: string, column?: string): Col;
+    /**
+     * Create a literal SQL expression
+     * Use this to inject raw SQL directly into queries
+     * @param sql - The raw SQL expression
+     * @returns A Literal object that will be inserted as-is into the SQL query
+     *
+     * @example
+     * // Use literal in where clause
+     * User.findAll({
+     *   where: prorm.literal('COUNT(role) > 1')
+     * })
+     *
+     * // Use literal in attributes for complex expressions
+     * User.findAll({
+     *   attributes: [[prorm.literal("'prefix' || name"), 'prefixedName']]
+     * })
+     */
+    /**
+     * Create a type cast expression
+     * Used to cast a value to a specific data type in SQL queries
+     * @param value - The value to cast (column reference, literal, or other expression)
+     * @param type - The target data type (e.g., 'VARCHAR', 'INTEGER', 'DATE', 'BOOLEAN')
+     * @returns A Cast object that can be used in queries
+     *
+     * @example
+     * // Cast a string to integer
+     * prorm.cast(prorm.col('count'), 'INTEGER')
+     *
+     * // Cast a value to date
+     * prorm.cast(prorm.col('timestamp'), 'DATETIME')
+     *
+     * // Cast in where clause
+     * User.findAll({
+     *   where: prorm.cast(prorm.col('active'), 'BOOLEAN')
+     * })
+     *
+     * // Use in attributes for type conversion
+     * User.findAll({
+     *   attributes: [[prorm.cast(prorm.col('price'), 'VARCHAR'), 'priceStr']]
+     * })
+     */
+    cast(value: string | Col | Fn | Literal, type: string): Cast;
+    /**
+     * UUIDV4 default value for generating UUIDs
+     * Use as defaultValue in model definitions
+     * @returns A Literal that generates a UUID v4
+     *
+     * @example
+     * const User = prorm.define('User', {
+     *   id: { type: DataTypes.UUID, defaultValue: Prorm.UUIDV4, primaryKey: true },
+     *   uuid: { type: DataTypes.UUID, defaultValue: prorm.UUIDV4 }
+     * });
+     */
+    get UUIDV4(): Literal;
+    /**
+     * Create a where condition for complex queries
+     * Allows creating custom WHERE clauses with operators
+     * @param condition - The condition object or literal SQL
+     * @param replacements - Optional replacements for the condition
+     * @returns A WhereObject for use in find options
+     *
+     * @example
+     * // Simple equality with column reference
+     * prorm.where(prorm.col('name'), 'John')
+     *
+     * // With a comparator operator
+     * prorm.where(prorm.col('age'), { $gt: 18 })
+     *
+     * // Complex condition with literal
+     * prorm.where(prorm.literal('LOWER(name)'), 'john')
+     *
+     * // Using with fn
+     * prorm.where(prorm.fn('YEAR', prorm.col('createdAt')), 2024)
+     */
+    where(col: Col | Fn | Literal, value: unknown): WhereObject;
+    /**
+     * Create an AND condition for combining multiple where conditions
+     * @param conditions - The conditions to combine with AND
+     * @returns An AndOrObject with AND operator
+     *
+     * @example
+     * // Combine multiple conditions
+     * prorm.and(
+     *   { name: 'John' },
+     *   { age: { $gte: 18 } }
+     * )
+     *
+     * // Use in where clause
+     * User.findAll({
+     *   where: prorm.and(
+     *     { status: 'active' },
+     *     { role: 'admin' }
+     *   )
+     * })
+     *
+     * // Nested with or
+     * prorm.and(
+     *   { active: true },
+     *   prorm.or({ role: 'admin' }, { role: 'moderator' })
+     * )
+     */
+    and(...conditions: unknown[]): AndOrObject;
+    /**
+     * Create an OR condition for combining multiple where conditions
+     * @param conditions - The conditions to combine with OR
+     * @returns An AndOrObject with OR operator
+     *
+     * @example
+     * // Combine multiple conditions
+     * prorm.or(
+     *   { name: 'John' },
+     *   { name: 'Jane' }
+     * )
+     *
+     * // Use in where clause
+     * User.findAll({
+     *   where: prorm.or(
+     *     { status: 'active' },
+     *     { role: 'admin' }
+     *   )
+     * })
+     *
+     * // Complex nested condition
+     * prorm.or(
+     *   prorm.and({ status: 'active' }, { role: 'admin' }),
+     *   { id: 1 }
+     * )
+     */
+    or(...conditions: unknown[]): AndOrObject;
+    /**
+     * Create a JSON path query for querying JSON columns
+     * Used to query specific paths in JSON columns (PostgreSQL, MySQL JSON)
+     * @param path - The JSON path to query (dot notation or array notation)
+     * @param value - Optional value to compare against
+     * @returns A JsonObject for use in where clauses
+     *
+     * @example
+     * // Query JSON column path
+     * prorm.json('profile.name')
+     *
+     * // Query nested JSON path
+     * prorm.json('settings.theme.color')
+     *
+     * // Query with value comparison
+     * prorm.json('profile.age', 25)
+     *
+     * // Use in where clause
+     * User.findAll({
+     *   where: prorm.json('profile.isActive', true)
+     * })
+     *
+     * // Query array element
+     * prorm.json('tags[0]', 'important')
+     */
+    json(path: string, value?: unknown): JsonObject;
+    /**
+     * Static version of the where method - creates a WHERE condition
+     * Can be used without instantiating Prorm
+     * @param col - The column reference (Col, Fn, or Literal)
+     * @param value - The value or condition to compare against
+     * @returns A WhereObject for use in find options
+     */
+    static where(col: Col | Fn | Literal, value: unknown): WhereObject;
+    /**
+     * Static version of the and method - combines conditions with AND
+     * Can be used without instantiating Prorm
+     * @param conditions - The conditions to combine with AND
+     * @returns An AndOrObject with AND operator
+     */
+    static and(...conditions: unknown[]): AndOrObject;
+    /**
+     * Static version of the or method - combines conditions with OR
+     * Can be used without instantiating Prorm
+     * @param conditions - The conditions to combine with OR
+     * @returns An AndOrObject with OR operator
+     */
+    static or(...conditions: unknown[]): AndOrObject;
+    /**
+     * Static version of the json method - creates a JSON path query
+     * Can be used without instantiating Prorm
+     * @param path - The JSON path to query
+     * @param value - Optional value to compare against
+     * @returns A JsonObject for use in where clauses
+     */
+    static json(path: string, value?: unknown): JsonObject;
+    /**
+     * Static version of the validate method - validates a model's values
+     * Can be used without instantiating Prorm
+     * @param values - The values to validate
+     * @param options - Validation options
+     * @returns A promise that resolves with validation errors
+     */
+    static validate(values: Record<string, unknown>, options?: {
+        model?: ModelStatic<AnyModel>;
+    }): Promise<ValidationError | null>;
+}
+/**
+ * Represents a SQL function expression
+ * Used with prorm.fn() to create SQL functions like COUNT, UPPER, YEAR, etc.
+ */
+export interface Fn {
+    /**
+     * The SQL function name (e.g., 'COUNT', 'UPPER', 'YEAR')
+     */
+    fn: string;
+    /**
+     * The arguments to the function (can be column references, literals, or other functions)
+     */
+    args: (string | Col | Fn | Literal)[];
+}
+/**
+ * Represents a SQL CAST expression
+ * Used to cast a value to a specific data type
+ */
+export interface Cast {
+    /**
+     * Type identifier for CAST
+     */
+    $type: 'cast';
+    /**
+     * The value to cast (column reference, literal, or function)
+     */
+    value: string | Col | Fn | Literal;
+    /**
+     * The target data type (e.g., 'VARCHAR', 'INTEGER', 'DATE', 'BOOLEAN')
+     */
+    type: string;
+}
+/**
+ * Represents a WHERE condition for complex queries
+ */
+export interface WhereObject {
+    /**
+     * Type identifier for WHERE
+     */
+    $type: 'where';
+    /**
+     * The column or expression to compare
+     */
+    col: Col | Fn | Literal;
+    /**
+     * The value or condition to compare against
+     */
+    value: unknown;
+}
+/**
+ * Represents an AND or OR combination of conditions
+ */
+export interface AndOrObject {
+    /**
+     * Type identifier - 'and' or 'or'
+     */
+    $type: 'and' | 'or';
+    /**
+     * The conditions to combine
+     */
+    conditions: unknown[];
+}
+/**
+ * Represents a JSON path query for JSON columns
+ */
+export interface JsonObject {
+    /**
+     * Type identifier for JSON
+     */
+    $type: 'json';
+    /**
+     * The JSON path to query (dot notation or array notation)
+     */
+    path: string;
+    /**
+     * Optional value to compare against
+     */
+    value?: unknown;
+}
+/**
+ * DataTypes for model definitions
+ */
+export declare const DataTypes: {
+    STRING: (length?: number) => DataType;
+    CHAR: (length?: number) => DataType;
+    TEXT: (length?: number) => DataType;
+    INTEGER: () => DataType;
+    BIGINT: () => DataType;
+    FLOAT: () => DataType;
+    DOUBLE: () => DataType;
+    DECIMAL: (precision?: number, scale?: number) => DataType;
+    BOOLEAN: () => DataType;
+    DATE: () => DataType;
+    DATEONLY: () => DataType;
+    TIME: () => DataType;
+    BLOB: () => DataType;
+    ENUM: (...values: string[]) => DataType;
+    JSON: () => DataType;
+    JSONB: () => DataType;
+    UUID: () => DataType;
+};
+export * from './types';
+export { Dialect, DialectOptions, ColumnDefinition, TableOptions } from './dialects/dialect';
+export { SQLiteDialect } from './dialects/sqlite';
+export { OracleDialect } from './dialects/oracle';