ts-prorm-orm 1.1.0 → 1.2.0

package/dist/types/index.d.ts

@@ -0,0 +1,3123 @@
+/**
+ * TypeScript interfaces for the Prorm-like ORM
+ */
+/**
+ * Referential actions for foreign key constraints (onDelete / onUpdate).
+ *
+ * This enum is a companion to the existing string-literal unions used for
+ * `onDelete`/`onUpdate` fields (e.g. `'CASCADE' | 'RESTRICT' | ...`). Both
+ * forms are accepted wherever these fields appear, so existing string
+ * literals continue to work unchanged.
+ *
+ * @example
+ * ```ts
+ * import { ReferentialAction } from 'prorm';
+ *
+ * User.hasMany(Post, {
+ *   foreignKey: 'userId',
+ *   onDelete: ReferentialAction.Cascade,
+ *   onUpdate: ReferentialAction.Cascade,
+ * });
+ *
+ * // Equivalent to the string-literal form:
+ * User.hasMany(Post, {
+ *   foreignKey: 'userId',
+ *   onDelete: 'CASCADE',
+ *   onUpdate: 'CASCADE',
+ * });
+ * ```
+ */
+export declare enum ReferentialAction {
+    Cascade = "CASCADE",
+    Restrict = "RESTRICT",
+    SetNull = "SET NULL",
+    NoAction = "NO ACTION",
+    SetDefault = "SET DEFAULT"
+}
+/**
+ * Minimum log level for Prorm's built-in logger.
+ *
+ * This enum is a companion to the existing string-literal union used for
+ * `loggingLevel` (`'debug' | 'info' | 'warn' | 'error'`). Both forms are
+ * accepted wherever this field appears, so existing string literals
+ * continue to work unchanged.
+ *
+ * @example
+ * ```ts
+ * import { LoggingLevel } from 'prorm';
+ *
+ * new Prorm({
+ *   dialect: 'postgres',
+ *   loggingLevel: LoggingLevel.Warn,
+ * });
+ *
+ * // Equivalent to the string-literal form:
+ * new Prorm({
+ *   dialect: 'postgres',
+ *   loggingLevel: 'warn',
+ * });
+ * ```
+ */
+export declare enum LoggingLevel {
+    Debug = "debug",
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
+}
+/**
+ * Refresh method for materialized views
+ */
+export type RefreshMethod = 'FAST' | 'COMPLETE' | 'FORCE';
+/**
+ * Build mode for materialized views (Oracle)
+ */
+export type BuildMode = 'IMMEDIATE' | 'DEFERRED';
+/**
+ * Refresh timing for materialized views (Oracle)
+ */
+export type RefreshOn = 'COMMIT' | 'DEMAND';
+/**
+ * Options for refreshing a materialized view
+ */
+export interface RefreshOptions {
+    /** If true, uses CONCURRENTLY (requires unique index on the view) - PostgreSQL only */
+    concurrently?: boolean;
+    /** If true, uses WITH NO DATA (creates view without populating data) */
+    withNoData?: boolean;
+    /** Schema name for the materialized view */
+    schema?: string;
+    /** Refresh method: FAST, COMPLETE, or FORCE (Oracle) */
+    refresh?: RefreshMethod;
+}
+/**
+ * Options for creating a materialized view
+ */
+export interface MaterializedViewOptions {
+    /** Name of the materialized view */
+    name: string;
+    /** The SELECT query that defines the materialized view */
+    query: string;
+    /** Schema to create the materialized view in (PostgreSQL) */
+    schema?: string;
+    /** If true, uses CREATE MATERIALIZED VIEW IF NOT EXISTS */
+    ifNotExists?: boolean;
+    /** If true, uses CREATE OR REPLACE MATERIALIZED VIEW */
+    replace?: boolean;
+    /** Columns to include in the WITH DATA clause (for initial data load) */
+    withData?: boolean;
+    /** Unique index name for CONCURRENTLY refresh support */
+    uniqueIndex?: string;
+    /** Optional comment for the materialized view */
+    comment?: string;
+    /** Build mode: IMMEDIATE or DEFERRED (Oracle) */
+    build?: BuildMode;
+    /** Refresh method: FAST, COMPLETE, or FORCE (Oracle) */
+    refresh?: RefreshMethod;
+    /** Refresh timing: COMMIT or DEMAND (Oracle) */
+    on?: RefreshOn;
+    /**
+     * Ongoing maintenance mode: 'IMMEDIATE' keeps the materialized view in
+     * sync automatically on every write to a base table; 'DEFERRED' only
+     * updates it when explicitly refreshed (Db2: `REFRESH IMMEDIATE|DEFERRED`).
+     * This is independent of `withData`, which only controls whether the view
+     * is populated at creation time. Defaults to 'DEFERRED' to avoid the perf
+     * cost of continuous auto-maintenance unless explicitly requested.
+     */
+    refreshMode?: 'IMMEDIATE' | 'DEFERRED';
+}
+/**
+ * Options for dropping a materialized view
+ */
+export interface DropMaterializedViewOptions {
+    /** If true, does not throw error if materialized view does not exist */
+    ifExists?: boolean;
+    /** If true, also drops dependent materialized views (CASCADE) */
+    cascade?: boolean;
+    /** Schema name for the materialized view */
+    schema?: string;
+}
+/**
+ * Options for creating/dropping a materialized view log (Oracle).
+ *
+ * A materialized view log is created on a *master table* (not on the
+ * materialized view itself) and is a prerequisite for `FAST` (incremental)
+ * refresh of any materialized view built on that table - without a log,
+ * `REFRESH FAST` fails with ORA-23413 ("table does not have a materialized
+ * view log").
+ *
+ * Oracle syntax:
+ * ```sql
+ * CREATE MATERIALIZED VIEW LOG ON table_name
+ *   [WITH [ROWID] [, PRIMARY KEY] [, SEQUENCE] [(col1, col2, ...)] [INCLUDING NEW VALUES]]
+ * DROP MATERIALIZED VIEW LOG ON table_name
+ * ```
+ */
+export interface MaterializedViewLogOptions {
+    /** Schema the master table (and resulting log) belongs to. */
+    schema?: string;
+    /**
+     * Include ROWID in the log (`WITH ROWID`). Required for fast refresh of
+     * materialized views without a primary key, or that use ROWID as the
+     * join/lookup key.
+     */
+    withRowid?: boolean;
+    /**
+     * Include the primary key in the log (`WITH PRIMARY KEY`). This is
+     * Oracle's own default when neither `withRowid` nor `withPrimaryKey` is
+     * specified, so this library defaults to it as well when nothing is set.
+     */
+    withPrimaryKey?: boolean;
+    /**
+     * Include a SEQUENCE value in the log (`WITH ... SEQUENCE`). Required for
+     * fast refresh of materialized views that involve joins or set operators
+     * such as UNION.
+     */
+    sequence?: boolean;
+    /**
+     * Specific filter columns to log in addition to the logging key
+     * (`WITH ... (col1, col2, ...)`). Needed for fast refresh of materialized
+     * views that aggregate or reference specific columns.
+     */
+    columns?: string[];
+    /**
+     * Log the new values of columns, not just old values (`INCLUDING NEW
+     * VALUES`). Required for fast refresh of materialized views containing
+     * aggregate functions. Defaults to true since that is the common case for
+     * fast-refreshable materialized views.
+     */
+    includingNewValues?: boolean;
+}
+/**
+ * Options for creating a stored procedure
+ */
+export interface StoredProcedureOptions {
+    /** Name of the stored procedure */
+    name: string;
+    /** Schema where the stored procedure belongs */
+    schema?: string;
+    /** Input parameters */
+    params?: StoredProcedureParam[];
+    /** The procedure body (SQL statements) */
+    body: string;
+    /** Return type (for functions) */
+    returnType?: string;
+    /** Language (SQL, PL/pgSQL, etc.) */
+    language?: string;
+    /** If true, uses CREATE OR REPLACE */
+    replace?: boolean;
+    /** If true, does not throw if already exists */
+    ifNotExists?: boolean;
+    /** Optional comment */
+    comment?: string;
+}
+/**
+ * Parameter for stored procedure
+ */
+export interface StoredProcedureParam {
+    /** Parameter name (without @ for T-SQL, $1 for PostgreSQL) */
+    name: string;
+    /** Data type */
+    type: string;
+    /** Parameter mode */
+    mode?: 'IN' | 'OUT' | 'INOUT';
+    /** Default value */
+    defaultValue?: any;
+}
+/**
+ * Options for dropping a stored procedure
+ */
+export interface DropStoredProcedureOptions {
+    /** If true, does not throw error if procedure does not exist */
+    ifExists?: boolean;
+    /** If true, also drops dependent objects (CASCADE) */
+    cascade?: boolean;
+    /** Schema (for PostgreSQL) */
+    schema?: string;
+    /**
+     * Explicit argument type signature for the procedure (e.g. ['VARCHAR', 'NUMBER']).
+     * Required by dialects (e.g. Snowflake) whose DROP PROCEDURE syntax must match the
+     * exact argument types the procedure was created with, since procedures are
+     * overloadable by signature.
+     */
+    paramTypes?: string[];
+}
+/**
+ * Options for executing a stored procedure
+ */
+export interface ExecuteStoredProcedureOptions {
+    /** Procedure name */
+    procedureName: string;
+    /** Schema (for PostgreSQL) */
+    schema?: string;
+    /** Input parameters */
+    params?: Record<string, any>;
+    /** Timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Options for creating a user-defined function (UDF).
+ *
+ * Deliberately shaped to mirror `StoredProcedureOptions` as closely as
+ * possible, since `CREATE FUNCTION` and `CREATE PROCEDURE` share almost
+ * identical grammar in Postgres-family dialects (CockroachDB, Postgres).
+ * The main differences are that a function always has a `returnType` and
+ * may declare a `volatility` category, which procedures do not have.
+ */
+export interface FunctionOptions {
+    /** Name of the function */
+    name: string;
+    /** Schema where the function belongs */
+    schema?: string;
+    /** Input parameters */
+    params?: StoredProcedureParam[];
+    /** The function body (SQL statements / expression) */
+    body: string;
+    /** Return type. Required: unlike procedures, functions always return a value. */
+    returnType: string;
+    /** Language (SQL, plpgsql, etc.). Defaults to 'SQL'. */
+    language?: string;
+    /**
+     * Volatility/optimization category:
+     * - `VOLATILE` (default if omitted): may modify the database and/or return
+     *   different results on successive calls with the same arguments.
+     * - `STABLE`: cannot modify the database, and is guaranteed to return the
+     *   same results given the same arguments within a single statement.
+     * - `IMMUTABLE`: cannot modify the database and always returns the same
+     *   results given the same arguments. Required for use in computed columns.
+     */
+    volatility?: 'VOLATILE' | 'STABLE' | 'IMMUTABLE';
+    /** If true, uses CREATE OR REPLACE */
+    replace?: boolean;
+    /** If true, does not throw if already exists */
+    ifNotExists?: boolean;
+    /** Optional comment */
+    comment?: string;
+}
+/**
+ * Options for dropping a user-defined function
+ */
+export interface DropFunctionOptions {
+    /** If true, does not throw error if function does not exist */
+    ifExists?: boolean;
+    /** If true, also drops dependent objects (CASCADE) */
+    cascade?: boolean;
+    /** Schema (for PostgreSQL/CockroachDB) */
+    schema?: string;
+    /**
+     * Explicit argument type signature for the function (e.g. ['INT', 'TEXT']).
+     * Required to disambiguate overloaded functions sharing the same name but
+     * different argument types.
+     */
+    paramTypes?: string[];
+}
+/**
+ * Options for creating a trigger
+ */
+export interface TriggerOptions {
+    /** Trigger name */
+    name: string;
+    /** Table to attach trigger to */
+    tableName: string;
+    /** Timing: BEFORE, AFTER, or INSTEAD OF */
+    timing: 'BEFORE' | 'AFTER' | 'INSTEAD OF';
+    /** Events: INSERT, UPDATE, DELETE */
+    events: Array<'INSERT' | 'UPDATE' | 'DELETE'>;
+    /** Trigger body (SQL statements) */
+    body: string;
+    /** For each row or for each statement */
+    level?: 'ROW' | 'STATEMENT';
+    /** Schema (for PostgreSQL) */
+    schema?: string;
+    /** If true, uses OR REPLACE */
+    replace?: boolean;
+    /** Constraint name for triggers that fire on constraint */
+    constraint?: string;
+    /** REFERENCING clause for transition tables (PostgreSQL) */
+    referencing?: {
+        oldRow?: string;
+        newRow?: string;
+    };
+    /** Optional comment */
+    comment?: string;
+    /** WHEN clause for conditional triggers (Oracle, PostgreSQL) */
+    when?: string;
+}
+/**
+ * Options for dropping a trigger
+ */
+export interface DropTriggerOptions {
+    /** If true, does not throw error if trigger does not exist */
+    ifExists?: boolean;
+    /** If true, also drops dependent objects (CASCADE) */
+    cascade?: boolean;
+    /** Schema (for PostgreSQL) */
+    schema?: string;
+}
+/**
+ * Schedule options for MySQL events (AT timestamp or EVERY interval)
+ */
+export interface EventSchedule {
+    /** Schedule type: AT a specific timestamp or EVERY interval */
+    type: 'AT' | 'EVERY';
+    /** Timestamp for AT schedule (YYYY-MM-DD HH:MM:SS) */
+    timestamp?: string;
+    /** Interval value (e.g., 1, 2, 3) */
+    intervalValue?: number;
+    /** Interval unit (SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, YEAR) */
+    intervalUnit?: 'SECOND' | 'MINUTE' | 'HOUR' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR';
+    /** STARTS clause - when to start */
+    starts?: string;
+    /** ENDS clause - when to end */
+    ends?: string;
+    /** ON SCHEDULE PRESERVE - keeps event after execution */
+    preserve?: boolean;
+}
+/**
+ * Options for creating an event
+ */
+export interface CreateEventOptions {
+    /** Event name */
+    name: string;
+    /** Schedule (AT timestamp or EVERY interval) */
+    schedule: EventSchedule;
+    /** Event body (SQL statements) */
+    body: string;
+    /** Schema (for MySQL database) */
+    schema?: string;
+    /** If true, uses CREATE EVENT IF NOT EXISTS */
+    ifNotExists?: boolean;
+    /** If true, uses OR REPLACE */
+    replace?: boolean;
+    /** Comment */
+    comment?: string;
+    /** Enable or disable the event (ENABLED/DISABLED) */
+    status?: 'ENABLED' | 'DISABLED';
+    /** ON COMPLETION PRESERVE (default) or ON COMPLETION DROP */
+    onCompletion?: 'PRESERVE' | 'DROP';
+}
+/**
+ * Options for dropping an event
+ */
+export interface DropEventOptions {
+    /** If true, does not throw error if event does not exist */
+    ifExists?: boolean;
+    /** Schema (for MySQL database) */
+    schema?: string;
+}
+/**
+ * Options for altering an event
+ */
+export interface AlterEventOptions {
+    /** Event name */
+    name: string;
+    /** New schedule */
+    schedule?: EventSchedule;
+    /** New body */
+    body?: string;
+    /** Schema (for MySQL database) */
+    schema?: string;
+    /** Enable or disable the event */
+    status?: 'ENABLED' | 'DISABLED';
+    /** Comment */
+    comment?: string;
+}
+/**
+ * Enhanced stored procedure options with full PL/SQL support
+ */
+export interface CreateProcedureOptions {
+    /** Procedure name */
+    name: string;
+    /** Schema where the procedure belongs */
+    schema?: string;
+    /** Parameters */
+    params?: StoredProcedureParam[];
+    /** Procedure body (SQL statements) */
+    body: string;
+    /** If true, drops existing procedure first */
+    replace?: boolean;
+    /** If true, does not throw if already exists */
+    ifNotExists?: boolean;
+    /** Optional comment */
+    comment?: string;
+}
+/**
+ * Options for creating a sequence
+ */
+export interface SequenceOptions {
+    /** Sequence name */
+    name: string;
+    /** Schema (for PostgreSQL) */
+    schema?: string;
+    /** Starting value */
+    startWith?: number;
+    /** Minimum value */
+    minvalue?: number;
+    /** Maximum value */
+    maxvalue?: number;
+    /** Increment value */
+    incrementBy?: number;
+    /** Whether sequence cycles */
+    cycle?: boolean;
+    /** Cache size */
+    cache?: number;
+    /** If true, uses CREATE SEQUENCE IF NOT EXISTS */
+    ifNotExists?: boolean;
+    /** If true, uses CREATE OR REPLACE */
+    replace?: boolean;
+    /** Temporary sequence (exists only for session) */
+    temporary?: boolean;
+    /** Owned by a column */
+    ownedBy?: string;
+    /** Force ordering (Oracle) */
+    order?: boolean;
+    /** No cache (Oracle) */
+    nocache?: boolean;
+}
+/**
+ * Options for dropping a sequence
+ */
+export interface DropSequenceOptions {
+    /** If true, does not throw error if sequence does not exist */
+    ifExists?: boolean;
+    /** If true, also drops dependent objects (CASCADE) */
+    cascade?: boolean;
+    /** Schema (for PostgreSQL) */
+    schema?: string;
+}
+/**
+ * Options for creating a policy (PostgreSQL RLS)
+ */
+export interface PolicyOptions {
+    /** Policy name */
+    name: string;
+    /** Table name */
+    tableName: string;
+    /** If true, creates a permissive policy (combines with OR); if false, creates a restrictive policy (combines with AND) */
+    permissive?: boolean;
+    /** Command the policy applies to (defaults to ALL) */
+    command?: 'ALL' | 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE';
+    /** Roles to apply the policy to */
+    roles?: string[];
+    /** CHECK expression for INSERT/UPDATE */
+    withCheck?: string;
+    /** USING expression for SELECT */
+    using?: string;
+    /** Schema (for PostgreSQL) */
+    schema?: string;
+    /** MSSQL: Predicate function (e.g., 'dbo.fn_SecurityPredicate') */
+    predicateFunction?: string;
+    /** MSSQL: Column to pass to predicate function */
+    column?: string;
+}
+/**
+ * Options for dropping a policy
+ */
+export interface DropPolicyOptions {
+    /** If true, does not throw error if policy does not exist */
+    ifExists?: boolean;
+    /** If true, also drops dependent objects (CASCADE) */
+    cascade?: boolean;
+    /** Schema (for PostgreSQL) */
+    schema?: string;
+}
+export type Dialect = 'mysql' | 'postgres' | 'sqlite' | 'mssql' | 'mariadb' | 'oracle' | 'cockroachdb' | 'redshift' | 'db2' | 'snowflake' | 'clickhouse' | 'duckdb' | 'hana' | 'spanner' | 'turso' | 'tidb' | 'singlestore' | 'yugabytedb' | 'timescaledb' | 'greenplum' | 'vertica' | 'trino' | 'exasol' | 'questdb' | 'cratedb' | 'firebird' | 'databricks';
+/**
+ * Query event data emitted when a query is executed
+ */
+export interface QueryEvent {
+    /** The SQL query that was executed */
+    sql: string;
+    /** Query execution duration in milliseconds */
+    duration: number;
+    /** Timestamp when the query was executed */
+    timestamp: Date;
+    /** Query type (SELECT, INSERT, UPDATE, DELETE, etc.) */
+    type?: string;
+    /** Model name if query was executed via model method */
+    model?: string;
+    /** Whether the query resulted in an error */
+    error?: boolean;
+}
+/**
+ * Slow query event data emitted when a query exceeds the threshold
+ */
+export interface SlowQueryEvent extends QueryEvent {
+    /** The threshold in milliseconds that was exceeded */
+    threshold: number;
+}
+/**
+ * Event listener types for Prorm events
+ */
+export interface PrormEvents {
+    /** Fired before a query is executed */
+    beforeQuery: (event: QueryEvent) => void;
+    /** Fired after a query is executed */
+    query: (event: QueryEvent) => void;
+    /** Fired when a query exceeds the slow query threshold */
+    slowQuery: (event: SlowQueryEvent) => void;
+    /** Fired when a connection is acquired from the pool */
+    acquire: (connection: any) => void;
+    /** Fired when a connection is released back to the pool */
+    release: (connection: any) => void;
+    /** Fired when there's a pool error */
+    pool: (error: Error) => void;
+    /** Fired when there's an error */
+    error: (error: Error) => void;
+}
+export interface PrormOptions {
+    dialect: Dialect;
+    database?: string;
+    username?: string;
+    password?: string;
+    host?: string;
+    port?: number;
+    storage?: string;
+    logging?: boolean | ((sql: string, timing?: number) => void);
+    loggingLevel?: LoggingLevel | 'debug' | 'info' | 'warn' | 'error';
+    logSQL?: boolean;
+    logSlowQueries?: boolean;
+    slowQueryThreshold?: number;
+    colors?: boolean;
+    pool?: PoolOptions;
+    /** Connection pool settings */
+    retry?: RetryOptions;
+    /** Connection timeout in milliseconds */
+    connectTimeout?: number;
+    /** Idle timeout in milliseconds */
+    idleTimeout?: number;
+    timezone?: string;
+    /** Keep the database's default timezone instead of converting to UTC */
+    keepDefaultTimezone?: boolean;
+    /** Additional options to pass to the database driver (e.g., SSL config) */
+    dialectOptions?: Record<string, any>;
+    transactionType?: string;
+    isolationLevel?: string;
+    raw?: boolean;
+    migrationModule?: string | any;
+    migrationStorage?: 'prorm' | 'table' | 'none';
+    migrationStorageTableName?: string;
+    migrationStorageTableSchema?: string;
+    migrationsPath?: string;
+    /** Schema to use for database operations (PostgreSQL) */
+    schema?: string;
+    /** Search path for query resolution (PostgreSQL) */
+    searchPath?: string | string[];
+    /** Additional named connections for cross-database queries */
+    connections?: NamedConnectionOptions[];
+    /** Name of the default connection to use */
+    defaultConnection?: string;
+}
+/**
+ * Named connection options for adding a new database connection
+ */
+export interface NamedConnectionOptions {
+    /** Unique name to identify this connection */
+    name: string;
+    /** Prorm options for the connection */
+    options: Omit<PrormOptions, 'connections' | 'defaultConnection'>;
+}
+/**
+ * Query event data emitted when a query is executed
+ */
+export interface QueryEvent {
+    /** The SQL query that was executed */
+    sql: string;
+    /** Query execution time in milliseconds */
+    duration: number;
+    /** Timestamp when the query was executed */
+    timestamp: Date;
+    /** Query type (SELECT, INSERT, UPDATE, etc.) */
+    type?: string;
+    /** Model name if this was a model query */
+    model?: string;
+    /** Whether the query threw an error */
+    error?: boolean;
+}
+/**
+ * Slow query event data emitted when a query exceeds the threshold
+ */
+export interface SlowQueryEvent extends QueryEvent {
+    /** The threshold that was exceeded (in ms) */
+    threshold: number;
+}
+export interface PoolOptions {
+    /** Maximum number of connections in the pool */
+    max?: number;
+    /** Minimum number of idle connections to maintain */
+    min?: number;
+    /** Maximum time in milliseconds to wait for a connection to become available */
+    acquire?: number;
+    /** Maximum time in milliseconds that a connection can be idle before being evicted */
+    idle?: number;
+    /** Interval in milliseconds to check for idle connections to evict */
+    evict?: number;
+    /** Whether to automatically handle disconnects */
+    handleDisconnects?: boolean;
+    /** Callback when a connection is acquired from the pool */
+    onConnect?: (connection: any) => void;
+    /** Callback when a connection is released back to the pool */
+    onDisconnect?: (connection: any) => void;
+    /** Enable pool event emission (for monitoring/debugging) */
+    enableEvents?: boolean;
+    /** Log pool operations (acquire, release, etc.) */
+    logPoolOperations?: boolean;
+}
+export interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    max?: number;
+    /** Timeout in milliseconds between retries (default: 1000) */
+    timeout?: number;
+    /** Array of error message patterns to retry on (default: common connection errors) */
+    match?: string[];
+    /** Enable exponential backoff for retries (default: false) */
+    backoff?: boolean;
+    /** Multiplier for exponential backoff (default: 2) */
+    backoffMultiplier?: number;
+    /** Maximum backoff time in ms (default: 10000) */
+    backoffMax?: number;
+}
+export interface ModelOptions {
+    tableName?: string;
+    /** Schema to use for this model (PostgreSQL) or database (MySQL) */
+    schema?: string;
+    /** Schema delimiter for table name generation (default: '.') */
+    schemaDelimiter?: string;
+    timestamps?: boolean;
+    createdAt?: string | false;
+    updatedAt?: string | false;
+    deletedAt?: string | false;
+    paranoid?: boolean;
+    preserveDeletedAt?: boolean;
+    underscored?: boolean;
+    freezeTableName?: boolean;
+    hooks?: ModelHooks;
+    scopes?: Record<string, ScopeOptions>;
+    defaultScope?: ScopeOptions;
+    validate?: ModelValidationOptions;
+    /** Primary key field(s) - supports both single field (string) and composite keys (string[]) */
+    primaryKey?: string | string[];
+    indexes?: IndexOptions[];
+    constraints?: ConstraintOptions[];
+    classMethods?: Record<string, Function>;
+    instanceMethods?: Record<string, Function>;
+    hidden?: Record<string, boolean>;
+    virtualFields?: boolean;
+    /** MySQL/MariaDB storage engine (e.g., 'InnoDB', 'MyISAM') */
+    engine?: string;
+    /** Character set for the table (e.g., 'utf8mb4') */
+    charset?: string;
+    /** Collation for the table (e.g., 'utf8mb4_unicode_ci') */
+    collate?: string;
+    /** Comment for the table */
+    comment?: string;
+    /** Initial auto-increment value for the table */
+    initialAutoIncrement?: number;
+    /** Row format for MySQL/MariaDB (e.g., 'DYNAMIC', 'FIXED', 'COMPRESSED') */
+    rowFormat?: string;
+    /** Unique keys to create with the table - supports both simple and composite keys */
+    uniqueKeys?: UniqueKeyOptions[];
+    /** Legacy unique keys format (deprecated - use UniqueKeyOptions instead) */
+    uniqueKeysLegacy?: Record<string, string[]>;
+    /** PostgreSQL tablespace */
+    tablespace?: string;
+    /** PostgreSQL: inherit from parent table */
+    inherit?: string;
+    /** PostgreSQL: partition by clause */
+    partitionBy?: string;
+    /** Validate on create (default: true) */
+    validateOnInsert?: boolean;
+    /** Validate on update (default: true) */
+    validateOnUpdate?: boolean;
+    /** Skip validations (default: false) */
+    skipValidations?: boolean;
+}
+/**
+ * Sort direction for index column ordering.
+ *
+ * Companion enum for the `'ASC' | 'DESC'` string-literal union used by
+ * {@link IndexField.order}. Raw string literals remain valid; the enum is an
+ * additive, opt-in alternative.
+ *
+ * @example
+ * ```typescript
+ * // Using raw string literals (still supported)
+ * indexes: [{ fields: [{ name: 'email', order: 'DESC' }] }]
+ *
+ * // Using the SortDirection enum
+ * import { SortDirection } from 'prorm';
+ * indexes: [{ fields: [{ name: 'email', order: SortDirection.DESC }] }]
+ * ```
+ */
+export declare enum SortDirection {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export interface IndexField {
+    name: string;
+    length?: number;
+    order?: SortDirection | 'ASC' | 'DESC';
+    collate?: string;
+}
+export interface IndexOptions {
+    name?: string;
+    /** Single field name or array of field names for composite indexes */
+    fields?: string[] | IndexField[];
+    unique?: boolean;
+    type?: string;
+    using?: string;
+    where?: WhereOptions;
+    /** PostgreSQL: specify tablespace for the index */
+    tablespace?: string;
+    /** PostgreSQL: index storage parameters */
+    storageParameters?: Record<string, string | number>;
+    /** MySQL/MariaDB: parser for full-text index */
+    parser?: string;
+    /** MySQL/MariaDB: FULLTEXT index */
+    fulltext?: boolean;
+    /** PostgreSQL: text search configuration for GIN index */
+    textSearchConfig?: string;
+    /** PostgreSQL/MySQL: include columns in index (covering index) */
+    include?: string[];
+    /** PostgreSQL/MySQL: index with NULLS NOT DISTINCT */
+    nullsNotDistinct?: boolean;
+    /** Expression-based index (e.g., LOWER(column), (column1 || ' ' || column2)) */
+    expression?: string;
+    /** If true, does not throw error if index already exists */
+    ifNotExists?: boolean;
+}
+/** Expression-based index definition */
+export interface IndexExpression {
+    /** The expression to index (e.g., "LOWER(email)", "(first_name || ' ' || last_name)") */
+    expression: string;
+    /** Optional name for the expression */
+    name?: string;
+}
+export interface ConstraintOptions {
+    /** Custom constraint name (auto-generated if not provided) */
+    name?: string;
+    /** Alias for name - custom constraint name */
+    constraintName?: string;
+    type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
+    /** Single field or array of fields for composite constraints */
+    fields?: string[];
+    /** Composite foreign key fields - used with compositeKey in associations */
+    compositeKey?: string[];
+    references?: {
+        model: string;
+        field: string;
+        /** Composite foreign key fields on the referenced table */
+        compositeKey?: string[];
+        onDelete?: ReferentialAction | 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION' | 'SET DEFAULT';
+        onUpdate?: ReferentialAction | 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+        /** PostgreSQL: match type for foreign key (FULL, PARTIAL, SIMPLE) */
+        match?: 'FULL' | 'PARTIAL' | 'SIMPLE';
+        /** PostgreSQL: deferrable constraint */
+        deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE' | 'NOT DEFERRABLE';
+    };
+    check?: string;
+    /** PostgreSQL: deferrable constraint */
+    deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE' | 'NOT DEFERRABLE';
+    /** Foreign key match type (FULL, PARTIAL) */
+    match?: 'FULL' | 'PARTIAL';
+}
+/**
+ * Unique key definition for model options
+ * Supports both simple unique constraints and composite unique constraints
+ */
+export interface UniqueKeyOptions {
+    /** Name of the unique constraint */
+    name?: string;
+    /** Fields to include in the unique constraint */
+    fields: string[];
+    /** Whether this is a unique index (true) or unique constraint (false/default) */
+    unique?: boolean;
+}
+/**
+ * Extended model options to support composite unique constraints
+ */
+export interface ModelOptionsWithConstraints extends ModelOptions {
+    /** Unique keys to create with the table - supports both simple and composite keys */
+    uniqueKeys?: UniqueKeyOptions[];
+}
+/**
+ * PostgreSQL partition type
+ */
+export type PartitionType = 'range' | 'list' | 'hash';
+/**
+ * Partition bound specification for range partitions
+ */
+export interface PartitionBound {
+    /** Start value (inclusive) */
+    from: string | number | Date;
+    /** End value (exclusive for range) */
+    to?: string | number | Date;
+}
+/**
+ * Partition bound specification for list partitions
+ */
+export interface PartitionListBound {
+    /** Values for list partition */
+    values: (string | number)[];
+}
+/**
+ * Partition bound specification for hash partitions
+ */
+export interface PartitionHashBound {
+    /** Modulus value */
+    modulus: number;
+    /** Remainder value */
+    remainder: number;
+}
+/**
+ * Partition options for model definitions
+ */
+export interface PartitionOptions {
+    /** Partition type: range, list, or hash */
+    type: PartitionType;
+    /** Column(s) to partition by */
+    column: string | string[];
+    /** Partition definitions */
+    partitions?: PartitionDefinition[];
+}
+/**
+ * Individual partition definition
+ */
+export interface PartitionDefinition {
+    /** Name of the partition */
+    name: string;
+    /** Partition bound specification */
+    bound?: PartitionBound | PartitionListBound | PartitionHashBound;
+    /** Tablespace for the partition (PostgreSQL) */
+    tablespace?: string;
+    /** Storage parameters for the partition */
+    storageParameters?: Record<string, string | number>;
+}
+/**
+ * Options for creating a partition
+ */
+export interface CreatePartitionOptions {
+    /** Parent table name */
+    parentTable: string;
+    /** Partition name */
+    name: string;
+    /** Partition bound */
+    bound?: PartitionBound | PartitionListBound | PartitionHashBound;
+    /** Tablespace */
+    tablespace?: string;
+    /** Storage parameters */
+    storageParameters?: Record<string, string | number>;
+    /** Include partition in queries (default: true) */
+    including?: boolean;
+}
+/**
+ * Options for attaching a partition
+ */
+export interface AttachPartitionOptions {
+    /** Parent table name */
+    parentTable: string;
+    /** Partition name */
+    partitionName: string;
+}
+/**
+ * Options for detaching a partition
+ */
+export interface DetachPartitionOptions {
+    /** Partition name */
+    partitionName: string;
+    /** Whether to use NOT VALIDATE option */
+    validate?: boolean;
+}
+/**
+ * Custom validator function type
+ * Returns true if valid, or throws an error if invalid
+ */
+export type CustomValidator = (value: any, options?: {
+    instance?: Model;
+    model?: ModelStatic<any>;
+    field?: string;
+}) => boolean | void | Promise<boolean | void>;
+/**
+ * When to run validation: on create, update, or both
+ */
+export type ValidateOnOption = 'create' | 'update' | 'save' | 'saveOnly';
+/**
+ * Companion enum for `ValidateOnOption`. Mirrors the same fixed set of
+ * string values so callers who prefer enums (autocomplete, refactor-safe
+ * references, etc.) can use `ValidateOn.Create` instead of the raw string
+ * literal `'create'`. Both forms are accepted anywhere `ValidateOnOption`
+ * is used - this is purely additive and does not replace the string
+ * literal union.
+ */
+export declare enum ValidateOn {
+    Create = "create",
+    Update = "update",
+    Save = "save",
+    SaveOnly = "saveOnly"
+}
+/**
+ * Per-field validation options
+ */
+export interface FieldValidationOptions {
+    /** Custom error message */
+    msg?: string;
+    /** When to run this validation. Accepts either the `ValidateOnOption`
+     * string literals or the equivalent `ValidateOn` enum members. */
+    on?: ValidateOnOption | ValidateOn | (ValidateOnOption | ValidateOn)[];
+    /** Custom validator function */
+    customValidator?: CustomValidator;
+}
+/**
+ * Extended validation options for attributes and model
+ */
+export interface ExtendedValidationOptions {
+    /** Custom validators by name */
+    [customValidator: string]: ValidationMethod | ValidationChain | CustomValidator | FieldValidationOptions;
+}
+/**
+ * Validation result interface
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationErrorItem[];
+}
+/**
+ * Options for Model.validate() static method
+ */
+export interface ModelValidateOptions {
+    /** Fields to validate (validates all if not provided) */
+    fields?: string[];
+    /** Whether to run hooks (default: true) */
+    hooks?: boolean;
+    /** Only validate specific fields */
+    validateSchema?: boolean;
+}
+/**
+ * Options for instance validate() method
+ */
+export interface InstanceValidateOptions {
+    /** Fields to validate (validates all if not provided) */
+    fields?: string[];
+    /** Whether to run hooks (default: true) */
+    hooks?: boolean;
+    /** Validate on create only (for instance validation) */
+    validateOnCreate?: boolean;
+    /** Validate on update only (for instance validation) */
+    validateOnUpdate?: boolean;
+}
+export interface ScopeOptions {
+    attributes?: FindOptions['attributes'];
+    where?: WhereOptions;
+    include?: Includeable[] | IncludeOptions[];
+    order?: Order;
+    limit?: number;
+    offset?: number;
+    transaction?: Transaction;
+}
+export interface ModelValidationOptions {
+    [key: string]: ValidationMethod | ValidationChain;
+}
+export type ValidationMethod = (value: any) => boolean | string | Error;
+export interface ValidationChain {
+    is: [RegExp | string, string?];
+    not: [RegExp | string, string?];
+    isEmail: boolean | string;
+    isUrl: boolean | string;
+    isIP: boolean | string;
+    isAlpha: boolean | string;
+    isAlphanumeric: boolean | string;
+    isNumeric: boolean | string;
+    isInt: boolean | string;
+    isFloat: boolean | string;
+    isDecimal: boolean | string;
+    isLowercase: boolean | string;
+    isUppercase: boolean | string;
+    isNull: boolean | string;
+    notEmpty: boolean | string;
+    equals: string;
+    contains: string;
+    notContains: string;
+    len: [number, number?] | number;
+    isUUID: boolean | string;
+    isDate: boolean | string;
+    isAfter: string;
+    isBefore: string;
+    isIn: any[][];
+    notIn: any[][];
+    max: number;
+    min: number;
+}
+export type DataType = DataTypeString | DataTypeChar | DataTypeText | DataTypeNumber | DataTypeInteger | DataTypeBigInt | DataTypeFloat | DataTypeDouble | DataTypeDecimal | DataTypeBoolean | DataTypeDate | DataTypeDateOnly | DataTypeTime | DataTypeBlob | DataTypeEnum | DataTypeJSON | DataTypeJSONB | DataTypeUUID | DataTypeGeometry | DataTypeSET | DataTypeHStore | DataTypeRange | DataTypeInet | DataTypeCidr | DataTypeMacAddr | string;
+export interface DataTypeAbstract {
+    key: string;
+    toSql?: () => string;
+}
+export interface DataTypeString extends DataTypeAbstract {
+    key: 'STRING';
+    length: number;
+}
+export interface DataTypeChar extends DataTypeAbstract {
+    key: 'CHAR';
+    length: number;
+}
+export interface DataTypeText extends DataTypeAbstract {
+    key: 'TEXT';
+    length?: number;
+}
+export interface DataTypeNumber extends DataTypeAbstract {
+    key: 'NUMBER';
+    precision: number;
+    scale: number;
+}
+export interface DataTypeInteger extends DataTypeAbstract {
+    key: 'INTEGER';
+    length?: number;
+    unsigned?: boolean;
+    zerofill?: boolean;
+}
+export interface DataTypeBigInt extends DataTypeAbstract {
+    key: 'BIGINT';
+    length?: number;
+    unsigned?: boolean;
+}
+export interface DataTypeFloat extends DataTypeAbstract {
+    key: 'FLOAT';
+    length?: number;
+    decimals?: number;
+    unsigned?: boolean;
+}
+export interface DataTypeDouble extends DataTypeAbstract {
+    key: 'DOUBLE';
+    length?: number;
+    decimals?: number;
+    unsigned?: boolean;
+}
+export interface DataTypeDecimal extends DataTypeAbstract {
+    key: 'DECIMAL';
+    precision: number;
+    scale: number;
+    unsigned?: boolean;
+}
+export interface DataTypeBoolean extends DataTypeAbstract {
+    key: 'BOOLEAN';
+}
+export interface DataTypeDate extends DataTypeAbstract {
+    key: 'DATE';
+    precision?: number;
+    timezone?: boolean;
+}
+export interface DataTypeDateOnly extends DataTypeAbstract {
+    key: 'DATEONLY';
+}
+export interface DataTypeTime extends DataTypeAbstract {
+    key: 'TIME';
+    precision?: number;
+}
+export interface DataTypeBlob extends DataTypeAbstract {
+    key: 'BLOB';
+    length?: 'tiny' | 'medium' | 'long';
+}
+export interface DataTypeEnum extends DataTypeAbstract {
+    key: 'ENUM';
+    values: string[];
+}
+export interface DataTypeJSON extends DataTypeAbstract {
+    key: 'JSON';
+}
+export interface DataTypeJSONB extends DataTypeAbstract {
+    key: 'JSONB';
+}
+export interface DataTypeUUID extends DataTypeAbstract {
+    key: 'UUID';
+}
+export interface DataTypeGeometry extends DataTypeAbstract {
+    key: 'GEOMETRY';
+    type: string;
+    srid?: number;
+}
+/**
+ * MySQL-specific spatial types
+ */
+export type SpatialType = 'POINT' | 'LINESTRING' | 'POLYGON' | 'MULTIPOINT' | 'MULTILINESTRING' | 'MULTIPOLYGON' | 'GEOMETRYCOLLECTION' | 'GEOMETRY';
+/**
+ * Options for JSON column in MySQL
+ */
+export interface JSONColumnOptions {
+    /** Whether to validate JSON format on insert/update */
+    validate?: boolean;
+    /** Whether to use JSON unescaped Unicode mode */
+    unescapedUnicode?: boolean;
+    /** Whether to use compact JSON output */
+    compact?: boolean;
+}
+/**
+ * MySQL SET column options
+ */
+export interface SetColumnOptions {
+    /** Array of allowed values for the SET column */
+    values: string[];
+    /** Optional name for the SET type (useful for custom types) */
+    name?: string;
+}
+export interface DataTypeVirtual extends DataTypeAbstract {
+    key: 'VIRTUAL';
+    returnType?: DataType;
+}
+/**
+ * MySQL SET column data type
+ */
+export interface DataTypeSET extends DataTypeAbstract {
+    key: 'SET';
+    values: string[];
+}
+/**
+ * Options for JSON column in MySQL
+ */
+export interface JSONColumnOptions {
+    /** Whether to validate JSON format on insert/update */
+    validate?: boolean;
+    /** Whether to use JSON unescaped Unicode mode */
+    unescapedUnicode?: boolean;
+    /** Whether to use compact JSON output */
+    compact?: boolean;
+}
+/**
+ * MySQL SET column options
+ */
+export interface SetColumnOptions {
+    /** Array of allowed values for the SET column */
+    values: string[];
+    /** Optional name for the SET type (useful for custom types) */
+    name?: string;
+}
+/**
+ * PostgreSQL HStore key-value type
+ * Requires extension: CREATE EXTENSION IF NOT EXISTS hstore
+ */
+export interface DataTypeHStore extends DataTypeAbstract {
+    key: 'HSTORE';
+}
+/**
+ * PostgreSQL Range Types
+ * - int4range: Range of integer
+ * - int8range: Range of bigint
+ * - numrange: Range of numeric
+ * - tsrange: Range of timestamp without time zone
+ * - tstzrange: Range of timestamp with time zone
+ * - daterange: Range of date
+ */
+export type RangeSubtype = 'int4range' | 'int8range' | 'numrange' | 'tsrange' | 'tstzrange' | 'daterange';
+export interface DataTypeRange extends DataTypeAbstract {
+    key: 'RANGE';
+    subtype: RangeSubtype;
+}
+/**
+ * PostgreSQL INET type for IP addresses
+ */
+export interface DataTypeInet extends DataTypeAbstract {
+    key: 'INET';
+}
+/**
+ * PostgreSQL CIDR type for network addresses
+ */
+export interface DataTypeCidr extends DataTypeAbstract {
+    key: 'CIDR';
+}
+/**
+ * PostgreSQL MACADDR type for MAC addresses
+ */
+export interface DataTypeMacAddr extends DataTypeAbstract {
+    key: 'MACADDR';
+}
+/**
+ * Options for UUID type
+ */
+export interface UUIDOptions {
+    /** Use gen_random_uuid() for default value (PostgreSQL 13+) */
+    defaultValue?: 'gen_random_uuid' | 'uuid_generate_v4' | string;
+}
+/**
+ * Options for JSONB type
+ */
+export interface JSONBOptions {
+    /** Whether to validate JSON structure */
+    validate?: boolean;
+}
+/**
+ * Options for HStore type
+ */
+export interface HStoreOptions {
+    /** Whether to use native HStore or JSONB fallback */
+    useNative?: boolean;
+}
+/**
+ * Options for Range type
+ */
+export interface RangeOptions {
+    /** The range subtype */
+    subtype: RangeSubtype;
+}
+/**
+ * Options for INET/CIDR types
+ */
+export interface InetOptions {
+    /** For CIDR: whether to include address family */
+    includeFamily?: boolean;
+}
+/**
+ * Table inheritance options for PostgreSQL
+ */
+export interface InheritOptions {
+    /** Parent table(s) to inherit from */
+    parentTable: string | string[];
+    /** Only include rows from child table in queries */
+    only?: boolean;
+    /** Include rows from parent table in queries (default) */
+    inherit?: boolean;
+}
+/**
+ * Array column options for PostgreSQL array types
+ */
+export interface ArrayOptions {
+    /** The data type of array elements */
+    type: DataType;
+    /** Whether the array can be null */
+    allowNull?: boolean;
+    /** Default value for the array column */
+    defaultValue?: any;
+    /** Comment for the column */
+    comment?: string;
+    /** Custom column name in the database */
+    field?: string;
+}
+/**
+ * Array operator options for querying array columns
+ */
+export interface ArrayOperatorOptions {
+    /** Array contains operator (@>) */
+    $arrayContains?: any[];
+    /** Array contained by operator (<@) */
+    $arrayContainedBy?: any[];
+    /** Array overlaps operator (&&) */
+    $arrayOverlaps?: any[];
+    /** Array ANY operator */
+    $arrayAny?: any;
+    /** Array ALL operator */
+    $arrayAll?: any;
+}
+export interface AttributeOptions {
+    type: DataType;
+    allowNull?: boolean;
+    defaultValue?: any;
+    primaryKey?: boolean;
+    /**
+     * Unique constraint on this field
+     * - true: auto-generate constraint name
+     * - string: use as constraint name
+     * - { name: string, msg?: string }: custom name with optional error message
+     */
+    unique?: boolean | string | {
+        name: string;
+        msg?: string;
+    };
+    /**
+     * Unique key name for this attribute - used to group with other fields for composite unique constraints.
+     * When multiple fields share the same uniqueKey, they form a composite unique constraint.
+     * Example: { uniqueKey: 'uq_org_email' } on orgId and email fields creates a composite unique constraint.
+     */
+    uniqueKey?: string;
+    references?: ReferenceOptions;
+    autoIncrement?: boolean;
+    comment?: string;
+    validate?: ModelValidationOptions;
+    field?: string;
+    get?: () => any;
+    set?: (value: any) => void;
+    hidden?: boolean;
+    virtual?: boolean;
+}
+export interface ReferenceOptions {
+    model: string | ModelStatic<any>;
+    key?: string;
+    deferrable?: string;
+    onDelete?: ReferentialAction | 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION' | 'SET DEFAULT';
+    onUpdate?: ReferentialAction | 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION' | 'SET DEFAULT';
+}
+export interface ModelHooks {
+    beforeValidate?: HookHandler;
+    afterValidate?: HookHandler;
+    beforeCreate?: HookHandler;
+    afterCreate?: HookHandler;
+    beforeUpdate?: HookHandler;
+    afterUpdate?: HookHandler;
+    beforeDestroy?: HookHandler;
+    afterDestroy?: HookHandler;
+    beforeSave?: HookHandler;
+    afterSave?: HookHandler;
+    beforeBulkCreate?: BulkHookHandler;
+    afterBulkCreate?: BulkHookHandler;
+    beforeBulkUpdate?: BulkHookHandler;
+    afterBulkUpdate?: BulkHookHandler;
+    beforeBulkDestroy?: BulkHookHandler;
+    afterBulkDestroy?: BulkHookHandler;
+    beforeFind?: FindHookHandler;
+    afterFind?: AfterFindHookHandler;
+}
+export type FindHookHandler = (options: FindOptions, model: ModelStatic<any>) => Promise<void> | void;
+export type AfterFindHookHandler = (instances: Model[], options: FindOptions, model: ModelStatic<any>) => Promise<void> | void;
+export type HookHandler = (instance: Model, options?: HookOptions) => Promise<void> | void;
+export type BulkHookHandler = (instances?: Model[], options?: HookOptions) => Promise<void> | void;
+export interface HookOptions {
+    transaction?: Transaction;
+    hooks?: boolean;
+    validate?: boolean;
+    fields?: string[];
+    skip?: string[];
+    individualHooks?: boolean;
+    bench?: boolean;
+    model?: any;
+    instances?: Model[];
+}
+export type WhereOptions<T = any> = {
+    [key: string]: any;
+} | WhereLogical<T>;
+export interface WhereLogical<T> {
+    $and?: WhereOptions<T>[];
+    $or?: WhereOptions<T>[];
+    $not?: WhereOptions<T>;
+}
+/**
+ * Full-text search options for MATCH AGAINST (MySQL) and tsvector (PostgreSQL)
+ */
+export interface FullTextSearchOptions {
+    /** Search mode: 'natural' for natural language mode, 'boolean' for boolean mode */
+    mode?: 'natural' | 'boolean';
+    /** Columns to search (for MATCH AGAINST) */
+    fields?: string[];
+}
+/**
+ * PostgreSQL tsvector options
+ */
+export interface TsVectorOptions {
+    /** Text search configuration (e.g., 'english', 'simple') */
+    config?: string;
+    /** Pre-computed tsvector column name */
+    column?: string;
+}
+/**
+ * UNION type for combining query results
+ */
+export type UnionType = 'UNION' | 'UNION ALL' | 'EXCEPT' | 'INTERSECT';
+/**
+ * Options for a single union query
+ */
+export interface UnionQueryOptions {
+    /** The model to query */
+    model: ModelStatic<any>;
+    /** WHERE conditions for this union query */
+    where?: WhereOptions;
+    /** Attributes to select */
+    attributes?: string[] | {
+        include?: string[];
+        exclude?: string[];
+    };
+    /** ORDER BY for this union query */
+    order?: Order;
+    /** LIMIT for this union query */
+    limit?: number | string;
+    /** OFFSET for this union query */
+    offset?: number | string;
+    /** Include related models */
+    include?: Includeable[] | IncludeOptions[];
+    /** Alias for this query (useful for debugging) */
+    as?: string;
+}
+/**
+ * Subquery wrapper for use in WHERE clauses
+ */
+export interface SubqueryOptions {
+    /** The SQL query string (raw or with model reference) */
+    sql: string;
+    /** Whether this is a literal SQL string vs a model-based subquery */
+    literal?: boolean;
+    /** Model to use for building the subquery */
+    model?: ModelStatic<any>;
+    /** Options for building the subquery (if model is provided) */
+    modelOptions?: FindOptions;
+}
+/**
+ * HAVING clause options - supports aggregations and alias references
+ * Similar to WhereOptions but can reference aggregate function aliases
+ */
+export type HavingOptions<T = any> = {
+    [key: string]: any;
+} | HavingLogical<T>;
+export interface HavingLogical<T> {
+    $and?: HavingOptions<T>[];
+    $or?: HavingOptions<T>[];
+    $not?: HavingOptions<T>;
+}
+/**
+ * Attribute selection format
+ * Supports:
+ * - Simple strings: 'columnName'
+ * - Arrays of strings: ['col1', 'col2']
+ * - Function expressions with alias: [[fn('COUNT', col('id')), 'count']]
+ * - Literal SQL with alias: [['COUNT(*)', 'count']]
+ */
+export type AttributeValue = string | [any, string] | [any, any, string];
+export type AttributesOptions = string[] | {
+    include?: string[];
+    exclude?: string[];
+} | AttributeValue[];
+/**
+ * Common Table Expression (CTE) options
+ * Used for WITH RECURSIVE and regular WITH clauses
+ */
+export interface CTEOptions {
+    /** Name of the CTE */
+    name: string;
+    /** Column names for the CTE (optional) */
+    columns?: string[];
+    /**
+     * The CTE body. Prefer a structured query object (same shape as
+     * `SelectOptions` in `src/dialects/dialect.ts`: `tableName`, `where`,
+     * `attributes`, `order`, etc.) over a raw SQL string wherever possible -
+     * a plain string is only meant as an escape hatch for CTE bodies that
+     * can't be expressed structurally (e.g. hand-written recursive UNION ALL
+     * logic referencing the CTE's own name).
+     */
+    query: string | Record<string, unknown>;
+    /** Whether this is a recursive CTE */
+    recursive?: boolean;
+}
+/**
+ * Aggregate function types for pivot operations
+ */
+export type AggregateFunction = 'SUM' | 'COUNT' | 'AVG' | 'MAX' | 'MIN';
+/**
+ * Pivot options for transforming rows to columns
+ */
+export interface PivotOptions {
+    /** The column to pivot on (values become new column names) */
+    on: string;
+    /** Map of column names to aggregate functions */
+    using: Record<string, AggregateFunction>;
+    /** Aggregate function to use (overrides using if provided) */
+    aggregate?: AggregateFunction;
+}
+/**
+ * Unpivot options for transforming columns to rows
+ */
+export interface UnpivotOptions {
+    /** Columns to unpivot (transform to rows) */
+    in: string[];
+    /** Name for the value column in the result */
+    valueColumn: string;
+    /** Name for the column name column in the result */
+    nameColumn: string;
+}
+export interface FindOptions {
+    where?: WhereOptions;
+    attributes?: AttributesOptions;
+    /** Schema to use for the main table */
+    schema?: string;
+    /**
+     * Overrides the FROM target of the query, in place of the model's own
+     * table name. Primarily useful together with `cte` to select from a CTE
+     * result set instead of the model's base table
+     * @example
+     * // Select from the `org_chart` CTE instead of `employees`
+     * Employee.findAll({ cte: [...], tableName: 'org_chart' })
+     */
+    tableName?: string;
+    /** Search path for query resolution (PostgreSQL) */
+    searchPath?: string | string[];
+    /**
+     * Connection name to use for this query
+     * Allows querying a different database connection
+     * @example
+     * // Use analytics connection
+     * User.findAll({
+     *   using: 'analytics'
+     * });
+     */
+    using?: string;
+    include?: Includeable[] | IncludeOptions[];
+    order?: Order;
+    /** Number of records to return */
+    limit?: number;
+    /** Number of records to skip */
+    offset?: number;
+    /**
+     * GROUP BY clause - can be a string, array of strings, array of arrays with function expressions, or array of model objects
+     * @example
+     * group: 'status'
+     * group: ['status']
+     * group: ['userId', 'category']
+     * group: [['status', 'role']] // Array format for mixed columns and expressions
+     * group: [[prorm.fn('COUNT', 'id'), 'count']] // Function expressions with alias
+     * group: [{ model: User, as: 'author' }]
+     */
+    group?: string | string[] | [any, string][] | {
+        model: ModelStatic<any>;
+        as?: string;
+    }[];
+    /**
+     * Type of grouping for advanced aggregation features
+     * - 'rollup': Generates ROLLUP(column, ...) for hierarchical aggregations
+     * - 'cube': Generates CUBE(column, ...) for multi-dimensional aggregations
+     * - 'grouping': Uses GROUPING SETS for custom grouping combinations
+     * - 'none': No special grouping type (default)
+     * @example
+     * groupType: 'rollup'
+     * groupType: 'cube'
+     * groupType: 'grouping'
+     */
+    groupType?: 'rollup' | 'cube' | 'grouping' | 'none';
+    /**
+     * GROUPING SETS - custom grouping combinations for advanced aggregation
+     * Each element is an array representing one grouping set
+     * @example
+     * groupingSets: [['status'], ['region'], []] // Group by status, region, and grand total
+     * groupingSets: [['a', 'b'], ['a'], []] // Group by (a,b), (a), and grand total
+     */
+    groupingSets?: string[][];
+    /**
+     * HAVING clause - filter aggregated results
+     * Supports all WHERE operators plus aggregation-specific conditions
+     * @example
+     * having: { count: { [Op.gt]: 5 } }
+     * having: { count: { [Op.between]: [1, 10] } }
+     * having: { $or: [{ count: { [Op.lt]: 2 } }, { totalViews: { [Op.gt]: 1000 } }] }
+     */
+    having?: HavingOptions;
+    raw?: boolean;
+    transaction?: Transaction;
+    /**
+     * Row-level locking options
+     * - true: FOR UPDATE (equivalent to 'UPDATE')
+     * - 'UPDATE': FOR UPDATE - prevents other transactions from modifying the rows
+     * - 'SHARE': FOR SHARE (PostgreSQL) / LOCK IN SHARE MODE (MySQL)
+     * - 'KEY SHARE': FOR KEY SHARE (PostgreSQL only)
+     * - { of: Model }: Lock only the specified table (PostgreSQL)
+     *
+     * @example
+     * // Lock all rows with FOR UPDATE
+     * User.findAll({ lock: 'UPDATE' })
+     *
+     * // Lock with transaction-level FOR UPDATE
+     * User.findAll({ lock: true, transaction: t })
+     *
+     * // Lock only the User table (PostgreSQL)
+     * User.findAll({ lock: { of: User } })
+     */
+    lock?: LockOptions;
+    benchmark?: boolean;
+    logging?: boolean | ((sql: string, time?: number) => void);
+    benchmarkMark?: string;
+    /**
+     * When true, includes soft-deleted records in query results.
+     * When false or undefined, excludes soft-deleted records (default behavior for paranoid models).
+     * @default false
+     */
+    paranoid?: boolean;
+    /**
+     * UNION type for combining multiple queries
+     * @default 'UNION'
+     */
+    unionType?: UnionType;
+    /**
+     * Array of union queries to combine with the main query
+     */
+    union?: UnionQueryOptions[];
+    /**
+     * Subquery support - allows using literal SQL in where clauses
+     * Usage: { id: { [Op.in]: prorm.literal('(SELECT id FROM users)') } }
+     */
+    subQuery?: boolean;
+    /**
+     * Whether to use subquery for includes.
+     * When false, uses JOIN instead of IN (SELECT) for includes.
+     * When true (default), uses subquery IN pattern for includes.
+     * @default true
+     * @example
+     * // Use JOIN instead of IN (SELECT)
+     * const users = await User.findAll({
+     *   include: [{ model: Post, where: { status: 'published' } }],
+     *   subquery: false
+     * });
+     * @example
+     * // Use subquery IN pattern (default)
+     * const users = await User.findAll({
+     *   include: [{ model: Post, where: { status: 'published' } }],
+     *   subquery: true
+     * });
+     */
+    subquery?: boolean;
+    /**
+     * When true, applies DISTINCT to the query to remove duplicate rows.
+     * Useful when using aggregate functions with includes that may cause duplicates.
+     * @default undefined
+     * @example
+     * // Count distinct users with posts
+     * const count = await User.count({ distinct: true, include: Post })
+     */
+    distinct?: boolean;
+    /**
+     * Common Table Expressions (CTEs) to use in the query
+     * Supports both regular WITH and WITH RECURSIVE
+     * @example
+     * // Simple CTE
+     * cte: [{ name: 'active_users', query: 'SELECT * FROM users WHERE active = true' }]
+     * @example
+     * // Recursive CTE for hierarchy
+     * cte: [{
+     *   name: 'org_chart',
+     *   columns: ['id', 'name', 'manager_id'],
+     *   query: `SELECT id, name, manager_id FROM employees WHERE manager_id IS NULL
+     *           UNION ALL
+     *           SELECT e.id, e.name, e.manager_id FROM employees e
+     *           INNER JOIN org_chart o ON e.manager_id = o.id`,
+     *   recursive: true
+     * }]
+     */
+    cte?: CTEOptions[];
+    /**
+     * Enable streaming results for large datasets
+     * When true, returns a ReadableStream instead of waiting for all results
+     * @default false
+     */
+    stream?: boolean;
+    /**
+     * Batch size for streaming results
+     * @default 1000
+     */
+    streamBatchSize?: number;
+    /**
+     * Transform function to apply to each record during streaming
+     */
+    transform?: (record: any) => any;
+    /**
+     * High watermark for the stream (internal buffer size)
+     * @default 1000
+     */
+    streamHighWatermark?: number;
+}
+export interface FindOrCreateOptions<T = any> extends FindOptions {
+    /** Default values to use when creating a new record if not found */
+    defaults?: Partial<T>;
+    /** Whether to run beforeCreate/afterCreate hooks (default: true) */
+    hooks?: boolean;
+    /** Whether to validate the model before creation (default: true) */
+    validate?: boolean;
+}
+export type Order = OrderItem[] | string | [string, string][] | import('../operators').OrderExpression[];
+/**
+ * Options for JSON path extraction
+ */
+export interface JsonPathOptions {
+    /** The JSON path to extract (e.g., '$.settings.theme' or 'settings.theme') */
+    path: string;
+    /** Optional value to compare against the extracted path */
+    value?: any;
+}
+/**
+ * Options for JSON contains operation
+ */
+export interface JsonContainsOptions {
+    /** The value or object that should be contained in the JSON column */
+    value: any;
+    /** Optional JSON path to check for containment at a specific location */
+    path?: string;
+}
+/**
+ * Options for JSON has key operation
+ */
+export interface JsonHasKeyOptions {
+    /** The key to check for existence */
+    key: string;
+    /** Whether to check for all keys (true) or any key (false) */
+    checkAll?: boolean;
+}
+/**
+ * Legacy OrderItem interface (kept for backward compatibility)
+ */
+export interface OrderItem {
+    0: ModelStatic<any> | string;
+    1?: string;
+}
+/**
+ * Geometry type for spatial data
+ */
+export type GeometryType = 'POINT' | 'LINESTRING' | 'POLYGON' | 'MULTIPOINT' | 'MULTILINESTRING' | 'MULTIPOLYGON' | 'GEOMETRYCOLLECTION' | 'GEOMETRY';
+/**
+ * Options for GeoJSON input/output
+ */
+export interface GeoJSONOptions {
+    /** Output as GeoJSON */
+    asGeoJSON?: boolean;
+    /** Input is GeoJSON */
+    fromGeoJSON?: boolean;
+    /** SRID for the geometry (default: 4326 for WGS84) */
+    srid?: number;
+    /** Geometry type if creating */
+    type?: GeometryType;
+}
+/**
+ * Options for distance calculations
+ */
+export interface DistanceOptions {
+    /** The point/geometry to measure distance from */
+    from: string | {
+        type: GeometryType;
+        coordinates: number[];
+    };
+    /** The maximum distance (in meters for geography, units depend on CRS for geometry) */
+    distance: number;
+    /** Use spheroidal calculation (PostgreSQL geography, default: true) */
+    spheroid?: boolean;
+    /** SRID for the calculation (default: 4326) */
+    srid?: number;
+}
+/**
+ * Options for within/contains queries
+ */
+export interface WithinOptions {
+    /** The geometry to check against */
+    geometry: string | {
+        type: GeometryType;
+        coordinates: number[];
+    };
+    /** SRID for the geometry (default: 4326) */
+    srid?: number;
+}
+/**
+ * Options for intersects/crosses/overlaps queries
+ */
+export interface IntersectsOptions {
+    /** The geometry to check against */
+    geometry: string | {
+        type: GeometryType;
+        coordinates: number[];
+    };
+    /** SRID for the geometry (default: 4326) */
+    srid?: number;
+}
+/**
+ * Options for DWithin (distance within) queries
+ */
+export interface DWithinOptions {
+    /** The point/geometry to measure distance from */
+    from: string | {
+        type: GeometryType;
+        coordinates: number[];
+    };
+    /** The maximum distance */
+    distance: number;
+    /** Use spheroidal calculation (PostgreSQL geography, default: true) */
+    spheroid?: boolean;
+    /** SRID (default: 4326) */
+    srid?: number;
+}
+/**
+ * GROUP BY clause format
+ */
+export type GroupBy = string | string[] | GroupByItem[];
+export interface GroupByItem {
+    model?: ModelStatic<any>;
+    as?: string;
+}
+/**
+ * Lock types for row-level locking
+ * - 'UPDATE': FOR UPDATE (PostgreSQL/MySQL) - prevents other transactions from modifying the rows
+ * - 'SHARE': FOR SHARE (PostgreSQL) / LOCK IN SHARE MODE (MySQL) - allows other transactions to read but not modify
+ * - 'KEY SHARE': FOR KEY SHARE (PostgreSQL only) - prevents key updates but allows row updates
+ */
+export declare enum LockLevel {
+    Share = "SHARE",
+    Update = "UPDATE",
+    KeyShare = "KEY SHARE"
+}
+/**
+ * Lock types for row-level locking
+ *
+ * Accepts either the raw string literals or the equivalent {@link LockLevel} enum member.
+ */
+export type LockType = 'SHARE' | 'UPDATE' | 'KEY SHARE' | LockLevel;
+/**
+ * Lock options for row-level locking
+ * @example
+ * // Lock all rows with FOR UPDATE
+ * User.findAll({ lock: 'UPDATE' })
+ *
+ * // Lock with transaction-level FOR UPDATE
+ * User.findAll({ lock: true, transaction: t })
+ *
+ * // Lock only the User table (PostgreSQL)
+ * User.findAll({ lock: { of: User } })
+ *
+ * // NOWAIT - return error if lock not available (PostgreSQL/MySQL 8.0+)
+ * User.findAll({ lock: { level: 'UPDATE', nowait: true } })
+ *
+ * // SKIP LOCKED - skip locked rows (PostgreSQL/MySQL 8.0+)
+ * User.findAll({ lock: { level: 'UPDATE', skipLocked: true } })
+ */
+export type LockOptions = LockType | boolean | {
+    of: ModelStatic<any>;
+} | {
+    level?: LockType;
+    nowait?: boolean;
+    skipLocked?: boolean;
+    of?: ModelStatic<any>;
+};
+/**
+ * Options for NOWAIT locking (PostgreSQL/MySQL 8.0+)
+ * Causes the database to return an error instead of waiting for a lock
+ */
+export interface NowaitOptions {
+    nowait: true;
+}
+/**
+ * Options for SKIP LOCKED locking (PostgreSQL/MySQL 8.0+)
+ * Causes the database to skip rows that are locked instead of waiting
+ */
+export interface SkipLockedOptions {
+    skipLocked: true;
+}
+export interface Includeable {
+    /** The model to include */
+    model: ModelStatic<any>;
+    /**
+     * Alias for the included model.
+     * Used as:
+     * - The key in result objects (e.g., user.myPosts instead of user.Posts)
+     * - The base name for association methods (e.g., user.getMyPosts(), user.setMyPosts())
+     * - The table alias in SQL JOINs
+     *
+     * @example
+     * // With 'as' alias
+     * User.findAll({
+     *   include: [{ model: Post, as: 'myPosts' }]
+     * })
+     * // Result: { id: 1, name: 'John', myPosts: [...] }
+     *
+     * // Without 'as' - defaults to model name
+     * User.findAll({
+     *   include: [{ model: Post }]
+     * })
+     * // Result: { id: 1, name: 'John', Posts: [...] }
+     */
+    as?: string;
+}
+export interface IncludeOptions extends Includeable {
+    where?: WhereOptions;
+    attributes?: string[] | {
+        include?: string[];
+        exclude?: string[];
+    };
+    /** Schema to use for the included model */
+    schema?: string;
+    required?: boolean;
+    /**
+     * For many-to-many (belongsToMany) relationships, specify the junction table model.
+     * This is required when including models through a join table.
+     */
+    through?: {
+        /** The junction/through model */
+        model?: ModelStatic<any>;
+        /** Alias for the through model in SQL */
+        as?: string;
+        /** Attributes to include from the through model */
+        attributes?: string[] | {
+            include?: string[];
+            exclude?: string[];
+        };
+        /** Where conditions on the through model */
+        where?: WhereOptions;
+        /** Whether to require the join (INNER JOIN vs LEFT JOIN) */
+        required?: boolean;
+    };
+    on?: WhereOptions;
+    order?: Order;
+    limit?: number;
+    offset?: number;
+    paranoid?: boolean;
+    /** When true, includes nested associations recursively */
+    nested?: boolean;
+    /** Include all associations, or a string to filter by association name */
+    all?: boolean | string;
+    /** Ignore attributes from included models (default: true) */
+    includeIgnoreAttributes?: boolean;
+    /**
+     * Custom foreign key for the join.
+     * Can be a single string for simple foreign keys, or an array for composite foreign keys.
+     * @example
+     * foreignKey: 'userId'  // Simple FK
+     * foreignKey: ['orderId', 'customerId']  // Composite FK
+     */
+    foreignKey?: string | string[] | {
+        name?: string | string[];
+        allowNull?: boolean;
+    };
+    /** Nested includes */
+    include?: Includeable[] | IncludeOptions[];
+    /** Whether to duplicate parent rows for each child (for hasMany) */
+    duplicating?: boolean;
+    /** Allow duplicate column names in the result. When true, uses table aliases to distinguish columns */
+    duplicate?: boolean;
+    /**
+     * Target key for the association (defaults to primary key).
+     * Can be a single string for simple keys, or an array for composite keys.
+     * @example
+     * targetKey: 'id'  // Simple key
+     * targetKey: ['id', 'customerId']  // Composite key
+     */
+    targetKey?: string | string[];
+    /**
+     * Type of JOIN to use.
+     * - 'INNER': INNER JOIN
+     * - 'LEFT': LEFT JOIN (outer)
+     * - 'RIGHT': RIGHT JOIN (outer)
+     * - 'FULL': FULL OUTER JOIN
+     * - 'CROSS': CROSS JOIN
+     * @example
+     * joinType: 'FULL'  // Full outer join
+     */
+    joinType?: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS';
+    /**
+     * Whether to use LATERAL JOIN (PostgreSQL only).
+     * LATERAL allows subqueries to reference columns from preceding tables.
+     * @example
+     * lateral: true  // LATERAL JOIN
+     */
+    lateral?: boolean;
+    /**
+     * Whether to use anti-join pattern (NOT EXISTS or LEFT JOIN WHERE NULL).
+     * This finds records that do not have related records in the included model.
+     * @example
+     * // Find users with no orders
+     * User.findAll({
+     *   include: [{ model: Order, antiJoin: true }]
+     * })
+     * // SQL: SELECT users.* FROM users LEFT JOIN orders ON users.id = orders.user_id WHERE orders.id IS NULL
+     */
+    antiJoin?: boolean;
+    /**
+     * Alias for antiJoin - when true, uses anti-join pattern.
+     * @example
+     * // Find users that are NOT in the banned_users table
+     * User.findAll({
+     *   include: [{ model: BannedUser, exclude: true }]
+     * })
+     */
+    exclude?: boolean;
+    /**
+     * Type of anti-join to use.
+     * - 'notExists': Uses NOT EXISTS subquery pattern
+     * - 'notIn': Uses NOT IN subquery pattern
+     * - 'leftJoinIsNull': Uses LEFT JOIN WHERE NULL pattern (default)
+     * @example
+     * // Find users with no orders using NOT EXISTS
+     * User.findAll({
+     *   include: [{ model: Order, antiJoin: true, antiJoinType: 'notExists' }]
+     * })
+     */
+    antiJoinType?: 'notExists' | 'notIn' | 'leftJoinIsNull';
+    /**
+     * Whether to use CROSS APPLY or OUTER APPLY (SQL Server only).
+     * - 'CROSS': CROSS APPLY - returns only matching rows
+     * - 'OUTER': OUTER APPLY - returns all rows from left table (like LEFT JOIN)
+     * @example
+     * // SQL Server CROSS APPLY with a subquery
+     * User.findAll({
+     *   include: [{
+     *     model: Order,
+     *     apply: 'CROSS',
+     *     where: { status: 'active' }
+     *   }]
+     * })
+     */
+    apply?: 'CROSS' | 'OUTER';
+    /**
+     * Inline lateral subquery for advanced use cases.
+     * Allows defining an inline subquery that can reference columns from preceding tables.
+     * @example
+     * // PostgreSQL LATERAL subquery
+     * User.findAll({
+     *   include: [{
+     *     lateralSubquery: {
+     *       model: Order,
+     *       where: { status: 'active' },
+     *       attributes: ['id', 'total']
+     *     }
+     *   }]
+     * })
+     */
+    lateralSubquery?: {
+        /** The model for the lateral subquery */
+        model: ModelStatic<any>;
+        /** WHERE conditions on the subquery */
+        where?: WhereOptions;
+        /** Attributes to select from the subquery */
+        attributes?: string[] | {
+            include?: string[];
+            exclude?: string[];
+        };
+    };
+}
+/**
+ * Options for anti-join queries
+ * Used to find records that do not have related records
+ */
+export interface AntiJoinOptions {
+    /** The model to check for absence of related records */
+    model: ModelStatic<any>;
+    /** Alias for the included model */
+    as?: string;
+    /** WHERE conditions on the related model (must NOT exist for anti-join) */
+    where?: WhereOptions;
+    /** Custom foreign key for the join */
+    foreignKey?: string | string[] | {
+        name?: string | string[];
+        allowNull?: boolean;
+    };
+    /** Target key (defaults to primary key) */
+    targetKey?: string | string[];
+    /**
+     * Type of anti-join to use.
+     * - 'notExists': Uses NOT EXISTS subquery pattern
+     * - 'notIn': Uses NOT IN subquery pattern
+     * - 'leftJoinIsNull': Uses LEFT JOIN WHERE NULL pattern (default)
+     */
+    type?: 'notExists' | 'notIn' | 'leftJoinIsNull';
+}
+export interface CreateOptions extends SaveOptions {
+    include?: Includeable[] | IncludeOptions[];
+    ignoreDuplicates?: boolean;
+    validate?: boolean;
+    fields?: string[];
+    returning?: boolean | string[];
+    raw?: boolean;
+    isNewRecord?: boolean;
+    /**
+     * Connection name to use for this query
+     * Allows querying a different database connection
+     */
+    using?: string;
+}
+export interface UpdateOptions extends SaveOptions {
+    where: WhereOptions;
+    limit?: number;
+    validate?: boolean;
+    fields?: string[];
+    returning?: boolean | string[];
+    sideEffects?: boolean;
+    omitNull?: boolean;
+    hooks?: boolean;
+    individualHooks?: boolean;
+    benchmark?: boolean;
+    logging?: boolean | ((sql: string, time?: number) => void);
+    /**
+     * Connection name to use for this query
+     * Allows querying a different database connection
+     */
+    using?: string;
+}
+export interface DestroyOptions extends HookOptions {
+    where: WhereOptions;
+    limit?: number;
+    truncate?: boolean;
+    cascade?: boolean;
+    force?: boolean;
+    restartIdentity?: boolean;
+    returning?: boolean | string[];
+    /**
+     * When false, performs a soft delete by setting deletedAt instead of actually deleting
+     * When true, actually deletes the record (bypasses paranoid mode)
+     * @default false
+     */
+    paranoid?: boolean;
+    /** Logging options for the query */
+    logging?: boolean | ((sql: string, time?: number) => void);
+    /**
+     * Connection name to use for this query
+     * Allows querying a different database connection
+     */
+    using?: string;
+}
+export interface SaveOptions {
+    transaction?: Transaction;
+    hooks?: boolean;
+    validate?: boolean;
+    fields?: string[];
+    sideEffects?: boolean;
+    logging?: boolean | ((sql: string, time?: number) => void);
+    benchmark?: boolean;
+}
+export interface ReloadOptions extends FindOptions {
+    /**
+     * Specify attributes to select when reloading from the database.
+     * If not provided, all attributes will be selected.
+     */
+    attributes?: string[];
+    /**
+     * Run beforeReload and afterReload hooks (default: true)
+     */
+    hooks?: boolean;
+}
+export interface AssociationOptions {
+    as?: string;
+    /**
+     * Foreign key field name(s) for the association.
+     * Can be a single string for simple foreign keys, or an array for composite foreign keys.
+     * @example
+     * foreignKey: 'userId'  // Simple FK
+     * foreignKey: ['orderId', 'customerId']  // Composite FK
+     */
+    foreignKey?: string | string[] | AssociationForeignKeyOptions;
+    /**
+     * Source key(s) on the source model (the model defining the association).
+     * Defaults to the primary key.
+     * @example
+     * sourceKey: 'id'  // Simple key
+     * sourceKey: ['id', 'tenantId']  // Composite key
+     */
+    sourceKey?: string | string[];
+    /**
+     * Target key(s) on the target model (the model being associated).
+     * Defaults to the primary key.
+     * @example
+     * targetKey: 'id'  // Simple key
+     * targetKey: ['id', 'customerId']  // Composite key
+     */
+    targetKey?: string | string[];
+    constraints?: boolean;
+    /**
+     * Referential action to take when the referenced row is deleted.
+     * @example
+     * onDelete: ReferentialAction.Cascade // or onDelete: 'CASCADE'
+     */
+    onDelete?: ReferentialAction | 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION' | 'SET DEFAULT';
+    /**
+     * Referential action to take when the referenced row's key is updated.
+     * @example
+     * onUpdate: ReferentialAction.Cascade // or onUpdate: 'CASCADE'
+     */
+    onUpdate?: ReferentialAction | 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION' | 'SET DEFAULT';
+    foreignKeyConstraint?: boolean;
+    through?: string | ThroughOptions;
+    scope?: AssociationScope;
+}
+export interface AssociationForeignKeyOptions {
+    /** Custom name for the foreign key constraint */
+    name?: string;
+    /** Allow null values in the foreign key column(s) */
+    allowNull?: boolean;
+    /** Validation options for the foreign key column */
+    validate?: ModelValidationOptions;
+    /**
+     * Composite foreign key - array of field names that make up the composite key.
+     * This is used when the foreign key consists of multiple columns.
+     * @example
+     * compositeKey: ['orderId', 'customerId']
+     */
+    compositeKey?: string[];
+    /** Custom constraint name for the foreign key (alternative to 'name') */
+    constraintName?: string;
+}
+export interface ThroughOptions {
+    model: string | ModelStatic<any>;
+    as?: string;
+    foreignKey?: string | AssociationForeignKeyOptions;
+    otherKey?: string | AssociationForeignKeyOptions;
+    scope?: AssociationScope;
+    timestamps?: boolean;
+}
+export interface AssociationScope {
+    [key: string]: any;
+}
+/**
+ * Transaction class
+ */
+export declare class Transaction {
+    id: string;
+    finished: boolean;
+    options: TransactionOptions;
+    parent: Transaction | null;
+    savepoints: string[];
+    constructor(options?: TransactionOptions);
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+export interface TransactionOptions {
+    autocommit?: boolean;
+    /**
+     * ANSI SQL transaction isolation level. Accepts either the `IsolationLevel`
+     * enum or the equivalent raw string literal (kept for backwards
+     * compatibility with existing callers). Dialect-specific native values
+     * that aren't part of the ANSI set (e.g. Db2's `UR`/`CS`/`RS`/`RR`
+     * abbreviations or MSSQL's `SNAPSHOT`) are intentionally not part of the
+     * `IsolationLevel` enum and continue to be accepted only as plain
+     * strings by the dialects that support them.
+     * @example
+     * { isolationLevel: 'SERIALIZABLE' }
+     * @example
+     * { isolationLevel: IsolationLevel.Serializable }
+     */
+    isolationLevel?: IsolationLevel | IsolationLevelString;
+    type?: 'DEFERRED' | 'IMMEDIATE' | 'EXCLUSIVE';
+    deferrable?: string;
+    /**
+     * Lock level for all queries within the transaction
+     * - true: FOR UPDATE (equivalent to 'UPDATE')
+     * - 'UPDATE': FOR UPDATE
+     * - 'SHARE': FOR SHARE (PostgreSQL) / LOCK IN SHARE MODE (MySQL)
+     * - 'KEY SHARE': FOR KEY SHARE (PostgreSQL only)
+     * - { of: Model }: Lock only the specified table (PostgreSQL)
+     */
+    lock?: LockOptions;
+}
+/**
+ * ANSI SQL transaction isolation levels expressed as a string-literal union.
+ * Kept as a standalone export (in addition to the `IsolationLevel` enum
+ * below) so existing code that passes raw strings such as
+ * `{ isolationLevel: 'SERIALIZABLE' }` keeps compiling without changes.
+ */
+export type IsolationLevelString = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABLE READ' | 'SERIALIZABLE';
+/**
+ * ANSI SQL transaction isolation levels.
+ *
+ * This is a companion enum for `IsolationLevelString` / the
+ * `TransactionOptions.isolationLevel` field. The field accepts both this
+ * enum and the raw string literals for backwards compatibility, so either
+ * of the following work:
+ * @example
+ * transaction.start({ isolationLevel: 'SERIALIZABLE' });
+ * @example
+ * transaction.start({ isolationLevel: IsolationLevel.Serializable });
+ */
+export declare enum IsolationLevel {
+    ReadUncommitted = "READ UNCOMMITTED",
+    ReadCommitted = "READ COMMITTED",
+    RepeatableRead = "REPEATABLE READ",
+    Serializable = "SERIALIZABLE"
+}
+export interface ModelStatic<T extends Model> {
+    name: string;
+    tableName: string;
+    /** Schema the model belongs to */
+    schema?: string;
+    rawAttributes: Record<string, AttributeOptions>;
+    associations: Record<string, Association>;
+    /** Static property indicating this is a model class (always false for static check) */
+    isNewRecord: false;
+    /**
+     * Build a WHERE condition using operator symbols
+     *
+     * @example
+     * // Simple equality
+     * User.where('status', 'active')
+     * // => { status: 'active' }
+     *
+     * // With operator
+     * User.where('age', Op.gte, 18)
+     * // => { age: { $gte: 18 } }
+     *
+     * // Using with findAll
+     * User.findAll({ where: User.where('status', 'active') })
+     */
+    where(field: string, operator: string | symbol | unknown, value?: unknown): WhereOptions;
+    findOne(options?: FindOptions): Promise<T | null>;
+    findAll(options?: FindOptions): Promise<T[]>;
+    /**
+     * Find all records matching the given options and return both rows and total count
+     * @param findOptions - Options for the query including limit and offset for pagination
+     * @returns Object with rows array and count total
+     *
+     * @example
+     * // Basic find and count all
+     * const result = await User.findAndCountAll();
+     * console.log(result.count); // total number of matching records
+     * console.log(result.rows);  // array of model instances
+     *
+     * @example
+     * // With pagination - get 10 records starting from record 20
+     * const result = await User.findAndCountAll({
+     *   limit: 10,
+     *   offset: 20,
+     *   where: { status: 'active' }
+     * });
+     *
+     * @example
+     * // With subquery optimization
+     * const result = await User.findAndCountAll({
+     *   include: [{ model: Post, where: { status: 'published' } }],
+     *   subquery: false
+     * });
+     */
+    findAndCountAll(options?: FindOptions): Promise<{
+        rows: T[];
+        count: number;
+    }>;
+    create(values?: Partial<T>, options?: CreateOptions): Promise<T>;
+    update(values: Partial<T>, options: UpdateOptions): Promise<[number, T[]]>;
+    destroy(options: DestroyOptions): Promise<number>;
+    bulkDestroy(options: DestroyOptions): Promise<number>;
+    /**
+     * Restore soft-deleted records (set deletedAt to NULL)
+     * @param options Restore options with where clause
+     */
+    restore(options?: RestoreOptions & {
+        where?: WhereOptions;
+    }): Promise<number>;
+    bulkRestore(options?: RestoreOptions & {
+        where?: WhereOptions;
+    }): Promise<number>;
+    bulkCreate(records: Partial<T>[], options?: BulkCreateOptions): Promise<T[]>;
+    count(options?: CountOptions): Promise<number>;
+    avg(attribute: string, options?: AggregateOptions): Promise<number>;
+    max(attribute: string, options?: AggregateOptions): Promise<any>;
+    min(attribute: string, options?: AggregateOptions): Promise<any>;
+    sum(attribute: string, options?: AggregateOptions & {
+        distinct?: boolean;
+    }): Promise<number>;
+    /**
+     * ROW_NUMBER() - Returns the row number within the partition
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The row number
+     *
+     * @example
+     * // Get row numbers partitioned by category
+     * const users = await User.findAll({
+     *   attributes: [[User.rowNumber({ partitionBy: 'department', orderBy: ['createdAt', 'DESC'] }), 'rowNum']]
+     * });
+     */
+    rowNumber(options: WindowFunctionOptions): number;
+    /**
+     * RANK() - Returns the rank of the current row within the partition (with gaps)
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The rank value
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.rank({ orderBy: ['score', 'DESC'] }), 'rank']]
+     * });
+     */
+    rank(options: WindowFunctionOptions): number;
+    /**
+     * DENSE_RANK() - Returns the rank of the current row within the partition (without gaps)
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The dense rank value
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.denseRank({ orderBy: ['score', 'DESC'] }), 'denseRank']]
+     * });
+     */
+    denseRank(options: WindowFunctionOptions): number;
+    /**
+     * LAG() - Returns the value from the preceding row in the partition
+     * @param field - The field to get value from
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The value from the preceding row
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.lag('salary', { partitionBy: 'department', orderBy: 'hireDate' }), 'prevSalary']]
+     * });
+     */
+    lag(field: string, options?: WindowFunctionOptions): any;
+    /**
+     * LEAD() - Returns the value from the following row in the partition
+     * @param field - The field to get value from
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The value from the following row
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.lead('salary', { partitionBy: 'department', orderBy: 'hireDate' }), 'nextSalary']]
+     * });
+     */
+    lead(field: string, options?: WindowFunctionOptions): any;
+    /**
+     * FIRST_VALUE() - Returns the first value in the partition
+     * @param field - The field to get first value from
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The first value in the partition
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.firstValue('salary', { partitionBy: 'department', orderBy: 'hireDate' }), 'firstSalary']]
+     * });
+     */
+    firstValue(field: string, options?: WindowFunctionOptions): any;
+    /**
+     * LAST_VALUE() - Returns the last value in the partition
+     * @param field - The field to get last value from
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The last value in the partition
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.lastValue('salary', { partitionBy: 'department', orderBy: 'hireDate' }), 'lastSalary']]
+     * });
+     */
+    lastValue(field: string, options?: WindowFunctionOptions): any;
+    /**
+     * NTH_VALUE() - Returns the nth value in the partition
+     * @param field - The field to get nth value from
+     * @param n - The position (1-based)
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The nth value in the partition
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.nthValue('salary', 2, { partitionBy: 'department', orderBy: 'hireDate' }), 'secondSalary']]
+     * });
+     */
+    nthValue(field: string, n: number, options?: WindowFunctionOptions): any;
+    /**
+     * NTILE() - Distributes rows into n buckets
+     * @param n - Number of buckets
+     * @param options - Window function options (partitionBy, orderBy)
+     * @returns The bucket number (1 to n)
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.ntile(4, { partitionBy: 'department', orderBy: 'salary' }), 'quartile']]
+     * });
+     */
+    ntile(n: number, options?: WindowFunctionOptions): any;
+    /**
+     * PERCENT_RANK() - Returns the relative rank of a row (0 to 1)
+     * @param options - Window function options (partitionBy, orderBy)
+     * @returns The percent rank value
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.percentRank({ orderBy: ['score', 'DESC'] }), 'pctRank']]
+     * });
+     */
+    percentRank(options?: WindowFunctionOptions): any;
+    /**
+     * CUME_DIST() - Returns the cumulative distribution (0 to 1)
+     * @param options - Window function options (partitionBy, orderBy)
+     * @returns The cumulative distribution value
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.cumeDist({ orderBy: ['score', 'DESC'] }), 'cumeDist']]
+     * });
+     */
+    cumeDist(options?: WindowFunctionOptions): any;
+    /**
+     * COUNT() as window function - counts rows or non-null values
+     * @param options - Window function options (partitionBy, orderBy, windowFrame, countField)
+     * @returns The count value
+     *
+     * @example
+     * const users = await User.findAll({
+     *   attributes: [[User.count({ partitionBy: 'department' }), 'deptCount']]
+     * });
+     */
+    count(options?: WindowFunctionOptions & {
+        countField?: string;
+    }): any;
+    /**
+     * SUM() as window function - sums values in a partition
+     * @param field - The field to sum
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The sum value
+     *
+     * @example
+     * const orders = await Order.findAll({
+     *   attributes: [[Order.sum('amount', { partitionBy: 'customerId', orderBy: 'orderDate' }), 'runningTotal']]
+     * });
+     */
+    sum(field: string, options?: WindowFunctionOptions): any;
+    /**
+     * AVG() as window function - calculates average in a partition
+     * @param field - The field to average
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The average value
+     *
+     * @example
+     * const orders = await Order.findAll({
+     *   attributes: [[Order.avg('amount', { partitionBy: 'customerId' }), 'avgOrder']]
+     * });
+     */
+    avg(field: string, options?: WindowFunctionOptions): any;
+    /**
+     * MAX() as window function - returns maximum value in a partition
+     * @param field - The field to find maximum
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The maximum value
+     *
+     * @example
+     * const orders = await Order.findAll({
+     *   attributes: [[Order.max('amount', { partitionBy: 'customerId' }), 'maxOrder']]
+     * });
+     */
+    max(field: string, options?: WindowFunctionOptions): any;
+    /**
+     * MIN() as window function - returns minimum value in a partition
+     * @param field - The field to find minimum
+     * @param options - Window function options (partitionBy, orderBy, windowFrame)
+     * @returns The minimum value
+     *
+     * @example
+     * const orders = await Order.findAll({
+     *   attributes: [[Order.min('amount', { partitionBy: 'customerId' }), 'minOrder']]
+     * });
+     */
+    min(field: string, options?: WindowFunctionOptions): any;
+    /**
+     * Generate a window function SQL expression for use in queries
+     * @param functionName - The window function name (ROW_NUMBER, RANK, etc.)
+     * @param args - Arguments to the window function
+     * @param options - Window function options
+     * @returns Object with sql and values for the window function
+     *
+     * @example
+     * const expr = User.windowFunction('ROW_NUMBER', [], { partitionBy: 'department', orderBy: ['createdAt', 'DESC'] });
+     */
+    windowFunction(functionName: string, args: any[], options: WindowFunctionOptions): {
+        sql: string;
+        values: any[];
+    };
+    upsert(values: Partial<T>, options?: UpsertOptions): Promise<[T, boolean]>;
+    /**
+     * Find a record by the given where clause, or create it if not found
+     * @param options - Find options with where clause and defaults for creation
+     * @returns A tuple of [instance, created] where created is true if a new record was created
+     *
+     * @example
+     * const [user, created] = await User.findOrCreate({
+     *   where: { email: 'test@test.com' },
+     *   defaults: { name: 'Test User' }
+     * });
+     */
+    findOrCreate(options: FindOptions & {
+        defaults?: Partial<T>;
+    }): Promise<[T, boolean]>;
+    /**
+     * Find a record by the given where clause, or build (but not save) it if not found
+     * @param options - Find options with where clause and defaults for building
+     * @returns A tuple of [instance, created] where created is true if a new instance was built
+     *
+     * @example
+     * const [user, created] = await User.findOrBuild({
+     *   where: { email: 'test@test.com' },
+     *   defaults: { name: 'Test User' }
+     * });
+     */
+    findOrBuild(options: FindOptions & {
+        defaults?: Partial<T>;
+    }): Promise<[T, boolean]>;
+    /**
+     * Find a record by the given where clause, or build (but not save) it if not found
+     * Alias for findOrBuild
+     */
+    findOrInitialize(options: FindOptions & {
+        defaults?: Partial<T>;
+    }): Promise<[T, boolean]>;
+    truncate(options?: TruncateOptions): Promise<void>;
+    describe(): Promise<Record<string, AttributeOptions>>;
+    drop(options?: DropOptions): Promise<void>;
+    getTableName(): string;
+    /**
+     * Refresh a materialized view (PostgreSQL only)
+     * @param options - Refresh options
+     * @returns Promise<void>
+     *
+     * @example
+     * // Simple refresh
+     * await User.refresh();
+     *
+     * // Concurrent refresh (requires unique index)
+     * await User.refresh({ concurrently: true });
+     *
+     * // Refresh without data
+     * await User.refresh({ withNoData: true });
+     */
+    refresh(options?: RefreshOptions): Promise<void>;
+    /**
+     * Check if this model is a materialized view
+     * @returns True if the model is a materialized view
+     */
+    isMaterializedView?: boolean;
+    /**
+     * Add a hook to the model
+     * @param hookName - Name of the hook
+     * @param handler - Hook handler function
+     */
+    hook(hookName: string, handler: HookHandler): ModelStatic<T>;
+    /**
+     * Add a named hook to the model
+     * @param hookName - Name of the hook
+     * @param name - Hook name identifier
+     * @param handler - Hook handler function
+     */
+    addHook(hookName: string, name: string, handler: HookHandler): ModelStatic<T>;
+    /**
+     * Check if a hook is registered
+     * @param hookName - Name of the hook
+     * @returns True if hook is registered
+     */
+    hasHook(hookName: string): boolean;
+    /**
+     * Remove a hook from the model
+     * @param hookName - Name of the hook
+     * @param hookOrHookId - Optional hook or hook ID to remove
+     */
+    removeHook(hookName: string, hookOrHookId?: string | HookHandler): ModelStatic<T>;
+}
+/**
+ * Options for toJSON method
+ */
+export interface ToJSONOptions {
+    /**
+     * Only include these attributes in the output
+     */
+    attributes?: string[];
+    /**
+     * Exclude these attributes from the output
+     */
+    exclude?: string[];
+    /**
+     * When true, bypass all transformations (no virtual fields, no hidden filtering)
+     */
+    raw?: boolean;
+    /**
+     * Include nested associations
+     */
+    include?: Includeable[] | IncludeOptions[];
+    /**
+     * Clone the result before returning (prevents mutation)
+     */
+    clone?: boolean;
+}
+export interface Model {
+    getDataValue(key: string): any;
+    setDataValue(key: string, value: any): void;
+    get(key: string): any;
+    set(key: string, value: any): void;
+    changed(key?: string): boolean | string[];
+    previous(key?: string): any;
+    isNewRecord: boolean;
+    isDirty: boolean;
+    primaryKey?: string;
+    transaction?: Transaction;
+    _previousDataValues: Record<string, any>;
+    dataValues: Record<string, any>;
+    validate(options?: ValidationOptions): Promise<ValidationError | {
+        valid: boolean;
+        errors: ValidationErrorItem[];
+    } | null>;
+    save(options?: SaveOptions): Promise<this>;
+    destroy(options?: DestroyOptions): Promise<void>;
+    restore(options?: RestoreOptions): Promise<void>;
+    reload(options?: FindOptions): Promise<this>;
+    toJSON(options?: ToJSONOptions): Record<string, any>;
+}
+export interface Association {
+    source: ModelStatic<any>;
+    target: ModelStatic<any>;
+    foreignKey: string | string[];
+    type: 'belongsTo' | 'hasOne' | 'hasMany' | 'belongsToMany';
+    as: string;
+    options: AssociationOptions;
+    targetKey?: string | string[];
+    sourceKey?: string | string[];
+}
+export interface BulkCreateOptions extends CreateOptions {
+    ignoreDuplicates?: boolean;
+    validate?: boolean;
+    fields?: string[];
+    hooks?: boolean;
+    individualHooks?: boolean;
+    returning?: boolean | string[];
+    /** Perform upsert instead of insert (insert or update on conflict) */
+    upsert?: boolean;
+    /** Fields to use for conflict resolution in upsert */
+    conflictFields?: string[];
+    /** Fields to update on conflict in upsert */
+    updateOnDuplicate?: string[];
+}
+export interface CountOptions extends FindOptions {
+    distinct?: boolean;
+    col?: string;
+}
+export interface AggregateOptions extends FindOptions {
+    plain?: boolean;
+}
+/**
+ * Window frame specification for window functions
+ */
+export interface WindowFrame {
+    /** Type of window frame: ROWS, RANGE, or GROUPS */
+    type: 'ROWS' | 'RANGE' | 'GROUPS';
+    /** Starting offset (positive number for following, negative for preceding) */
+    start?: number;
+    /** Ending offset (positive number for following, negative for preceding) */
+    end?: number;
+}
+/**
+ * Options for window functions
+ */
+export interface WindowFunctionOptions {
+    /** PARTITION BY clause - field(s) to partition by */
+    partitionBy?: string | string[];
+    /** ORDER BY clause - field(s) to order by */
+    orderBy?: Order;
+    /** Window frame specification */
+    windowFrame?: WindowFrame;
+    /** Number of buckets for NTILE() function */
+    ntileBuckets?: number;
+    /** Offset for LAG/LEAD functions (number of rows to look ahead/behind) */
+    offset?: number;
+    /** Default value for LAG/LEAD functions when the offset goes beyond the partition */
+    defaultValue?: any;
+}
+export interface UpsertOptions extends Omit<UpdateOptions, 'where'>, CreateOptions {
+    /** Fields to use for conflict resolution (ON CONFLICT for PostgreSQL/SQLite, ON DUPLICATE KEY for MySQL) */
+    conflictFields?: 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[];
+    /** Use raw values instead of instances */
+    raw?: boolean;
+    /** Fields to include in the returned record */
+    fields?: string[];
+    /** Hooks configuration */
+    hooks?: boolean;
+    /** Validate before upsert */
+    validate?: boolean;
+    /** Transaction to use */
+    transaction?: Transaction;
+    /** Where clause for upsert (optional, can use primary key in values instead) */
+    where?: WhereOptions;
+    /** Whether to use paranoid mode when fetching the instance after upsert */
+    paranoid?: boolean;
+}
+export interface TruncateOptions extends HookOptions {
+    cascade?: boolean;
+    restartIdentity?: boolean;
+}
+export interface DropOptions extends HookOptions {
+    cascade?: boolean;
+}
+export interface ValidationOptions {
+    fields?: string[];
+    validate?: boolean;
+    hooks?: boolean;
+}
+export interface RestoreOptions extends HookOptions {
+    where?: WhereOptions;
+    limit?: number;
+}
+export interface IncrementDecrementOptions extends HookOptions {
+    /** Amount to increment/decrement by (default: 1) */
+    by?: number;
+    /** Additional where clause for the increment/decrement operation */
+    where?: WhereOptions;
+    /** Whether to reload the instance after the operation (default: true) */
+    reload?: boolean;
+}
+export interface IncrementOptions extends IncrementDecrementOptions {
+}
+export interface DecrementOptions extends IncrementDecrementOptions {
+}
+export interface ValidationError extends Error {
+    name: string;
+    message: string;
+    errors: ValidationErrorItem[];
+}
+export interface ValidationErrorItem {
+    message: string;
+    type: string;
+    path: string;
+    value: any;
+}
+export interface QueryResult {
+    rows: any[];
+    rowCount: number;
+    fields: FieldInfo[];
+    lastInsertRowid?: number;
+    /**
+     * Scalar OUT/INOUT parameter values returned by a stored procedure `CALL`
+     * (e.g. HANA's `hdb` driver callback shape `cb(err, parameters, ...resultSets)`).
+     * Present only when the query was a procedure call that declared such
+     * parameters.
+     */
+    outputParams?: Record<string, unknown>;
+    /**
+     * Additional result sets returned by a stored procedure `CALL` beyond the
+     * primary `rows` (e.g. one array per table/cursor OUT parameter). Present
+     * only when the procedure returned more than one additional result set.
+     */
+    resultSets?: any[][];
+}
+export interface FieldInfo {
+    name: string;
+    type: string;
+    length: number;
+    tableID: number;
+    columnID: number;
+    nullable: boolean;
+    isEnum: boolean;
+    isPrimaryKey: boolean;
+}
+export interface RawQueryResult {
+    rows: any[];
+    count: number;
+    isSelect: boolean;
+}
+/**
+ * Enum for query types used in prorm.query()
+ * @example
+ * prorm.query('SELECT * FROM users', { type: QueryTypes.SELECT })
+ * prorm.query('INSERT INTO users VALUES(...)', { type: QueryTypes.INSERT })
+ */
+export declare enum QueryTypes {
+    SELECT = "SELECT",
+    INSERT = "INSERT",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+    BULKINSERT = "BULKINSERT",
+    BULKUPDATE = "BULKUPDATE",
+    BULKDELETE = "BULKDELETE",
+    RAW = "RAW",
+    CALL = "CALL"
+}
+export interface QueryOptions {
+    plain?: boolean;
+    raw?: boolean;
+    type?: QueryTypes;
+    nest?: boolean;
+    replacements?: Record<string, any>;
+    bind?: Record<string, any>;
+    transaction?: Transaction;
+    logging?: boolean | ((sql: string, time?: number) => void);
+    using?: string;
+    /**
+     * Map raw query results to a model instance
+     * When true, maps the result rows to ModelInstance objects using the provided model
+     * @default false
+     * @example
+     * // Map raw results to model
+     * const users = await prorm.query('SELECT * FROM users', {
+     *   model: User,
+     *   mapToModel: true
+     * });
+     */
+    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>;
+    /**
+     * Retry options for failed queries
+     * Allows retrying queries that fail due to transient errors (e.g., connection issues)
+     * @example
+     * // Retry up to 3 times with default error matching
+     * await prorm.query('SELECT * FROM users', {
+     *   retry: { max: 3 }
+     * });
+     * @example
+     * // Retry only on specific error patterns
+     * await prorm.query('SELECT * FROM users', {
+     *   retry: { max: 3, match: ['Connection refused', 'Too many connections'] }
+     * });
+     */
+    retry?: RetryOptions;
+    /** Query timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Options for streaming query results
+ */
+export interface StreamOptions {
+    /**
+     * Batch size for fetching records
+     * @default 1000
+     */
+    batchSize?: number;
+    /**
+     * High watermark for the stream internal buffer
+     * @default 1000
+     */
+    highWaterMark?: number;
+    /**
+     * Model to use for mapping raw results to model instances
+     */
+    model?: ModelStatic<any>;
+    /**
+     * Map raw query results to a model instance
+     * @default false
+     */
+    mapToModel?: boolean;
+    /**
+     * Transaction to use for the query
+     */
+    transaction?: Transaction;
+    /**
+     * Logging function
+     */
+    logging?: boolean | ((sql: string, time?: number) => void);
+}
+export interface QueryError extends Error {
+    parent?: Error;
+    original?: Error;
+    sql?: string;
+    parameters?: any[];
+}
+export interface SyncOptions {
+    /**
+     * If true, drop all tables first before recreating 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.
+     * @default false
+     */
+    alter?: 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;
+}
+/**
+ * Routing strategy for selecting a replica
+ */
+export type RoutingStrategy = 'round-robin' | 'least-connections' | 'lowest-lag';
+/**
+ * Replica status
+ */
+export interface ReplicaStatus {
+    /** Replica name */
+    name: string;
+    /** Whether the replica is healthy */
+    healthy: boolean;
+    /** Replication lag in milliseconds */
+    lag: number | null;
+    /** Number of active connections */
+    activeConnections: number;
+    /** Last check timestamp */
+    lastCheck: Date;
+    /** Error message if unhealthy */
+    error?: string;
+}
+/**
+ * Configuration for connecting to a replica
+ */
+export interface ReplicaConnectionConfig {
+    /** Unique name for this replica */
+    name: string;
+    /** Connection host */
+    host: string;
+    /** Connection port */
+    port: number;
+    /** Database name */
+    database: string;
+    /** Username */
+    username: string;
+    /** Password */
+    password: string;
+    /** Connection dialect (mysql, mariadb, postgres, mssql, sqlite, oracle) */
+    dialect: string;
+    /** Additional dialect-specific options */
+    dialectOptions?: Record<string, any>;
+    /** Pool options for this replica */
+    pool?: {
+        max?: number;
+        min?: number;
+        idle?: number;
+        acquire?: number;
+    };
+}
+/**
+ * Configuration for lag detection
+ */
+export interface LagDetectionConfig {
+    /** Enable lag detection */
+    enabled: boolean;
+    /** Interval in milliseconds between lag checks */
+    interval: number;
+    /** Query timeout in milliseconds */
+    timeout: number;
+    /** Maximum acceptable lag in milliseconds */
+    maxAcceptableLag: number;
+    /** Number of consecutive failures before marking replica as unhealthy */
+    maxFailures: number;
+}
+/**
+ * Options for configuring replication
+ */
+export interface ReplicationOptions {
+    /** Enable replication support */
+    enabled: boolean;
+    /** The master connection configuration */
+    master: ReplicaConnectionConfig;
+    /** Array of replica configurations */
+    replicas: ReplicaConnectionConfig[];
+    /** Default lag detection configuration */
+    lagDetection?: Partial<LagDetectionConfig>;
+    /** Default routing strategy */
+    defaultRoutingStrategy?: RoutingStrategy;
+    /** Whether to automatically fail over to master on all replicas unhealthy */
+    autoFailover?: boolean;
+}
+export type ModelInstance<T = any> = any;
+export interface RedisClusterNode {
+    host: string;
+    port: number;
+    tls?: boolean;
+}
+export interface L1CacheOptions {
+    maxItems: number;
+    ttl: number;
+}
+export interface RedisClusterCacheOptions {
+    nodes: RedisClusterNode[];
+    maxRedirects?: number;
+    keyPrefix?: string;
+    defaultTtl?: number;
+    readFromReplicas?: boolean;
+    poolSize?: number;
+    lazyConnect?: boolean;
+    l1?: L1CacheOptions;
+}
+export interface CacheManagerOptions {
+    keyPrefix?: string;
+    defaultTtl?: number;
+    l1?: L1CacheOptions;
+}