ts-prorm-orm 1.1.0 → 1.2.1

package/dist/operators.d.ts

@@ -0,0 +1,2947 @@
+/**
+ * Operators for building queries
+ * Provides Symbol-based operators for type safety and flexible query building
+ */
+import type { FullTextSearchOptions } from './types';
+import { SortDirection } from './types';
+/**
+ * Usage Examples:
+ * ```typescript
+ * // Basic operators with findAll
+ * User.findAll({ where: { age: { [Op.gte]: 18 } } })
+ * User.findAll({ where: { name: { [Op.like]: '%john%' } } })
+ * User.findAll({ where: { status: { [Op.in]: ['active', 'pending'] } } })
+ *
+ * // Using helper functions
+ * import { Op, where, and, or, eq, gte } from 'orm';
+ *
+ * // Simple equality
+ * User.findAll({ where: { name: 'John' } })
+ *
+ * // Using helpers for complex conditions
+ * User.findAll({ where: and({ name: 'John' }, { age: gte('age', 18) }) })
+ * User.findAll({ where: or({ status: 'active' }, { role: 'admin' }) })
+ *
+ * // Column comparison (e.g., WHERE column1 = column2)
+ * User.findAll({ where: { balance: { [Op.eq]: Op.col('credit_limit') } } })
+ *
+ * // Using Op.col in WHERE, ORDER BY, and UPDATE SET
+ * User.findAll({ where: { [Op.col('id')]: 1 } })
+ * User.findAll({ order: [[Op.col('name'), 'ASC']] })
+ * User.update({ count: Op.col('count') + 1 }, { where: { ... } })
+ *
+ * // JSON column queries
+ * User.findAll({ where: { settings: { [Op.json]: { theme: 'dark' } } } })
+ *
+ * // Using Op.where for explicit where clauses
+ * User.findAll({ where: Op.where(Op.col('username'), 'john') })
+ * User.findAll({ where: Op.where('status', 'active') })
+ * User.findAll({ where: Op.where(Op.col('balance'), '>', 1000) })
+ * ```
+ */
+export interface ColumnReference {
+    $col: string;
+}
+export interface LiteralValue {
+    $literal: string;
+}
+/**
+ * Check if a value is a column reference
+ */
+export declare function isColumnReference(value: any): value is ColumnReference;
+export declare const Op: {
+    readonly and: symbol;
+    readonly or: symbol;
+    readonly not: symbol;
+    readonly eq: symbol;
+    readonly is: symbol;
+    readonly ne: symbol;
+    readonly gt: symbol;
+    readonly gte: symbol;
+    readonly lt: symbol;
+    readonly lte: symbol;
+    readonly like: symbol;
+    readonly notLike: symbol;
+    readonly iLike: symbol;
+    readonly notILike: symbol;
+    readonly startsWith: symbol;
+    readonly notStartsWith: symbol;
+    readonly endsWith: symbol;
+    readonly notEndsWith: symbol;
+    readonly substring: symbol;
+    readonly notSubstring: symbol;
+    readonly col: symbol;
+    readonly in: symbol;
+    readonly notIn: symbol;
+    readonly between: symbol;
+    readonly notBetween: symbol;
+    readonly isNull: symbol;
+    readonly isNotNull: symbol;
+    readonly exists: symbol;
+    readonly notExists: symbol;
+    readonly regexp: symbol;
+    readonly notRegexp: symbol;
+    readonly iRegexp: symbol;
+    readonly notIRegexp: symbol;
+    readonly any: symbol;
+    readonly all: symbol;
+    readonly containsKey: symbol;
+    readonly containsKeyPath: symbol;
+    readonly containsPath: symbol;
+    readonly strictLeft: symbol;
+    readonly strictRight: symbol;
+    readonly noExtendRight: symbol;
+    readonly noExtendLeft: symbol;
+    readonly adj: symbol;
+    readonly notAdj: symbol;
+    /**
+     * Array contains - checks if an array contains all specified elements
+     * PostgreSQL: @>
+     *
+     * @example
+     * ```typescript
+     * // Find products where tags contains both 'electronics' and 'sale'
+     * Product.findAll({ where: { tags: { [Op.arrayContains]: ['electronics', 'sale'] } } })
+     * // SQL: WHERE tags @> ARRAY['electronics', 'sale']
+     * ```
+     */
+    readonly arrayContains: symbol;
+    /**
+     * Array contained by - checks if an array is contained by the specified elements
+     * PostgreSQL: <@
+     *
+     * @example
+     * ```typescript
+     * // Find products where tags is contained by ['electronics', 'sale', 'new']
+     * Product.findAll({ where: { tags: { [Op.arrayContainedBy]: ['electronics', 'sale'] } } })
+     * // SQL: WHERE tags <@ ARRAY['electronics', 'sale']
+     * ```
+     */
+    readonly arrayContainedBy: symbol;
+    /**
+     * Array overlaps - checks if arrays have common elements
+     * PostgreSQL: &&
+     *
+     * @example
+     * ```typescript
+     * // Find products where tags overlaps with ['electronics', 'sale']
+     * Product.findAll({ where: { tags: { [Op.arrayOverlaps]: ['electronics', 'sale'] } } })
+     * // SQL: WHERE tags && ARRAY['electronics', 'sale']
+     * ```
+     */
+    readonly arrayOverlaps: symbol;
+    /**
+     * Array ANY - checks if any element matches the condition
+     * PostgreSQL: ANY
+     *
+     * @example
+     * ```typescript
+     * // Find products where any tag equals 'electronics'
+     * Product.findAll({ where: { tags: { [Op.arrayAny]: 'electronics' } } })
+     * // SQL: WHERE 'electronics' = ANY(tags)
+     * ```
+     */
+    readonly arrayAny: symbol;
+    /**
+     * Array ALL - checks if all elements match the condition
+     * PostgreSQL: ALL
+     *
+     * @example
+     * ```typescript
+     * // Find products where all prices are greater than 100
+     * Product.findAll({ where: { prices: { [Op.arrayAll]: { [Op.gt]: 100 } } } })
+     * // SQL: WHERE 100 > ALL(prices)
+     * ```
+     */
+    readonly arrayAll: symbol;
+    /**
+     * Starts with - checks if a string starts with the given value
+     * SQL: LIKE 'value%'
+     *
+     * @example
+     * ```typescript
+     * // Find users whose name starts with 'John'
+     * User.findAll({ where: { name: { [Op.startsWith]: 'John' } } })
+     * // SQL: WHERE name LIKE 'John%'
+     * ```
+     */
+    /**
+     * Ends with - checks if a string ends with the given value
+     * SQL: LIKE '%value'
+     *
+     * @example
+     * ```typescript
+     * // Find users whose email ends with '@gmail.com'
+     * User.findAll({ where: { email: { [Op.endsWith]: '@gmail.com' } } })
+     * // SQL: WHERE email LIKE '%@gmail.com'
+     * ```
+     */
+    /**
+     * JSON contains - checks if JSON document contains the specified value
+     * PostgreSQL: @>
+     * MySQL: JSON_CONTAINS
+     * SQLite: JSON_EXTRACT
+     *
+     * @example
+     * ```typescript
+     * // Find users where preferences contains { theme: 'dark' }
+     * User.findAll({ where: { preferences: { [Op.contains]: { theme: 'dark' } } } })
+     * ```
+     */
+    readonly contains: symbol;
+    /**
+     * JSON is contained in - checks if the value is contained in the JSON column
+     * PostgreSQL: <@
+     *
+     * @example
+     * ```typescript
+     * // Find users where settings is contained in the specified JSON
+     * User.findAll({ where: { settings: { [Op.containedBy]: { theme: 'dark', lang: 'en' } } } })
+     * ```
+     */
+    readonly containedBy: symbol;
+    /**
+     * JSON key exists - checks if a key (or array index) exists in a JSON object/array
+     *
+     * @example
+     * ```typescript
+     * // Find users where 'role' key exists in data column
+     * User.findAll({ where: { data: { [Op.keyExists]: 'role' } } })
+     *
+     * // Find users where array index 0 exists
+     * User.findAll({ where: { tags: { [Op.keyExists]: '0' } } })
+     * ```
+     */
+    readonly keyExists: symbol;
+    /**
+     * JSON overlap - checks if JSON arrays overlap (have common elements)
+     * PostgreSQL: &&
+     *
+     * @example
+     * ```typescript
+     * // Find users where tags overlaps with ['admin', 'vip']
+     * User.findAll({ where: { tags: { [Op.overlap]: ['admin', 'vip'] } } })
+     * ```
+     */
+    readonly overlap: symbol;
+    /**
+     * JSON key access - access a specific key in a JSON column
+     * PostgreSQL: ->> for text, -> for object
+     * MySQL: JSON_EXTRACT
+     * SQLite: JSON_EXTRACT
+     *
+     * @example
+     * ```typescript
+     * // Find users where data->>'name' equals 'John'
+     * User.findAll({ where: { data: { [Op.key]: 'name' } } })
+     * // For nested: { field: { [Op.key]: 'profile.name' } }
+     * ```
+     */
+    /**
+     * Column reference - reference another column in a WHERE clause
+     * Used for comparing one column to another
+     *
+     * @example
+     * ```typescript
+     * // Find orders where quantity equals available stock
+     * Order.findAll({ where: { quantity: { [Op.col]: 'available_stock' } } })
+     * ```
+     */
+    readonly match: symbol;
+    readonly $json: symbol;
+    /**
+     * JSON path explicit operator - explicit JSON path with field and path separated
+     * Convenience method combining field and path in one call
+     *
+     * @example
+     * ```typescript
+     * // Query with field and path separated
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.jsonPath('settings', 'theme')]: 'dark' }
+     *   }
+     * })
+     * // SQLite/MySQL: WHERE json_extract(data, '$.settings.theme') = 'dark'
+     * // PostgreSQL: WHERE data->>'settings'->>'theme' = 'dark'
+     *
+     * // Check if path exists (no value comparison)
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.jsonPath('settings', 'theme')]: { [Op.ne]: null } }
+     *   }
+     * })
+     * ```
+     */
+    readonly jsonPath: symbol;
+    /**
+     * JSON contains - checks if a JSON column contains a specific value or object
+     * PostgreSQL: @> (contains), MySQL: JSON_CONTAINS, SQLite: json_each
+     *
+     * @example
+     * ```typescript
+     * // Find users where preferences contains { theme: 'dark' }
+     * User.findAll({ where: { preferences: { [Op.jsonContains]: { theme: 'dark' } } } })
+     * // SQL: WHERE preferences @> '{"theme":"dark"}' (PostgreSQL)
+     * // SQL: WHERE JSON_CONTAINS(preferences, '{"theme":"dark"}') (MySQL)
+     * ```
+     */
+    readonly jsonContains: symbol;
+    /**
+     * JSON has key - checks if a JSON column has a specific key
+     * PostgreSQL: ? (jsonb_exists), MySQL: JSON_CONTAINS_PATH, SQLite: json_each
+     *
+     * @example
+     * ```typescript
+     * // Find users where data column has 'role' key
+     * User.findAll({ where: { data: { [Op.jsonHasKey]: 'role' } } })
+     * // SQL: WHERE data ? 'role' (PostgreSQL)
+     * // SQL: WHERE JSON_CONTAINS_PATH(data, 'one', '$.role') (MySQL)
+     * ```
+     */
+    readonly jsonHasKey: symbol;
+    /**
+     * JSONB extract - extracts a JSON object field (returns JSON)
+     * PostgreSQL: -> operator
+     *
+     * @example
+     * ```typescript
+     * // Extract field as JSON: data -> 'key'
+     * User.findAll({ where: { data: { [Op.jsonbExtract]: { path: 'key' } } } })
+     * // SQL: WHERE data -> 'key'
+     * ```
+     */
+    readonly jsonbExtract: symbol;
+    /**
+     * JSONB extract text - extracts a JSON object field as text (returns text)
+     * PostgreSQL: ->> operator
+     *
+     * @example
+     * ```typescript
+     * // Extract field as text: data ->> 'key'
+     * User.findAll({ where: { data: { [Op.jsonbExtractText]: { path: 'key', value: 'someValue' } } } })
+     * // SQL: WHERE data ->> 'key' = 'someValue'
+     * ```
+     */
+    readonly jsonbExtractText: symbol;
+    /**
+     * JSONB extract path - extracts JSON by path (returns JSON)
+     * PostgreSQL: #> operator
+     *
+     * @example
+     * ```typescript
+     * // Extract nested path as JSON: data #> '{a, b}'
+     * User.findAll({ where: { data: { [Op.jsonbExtractPath]: { path: ['a', 'b'] } } } })
+     * // SQL: WHERE data #> '{a, b}'
+     * ```
+     */
+    readonly jsonbExtractPath: symbol;
+    /**
+     * JSONB extract path text - extracts JSON by path as text (returns text)
+     * PostgreSQL: #>> operator
+     *
+     * @example
+     * ```typescript
+     * // Extract nested path as text: data #>> '{a, b}'
+     * User.findAll({ where: { data: { [Op.jsonbExtractPathText]: { path: ['a', 'b'], value: 'someValue' } } } })
+     * // SQL: WHERE data #>> '{a, b}' = 'someValue'
+     * ```
+     */
+    readonly jsonbExtractPathText: symbol;
+    /**
+     * JSONB concatenation - concatenates two JSONB values
+     * PostgreSQL: || operator
+     *
+     * @example
+     * ```typescript
+     * // Concatenate JSONB values: data || '{"key": "value"}'
+     * User.findAll({ where: { data: { [Op.jsonConcat]: { key: 'value' } } } })
+     * // SQL: WHERE data || '{"key": "value"}'
+     * ```
+     */
+    readonly jsonConcat: symbol;
+    /**
+     * JSONB delete key - deletes a key from JSONB object
+     * PostgreSQL: - operator
+     *
+     * @example
+     * ```typescript
+     * // Delete key from JSONB: data - 'key'
+     * User.findAll({ where: { data: { [Op.jsonDelete]: 'key' } } })
+     * // SQL: WHERE data - 'key'
+     * ```
+     */
+    readonly jsonDelete: symbol;
+    /**
+     * JSONB delete by path - deletes a key from JSONB by path
+     * PostgreSQL: #- operator
+     *
+     * @example
+     * ```typescript
+     * // Delete by path: data #- '{a, b}'
+     * User.findAll({ where: { data: { [Op.jsonDeletePath]: ['a', 'b'] } } })
+     * // SQL: WHERE data #- '{a, b}'
+     * ```
+     */
+    readonly jsonDeletePath: symbol;
+    /**
+     * JSON path exists - checks if a JSON path exists and returns boolean
+     * PostgreSQL: @? operator
+     *
+     * @example
+     * ```typescript
+     * // Check if path exists: data @? '$.key'
+     * User.findAll({ where: { data: { [Op.jsonPathExists]: '$.key' } } })
+     * // SQL: WHERE data @? '$.key'
+     * ```
+     */
+    readonly jsonPathExists: symbol;
+    /**
+     * JSON path query - evaluates JSON path and returns result
+     * PostgreSQL: @@ operator
+     *
+     * @example
+     * ```typescript
+     * // Query JSON path: data @@ '$.key'
+     * User.findAll({ where: { data: { [Op.jsonPathQuery]: '$.key' } } })
+     * // SQL: WHERE data @@ '$.key'
+     * ```
+     */
+    readonly jsonPathQuery: symbol;
+    /**
+     * JSON type of - returns the type of a JSON value
+     * PostgreSQL: json_typeof function
+     *
+     * @example
+     * ```typescript
+     * // Get JSON type: json_typeof(data)
+     * User.findAll({ where: { data: { [Op.jsonTypeOf]: 'object' } } })
+     * // SQL: WHERE json_typeof(data) = 'object'
+     * ```
+     */
+    readonly jsonTypeOf: symbol;
+    /**
+     * Create a JSON column path reference for querying
+     * Returns a Symbol that can be used as a computed property key
+     *
+     * @example
+     * ```typescript
+     * // Using as computed property key (recommended)
+     * User.findAll({
+     *   where: {
+     *     settings: { [Op.json('$.theme')]: 'dark' }
+     *   }
+     * })
+     * // SQL: WHERE json_extract(settings, '$.theme') = 'dark'
+     *
+     * // Using with path prefix
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.json('address.city')]: 'NYC' }
+     *   }
+     * })
+     * // SQL: WHERE json_extract(data, '$.address.city') = 'NYC'
+     * ```
+     */
+    readonly json: (path: string) => symbol;
+    /**
+     * Create a JSON key path query
+     * Useful for accessing specific keys in a JSON/JSONB column
+     *
+     * @example
+     * ```typescript
+     * // Access JSON key 'name' from data column
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.key]: 'name' }
+     *   }
+     * })
+     *
+     * // Compare JSON key to a value
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.key]: { path: 'name', value: 'John' } }
+     *   }
+     * })
+     *
+     * // Nested key access
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.key]: { path: 'profile.settings.theme', value: 'dark' } }
+     *   }
+     * })
+     * ```
+     */
+    readonly key: (pathOrOptions: string | {
+        path: string;
+        value?: any;
+    }) => Record<string, any>;
+    /**
+     * Create a raw SQL literal
+     * Useful for embedding raw SQL expressions like NOW(), CURRENT_TIMESTAMP, etc.
+     *
+     * @example
+     * ```typescript
+     * // Use with update to set current timestamp
+     * User.update({ lastLogin: Op.literal('NOW()') }, { where: { ... } })
+     *
+     * // Use in where clause to compare with current time
+     * User.findAll({
+     *   where: {
+     *     createdAt: { [Op.lt]: Op.literal('NOW()') }
+     *   }
+     * })
+     *
+     * // Compare column to a literal value
+     * User.findAll({
+     *   where: {
+     *     updatedAt: { [Op.gt]: Op.literal('createdAt') }
+     *   }
+     * })
+     *
+     * // Use with Op.where
+     * User.findAll({ where: Op.where(Op.col('created_at'), '>', Op.literal('NOW()')) })
+     * ```
+     */
+    readonly literal: (value: string) => LiteralValue;
+    /**
+     * Create a CAST expression for type casting
+     * SQL: CAST(value AS type)
+     *
+     * @example
+     * ```typescript
+     * // CAST('2023-01-01' AS DATE)
+     * User.findAll({
+     *   attributes: [[Op.cast('2023-01-01', 'DATE'), 'dateOnly']]
+     * })
+     *
+     * // CAST(column AS INTEGER)
+     * User.findAll({
+     *   attributes: [[Op.cast(col('createdAt'), 'INTEGER'), 'dateInt']]
+     * })
+     *
+     * // CAST to DECIMAL
+     * User.findAll({
+     *   attributes: [[Op.cast(col('price'), 'DECIMAL(10,2)'), 'priceDecimal']]
+     * })
+     * ```
+     */
+    readonly cast: (value: any, type: string) => CastExpression;
+    /**
+     * Create an EXTRACT expression for extracting date parts
+     * SQL: EXTRACT(part FROM field)
+     *
+     * @example
+     * ```typescript
+     * // EXTRACT(YEAR FROM createdAt)
+     * User.findAll({
+     *   attributes: [[Op.extract('createdAt', 'year'), 'year']]
+     * })
+     *
+     * // EXTRACT(MONTH FROM order_date)
+     * User.findAll({
+     *   attributes: [[Op.extract('orderDate', 'month'), 'month']]
+     * })
+     *
+     * // EXTRACT(HOUR FROM timestamp)
+     * User.findAll({
+     *   attributes: [[Op.extract('createdAt', 'hour'), 'hour']]
+     * })
+     * ```
+     */
+    readonly extract: (field: any, part: ExtractPart) => ExtractExpression;
+    /**
+     * Create a CONVERT expression for type conversion
+     * SQL: CONVERT(value, type) for MySQL, CAST for other dialects
+     *
+     * @example
+     * ```typescript
+     * // CONVERT(value, type)
+     * User.findAll({
+     *   attributes: [[Op.conv(col('value'), null, 'CHAR'), 'strValue']]
+     * })
+     *
+     * // MySQL charset conversion
+     * User.findAll({
+     *   attributes: [[Op.conv(col('name'), null, 'utf8mb4'), 'utf8Name']]
+     * })
+     * ```
+     */
+    readonly conv: (value: any, from: string | null | undefined, to: string) => ConvExpression;
+    /**
+     * Create a where clause with a column reference
+     * Supports both simple equality (2 args) and explicit operator (3 args)
+     *
+     * @example
+     * ```typescript
+     * // Simple equality (2 args) - defaults to =
+     * Op.where(Op.col('username'), 'john')
+     * // => { $where: { $col: 'username', $eq: 'john' } }
+     *
+     * // Compare column to a value with explicit operator
+     * Op.where(Op.col('user.id'), '=', 1)
+     * // => { $where: { $col: 'user.id', $eq: 1 } }
+     *
+     * // Compare column to another column
+     * Op.where(Op.col('balance'), '>', Op.col('credit_limit'))
+     * // => { $where: { $col: 'balance', $gt: { $col: 'credit_limit' } } }
+     *
+     * // Using with Op.eq symbol
+     * Op.where(Op.col('user.id'), Op.eq, 1)
+     * // => { $where: { $col: 'user.id', $eq: 1 } }
+     *
+     * // Using with findAll
+     * User.findAll({ where: Op.where(Op.col('username'), 'john') })
+     * User.findAll({ where: Op.where('status', 'active') })
+     * ```
+     */
+    readonly where: (column: {
+        $col: string;
+    } | string, operator: any, value?: any) => {
+        $where: {
+            $col: string;
+            [key: string]: any;
+        };
+    } | Record<string, any>;
+    /**
+     * Create an ascending order expression
+     * SQL: ORDER BY field ASC
+     *
+     * @example
+     * ```typescript
+     * // Order by name ascending
+     * User.findAll({ order: [Op.asc('name')] })
+     * // SQL: ORDER BY name ASC
+     *
+     * // Multiple order conditions
+     * User.findAll({ order: [Op.asc('name'), Op.desc('createdAt')] })
+     * ```
+     */
+    readonly asc: (field: string) => OrderExpression;
+    /**
+     * Create a descending order expression
+     * SQL: ORDER BY field DESC
+     *
+     * @example
+     * ```typescript
+     * // Order by createdAt descending (newest first)
+     * User.findAll({ order: [Op.desc('createdAt')] })
+     * // SQL: ORDER BY createdAt DESC
+     *
+     * // Combined with asc
+     * User.findAll({ order: [Op.asc('name'), Op.desc('createdAt')] })
+     * ```
+     */
+    readonly desc: (field: string) => OrderExpression;
+    /**
+     * Create a random order expression
+     * SQL: ORDER BY RANDOM() (SQLite/PostgreSQL) or ORDER BY RAND() (MySQL)
+     *
+     * @example
+     * ```typescript
+     * // Random ordering (useful for sampling)
+     * User.findAll({ order: [Op.random()] })
+     * // SQLite: ORDER BY RANDOM()
+     * // MySQL: ORDER BY RAND()
+     * // PostgreSQL: ORDER BY RANDOM()
+     *
+     * // With limit for random sample
+     * User.findAll({ order: [Op.random()], limit: 5 })
+     * ```
+     */
+    readonly random: () => OrderExpression;
+    /**
+     * Check if a value is not null
+     * Returns true if the value is not null or undefined
+     * Useful as a predicate for filtering arrays
+     *
+     * @example
+     * ```typescript
+     * // Filter out null values from an array
+     * const values = [1, null, 2, undefined, 3];
+     * const notNullValues = values.filter(Op.isNotNull);
+     * // => [1, 2, 3]
+     *
+     * // Using in array filter with objects
+     * const users = [{ name: 'John', age: null }, { name: 'Jane', age: 25 }];
+     * const withAge = users.filter(u => Op.isNotNull(u.age));
+     * // => [{ name: 'Jane', age: 25 }]
+     * ```
+     */
+    readonly isNotNullPredicate: (value: any) => boolean;
+    /**
+     * Create a full-text search MATCH AGAINST condition (MySQL)
+     * SQL: MATCH(columns) AGAINST(searchTerm [IN NATURAL LANGUAGE MODE | IN BOOLEAN MODE])
+     *
+     * @example
+     * ```typescript
+     * // Natural language mode search
+     * Article.findAll({
+     *   where: {
+     *     [Op.matchAgainst(['title', 'body'])]: 'database'
+     *   }
+     * })
+     * // SQL: WHERE MATCH(title, body) AGAINST('database' IN NATURAL LANGUAGE MODE)
+     *
+     * // Boolean mode search
+     * Article.findAll({
+     *   where: {
+     *     [Op.matchAgainst(['title', 'body'], { mode: 'boolean' })]: '+mysql -oracle'
+     *   }
+     * })
+     * // SQL: WHERE MATCH(title, body) AGAINST('+mysql -oracle' IN BOOLEAN MODE)
+     * ```
+     */
+    readonly matchAgainst: (columns: string | string[], options?: {
+        mode?: "natural" | "boolean";
+    }) => {
+        $match: {
+            columns: string[];
+            mode: "natural" | "boolean";
+        };
+    };
+    /**
+     * Create a full-text search condition (alias for matchAgainst with explicit mode)
+     * SQL: MATCH(columns) AGAINST(searchTerm IN NATURAL LANGUAGE MODE)
+     *
+     * @example
+     * ```typescript
+     * Article.findAll({
+     *   where: {
+     *     [Op.matchFulltext(['title', 'body'])]: 'database'
+     *   }
+     * })
+     * // SQL: WHERE MATCH(title, body) AGAINST('database' IN NATURAL LANGUAGE MODE)
+     * ```
+     */
+    readonly matchFulltext: (columns: string | string[]) => {
+        $match: {
+            columns: string[];
+            mode: "natural";
+        };
+    };
+    /**
+     * Create a PostgreSQL tsvector expression
+     * SQL: to_tsvector(config, column)
+     *
+     * @example
+     * ```typescript
+     * Article.findAll({
+     *   where: {
+     *     [Op.toTsvector('title')]: { $tsquery: 'database' }
+     *   }
+     * })
+     * // SQL: WHERE to_tsvector('english', title) @@ to_tsquery('english', 'database')
+     * ```
+     */
+    readonly toTsvector: (column: string, config?: string) => {
+        $tsvector: {
+            column: string;
+            config: string;
+        };
+    };
+    /**
+     * Create a PostgreSQL tsquery expression
+     * SQL: to_tsquery(config, query)
+     *
+     * @example
+     * ```typescript
+     * Article.findAll({
+     *   where: {
+     *     body: { [Op.toTsquery('database')]: true }
+     *   }
+     * })
+     * // SQL: WHERE body @@ to_tsquery('english', 'database')
+     * ```
+     */
+    readonly toTsquery: (query: string, config?: string) => {
+        $tsquery: {
+            query: string;
+            config: string;
+        };
+    };
+    /**
+     * ST_Distance - calculate distance between two geometries
+     * MySQL: ST_Distance(geom1, geom2)
+     * PostgreSQL: ST_Distance(geom1, geom2) - for geometry, ST_Distance(geog1, geog2) for geography
+     *
+     * @example
+     * ```typescript
+     * // Find locations within 100 meters of a point
+     * Location.findAll({
+     *   where: {
+     *     location: { [Op.stDWithin]: { from: 'POINT(0 0)', distance: 100, srid: 4326 } }
+     *   }
+     * })
+     * ```
+     */
+    readonly stDistance: symbol;
+    /**
+     * ST_Within - check if geometry A is within geometry B
+     * MySQL: ST_Within(geom1, geom2)
+     * PostgreSQL: ST_Within(geom1, geom2)
+     *
+     * @example
+     * ```typescript
+     * // Find locations within a polygon
+     * Location.findAll({
+     *   where: {
+     *     location: { [Op.stWithin]: { geometry: 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))', srid: 4326 } }
+     *   }
+     * })
+     * ```
+     */
+    readonly stWithin: symbol;
+    /**
+     * ST_Contains - check if geometry A contains geometry B
+     * MySQL: ST_Contains(geom1, geom2)
+     * PostgreSQL: ST_Contains(geom1, geom2)
+     *
+     * @example
+     * ```typescript
+     * // Find areas that contain a point
+     * Area.findAll({
+     *   where: {
+     *     boundary: { [Op.stContains]: { geometry: 'POINT(5 5)', srid: 4326 } }
+     *   }
+     * })
+     * ```
+     */
+    readonly stContains: symbol;
+    /**
+     * ST_Intersects - check if two geometries intersect
+     * MySQL: ST_Intersects(geom1, geom2)
+     * PostgreSQL: ST_Intersects(geom1, geom2)
+     *
+     * @example
+     * ```typescript
+     * // Find locations that intersect with a polygon
+     * Location.findAll({
+     *   where: {
+     *     location: { [Op.stIntersects]: { geometry: 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))', srid: 4326 } }
+     *   }
+     * })
+     * ```
+     */
+    readonly stIntersects: symbol;
+    /**
+     * ST_DWithin - check if geometries are within a given distance
+     * PostgreSQL: ST_DWithin (for both geometry and geography)
+     * MySQL 8.0+: ST_Distance_Sphere or ST_DWithin (with care)
+     *
+     * @example
+     * ```typescript
+     * // Find locations within 1km of a point
+     * Location.findAll({
+     *   where: {
+     *     location: { [Op.stDWithin]: { from: 'POINT(-122.4194 37.7749)', distance: 1000, srid: 4326 } }
+     *   }
+     * })
+     * ```
+     */
+    readonly stDWithin: symbol;
+    /**
+     * ST_Crosses - check if two geometries cross
+     * MySQL: ST_Crosses(geom1, geom2)
+     * PostgreSQL: ST_Crosses(geom1, geom2)
+     */
+    readonly stCrosses: symbol;
+    /**
+     * ST_Overlaps - check if two geometries overlap
+     * MySQL: ST_Overlaps(geom1, geom2)
+     * PostgreSQL: ST_Overlaps(geom1, geom2)
+     */
+    readonly stOverlaps: symbol;
+    /**
+     * ST_Touches - check if two geometries touch
+     * MySQL: ST_Touches(geom1, geom2)
+     * PostgreSQL: ST_Touches(geom1, geom2)
+     */
+    readonly stTouches: symbol;
+    /**
+     * ST_Equals - check if two geometries are equal
+     * MySQL: ST_Equals(geom1, geom2)
+     * PostgreSQL: ST_Equals(geom1, geom2)
+     */
+    readonly stEquals: symbol;
+    /**
+     * ST_IsValid - check if a geometry is valid
+     * MySQL: ST_IsValid(geom)
+     * PostgreSQL: ST_IsValid(geom)
+     */
+    readonly stIsValid: symbol;
+};
+export type OpType = typeof Op;
+export type OperatorSymbol = (typeof Op)[keyof typeof Op];
+/**
+ * Check if a value is a column reference or needs column reference handling
+ */
+export declare function isColOperator(value: any): boolean;
+export declare const Operators: {
+    readonly and: symbol;
+    readonly or: symbol;
+    readonly not: symbol;
+    readonly eq: symbol;
+    readonly is: symbol;
+    readonly ne: symbol;
+    readonly gt: symbol;
+    readonly gte: symbol;
+    readonly lt: symbol;
+    readonly lte: symbol;
+    readonly like: symbol;
+    readonly notLike: symbol;
+    readonly iLike: symbol;
+    readonly notILike: symbol;
+    readonly startsWith: symbol;
+    readonly notStartsWith: symbol;
+    readonly endsWith: symbol;
+    readonly notEndsWith: symbol;
+    readonly substring: symbol;
+    readonly notSubstring: symbol;
+    readonly col: symbol;
+    readonly in: symbol;
+    readonly notIn: symbol;
+    readonly between: symbol;
+    readonly notBetween: symbol;
+    readonly isNull: symbol;
+    readonly isNotNull: symbol;
+    readonly exists: symbol;
+    readonly notExists: symbol;
+    readonly regexp: symbol;
+    readonly notRegexp: symbol;
+    readonly iRegexp: symbol;
+    readonly notIRegexp: symbol;
+    readonly any: symbol;
+    readonly all: symbol;
+    readonly containsKey: symbol;
+    readonly containsKeyPath: symbol;
+    readonly containsPath: symbol;
+    readonly strictLeft: symbol;
+    readonly strictRight: symbol;
+    readonly noExtendRight: symbol;
+    readonly noExtendLeft: symbol;
+    readonly adj: symbol;
+    readonly notAdj: symbol;
+    /**
+     * Array contains - checks if an array contains all specified elements
+     * PostgreSQL: @>
+     *
+     * @example
+     * ```typescript
+     * // Find products where tags contains both 'electronics' and 'sale'
+     * Product.findAll({ where: { tags: { [Op.arrayContains]: ['electronics', 'sale'] } } })
+     * // SQL: WHERE tags @> ARRAY['electronics', 'sale']
+     * ```
+     */
+    readonly arrayContains: symbol;
+    /**
+     * Array contained by - checks if an array is contained by the specified elements
+     * PostgreSQL: <@
+     *
+     * @example
+     * ```typescript
+     * // Find products where tags is contained by ['electronics', 'sale', 'new']
+     * Product.findAll({ where: { tags: { [Op.arrayContainedBy]: ['electronics', 'sale'] } } })
+     * // SQL: WHERE tags <@ ARRAY['electronics', 'sale']
+     * ```
+     */
+    readonly arrayContainedBy: symbol;
+    /**
+     * Array overlaps - checks if arrays have common elements
+     * PostgreSQL: &&
+     *
+     * @example
+     * ```typescript
+     * // Find products where tags overlaps with ['electronics', 'sale']
+     * Product.findAll({ where: { tags: { [Op.arrayOverlaps]: ['electronics', 'sale'] } } })
+     * // SQL: WHERE tags && ARRAY['electronics', 'sale']
+     * ```
+     */
+    readonly arrayOverlaps: symbol;
+    /**
+     * Array ANY - checks if any element matches the condition
+     * PostgreSQL: ANY
+     *
+     * @example
+     * ```typescript
+     * // Find products where any tag equals 'electronics'
+     * Product.findAll({ where: { tags: { [Op.arrayAny]: 'electronics' } } })
+     * // SQL: WHERE 'electronics' = ANY(tags)
+     * ```
+     */
+    readonly arrayAny: symbol;
+    /**
+     * Array ALL - checks if all elements match the condition
+     * PostgreSQL: ALL
+     *
+     * @example
+     * ```typescript
+     * // Find products where all prices are greater than 100
+     * Product.findAll({ where: { prices: { [Op.arrayAll]: { [Op.gt]: 100 } } } })
+     * // SQL: WHERE 100 > ALL(prices)
+     * ```
+     */
+    readonly arrayAll: symbol;
+    /**
+     * Starts with - checks if a string starts with the given value
+     * SQL: LIKE 'value%'
+     *
+     * @example
+     * ```typescript
+     * // Find users whose name starts with 'John'
+     * User.findAll({ where: { name: { [Op.startsWith]: 'John' } } })
+     * // SQL: WHERE name LIKE 'John%'
+     * ```
+     */
+    /**
+     * Ends with - checks if a string ends with the given value
+     * SQL: LIKE '%value'
+     *
+     * @example
+     * ```typescript
+     * // Find users whose email ends with '@gmail.com'
+     * User.findAll({ where: { email: { [Op.endsWith]: '@gmail.com' } } })
+     * // SQL: WHERE email LIKE '%@gmail.com'
+     * ```
+     */
+    /**
+     * JSON contains - checks if JSON document contains the specified value
+     * PostgreSQL: @>
+     * MySQL: JSON_CONTAINS
+     * SQLite: JSON_EXTRACT
+     *
+     * @example
+     * ```typescript
+     * // Find users where preferences contains { theme: 'dark' }
+     * User.findAll({ where: { preferences: { [Op.contains]: { theme: 'dark' } } } })
+     * ```
+     */
+    readonly contains: symbol;
+    /**
+     * JSON is contained in - checks if the value is contained in the JSON column
+     * PostgreSQL: <@
+     *
+     * @example
+     * ```typescript
+     * // Find users where settings is contained in the specified JSON
+     * User.findAll({ where: { settings: { [Op.containedBy]: { theme: 'dark', lang: 'en' } } } })
+     * ```
+     */
+    readonly containedBy: symbol;
+    /**
+     * JSON key exists - checks if a key (or array index) exists in a JSON object/array
+     *
+     * @example
+     * ```typescript
+     * // Find users where 'role' key exists in data column
+     * User.findAll({ where: { data: { [Op.keyExists]: 'role' } } })
+     *
+     * // Find users where array index 0 exists
+     * User.findAll({ where: { tags: { [Op.keyExists]: '0' } } })
+     * ```
+     */
+    readonly keyExists: symbol;
+    /**
+     * JSON overlap - checks if JSON arrays overlap (have common elements)
+     * PostgreSQL: &&
+     *
+     * @example
+     * ```typescript
+     * // Find users where tags overlaps with ['admin', 'vip']
+     * User.findAll({ where: { tags: { [Op.overlap]: ['admin', 'vip'] } } })
+     * ```
+     */
+    readonly overlap: symbol;
+    /**
+     * JSON key access - access a specific key in a JSON column
+     * PostgreSQL: ->> for text, -> for object
+     * MySQL: JSON_EXTRACT
+     * SQLite: JSON_EXTRACT
+     *
+     * @example
+     * ```typescript
+     * // Find users where data->>'name' equals 'John'
+     * User.findAll({ where: { data: { [Op.key]: 'name' } } })
+     * // For nested: { field: { [Op.key]: 'profile.name' } }
+     * ```
+     */
+    /**
+     * Column reference - reference another column in a WHERE clause
+     * Used for comparing one column to another
+     *
+     * @example
+     * ```typescript
+     * // Find orders where quantity equals available stock
+     * Order.findAll({ where: { quantity: { [Op.col]: 'available_stock' } } })
+     * ```
+     */
+    readonly match: symbol;
+    readonly $json: symbol;
+    /**
+     * JSON path explicit operator - explicit JSON path with field and path separated
+     * Convenience method combining field and path in one call
+     *
+     * @example
+     * ```typescript
+     * // Query with field and path separated
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.jsonPath('settings', 'theme')]: 'dark' }
+     *   }
+     * })
+     * // SQLite/MySQL: WHERE json_extract(data, '$.settings.theme') = 'dark'
+     * // PostgreSQL: WHERE data->>'settings'->>'theme' = 'dark'
+     *
+     * // Check if path exists (no value comparison)
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.jsonPath('settings', 'theme')]: { [Op.ne]: null } }
+     *   }
+     * })
+     * ```
+     */
+    readonly jsonPath: symbol;
+    /**
+     * JSON contains - checks if a JSON column contains a specific value or object
+     * PostgreSQL: @> (contains), MySQL: JSON_CONTAINS, SQLite: json_each
+     *
+     * @example
+     * ```typescript
+     * // Find users where preferences contains { theme: 'dark' }
+     * User.findAll({ where: { preferences: { [Op.jsonContains]: { theme: 'dark' } } } })
+     * // SQL: WHERE preferences @> '{"theme":"dark"}' (PostgreSQL)
+     * // SQL: WHERE JSON_CONTAINS(preferences, '{"theme":"dark"}') (MySQL)
+     * ```
+     */
+    readonly jsonContains: symbol;
+    /**
+     * JSON has key - checks if a JSON column has a specific key
+     * PostgreSQL: ? (jsonb_exists), MySQL: JSON_CONTAINS_PATH, SQLite: json_each
+     *
+     * @example
+     * ```typescript
+     * // Find users where data column has 'role' key
+     * User.findAll({ where: { data: { [Op.jsonHasKey]: 'role' } } })
+     * // SQL: WHERE data ? 'role' (PostgreSQL)
+     * // SQL: WHERE JSON_CONTAINS_PATH(data, 'one', '$.role') (MySQL)
+     * ```
+     */
+    readonly jsonHasKey: symbol;
+    /**
+     * JSONB extract - extracts a JSON object field (returns JSON)
+     * PostgreSQL: -> operator
+     *
+     * @example
+     * ```typescript
+     * // Extract field as JSON: data -> 'key'
+     * User.findAll({ where: { data: { [Op.jsonbExtract]: { path: 'key' } } } })
+     * // SQL: WHERE data -> 'key'
+     * ```
+     */
+    readonly jsonbExtract: symbol;
+    /**
+     * JSONB extract text - extracts a JSON object field as text (returns text)
+     * PostgreSQL: ->> operator
+     *
+     * @example
+     * ```typescript
+     * // Extract field as text: data ->> 'key'
+     * User.findAll({ where: { data: { [Op.jsonbExtractText]: { path: 'key', value: 'someValue' } } } })
+     * // SQL: WHERE data ->> 'key' = 'someValue'
+     * ```
+     */
+    readonly jsonbExtractText: symbol;
+    /**
+     * JSONB extract path - extracts JSON by path (returns JSON)
+     * PostgreSQL: #> operator
+     *
+     * @example
+     * ```typescript
+     * // Extract nested path as JSON: data #> '{a, b}'
+     * User.findAll({ where: { data: { [Op.jsonbExtractPath]: { path: ['a', 'b'] } } } })
+     * // SQL: WHERE data #> '{a, b}'
+     * ```
+     */
+    readonly jsonbExtractPath: symbol;
+    /**
+     * JSONB extract path text - extracts JSON by path as text (returns text)
+     * PostgreSQL: #>> operator
+     *
+     * @example
+     * ```typescript
+     * // Extract nested path as text: data #>> '{a, b}'
+     * User.findAll({ where: { data: { [Op.jsonbExtractPathText]: { path: ['a', 'b'], value: 'someValue' } } } })
+     * // SQL: WHERE data #>> '{a, b}' = 'someValue'
+     * ```
+     */
+    readonly jsonbExtractPathText: symbol;
+    /**
+     * JSONB concatenation - concatenates two JSONB values
+     * PostgreSQL: || operator
+     *
+     * @example
+     * ```typescript
+     * // Concatenate JSONB values: data || '{"key": "value"}'
+     * User.findAll({ where: { data: { [Op.jsonConcat]: { key: 'value' } } } })
+     * // SQL: WHERE data || '{"key": "value"}'
+     * ```
+     */
+    readonly jsonConcat: symbol;
+    /**
+     * JSONB delete key - deletes a key from JSONB object
+     * PostgreSQL: - operator
+     *
+     * @example
+     * ```typescript
+     * // Delete key from JSONB: data - 'key'
+     * User.findAll({ where: { data: { [Op.jsonDelete]: 'key' } } })
+     * // SQL: WHERE data - 'key'
+     * ```
+     */
+    readonly jsonDelete: symbol;
+    /**
+     * JSONB delete by path - deletes a key from JSONB by path
+     * PostgreSQL: #- operator
+     *
+     * @example
+     * ```typescript
+     * // Delete by path: data #- '{a, b}'
+     * User.findAll({ where: { data: { [Op.jsonDeletePath]: ['a', 'b'] } } })
+     * // SQL: WHERE data #- '{a, b}'
+     * ```
+     */
+    readonly jsonDeletePath: symbol;
+    /**
+     * JSON path exists - checks if a JSON path exists and returns boolean
+     * PostgreSQL: @? operator
+     *
+     * @example
+     * ```typescript
+     * // Check if path exists: data @? '$.key'
+     * User.findAll({ where: { data: { [Op.jsonPathExists]: '$.key' } } })
+     * // SQL: WHERE data @? '$.key'
+     * ```
+     */
+    readonly jsonPathExists: symbol;
+    /**
+     * JSON path query - evaluates JSON path and returns result
+     * PostgreSQL: @@ operator
+     *
+     * @example
+     * ```typescript
+     * // Query JSON path: data @@ '$.key'
+     * User.findAll({ where: { data: { [Op.jsonPathQuery]: '$.key' } } })
+     * // SQL: WHERE data @@ '$.key'
+     * ```
+     */
+    readonly jsonPathQuery: symbol;
+    /**
+     * JSON type of - returns the type of a JSON value
+     * PostgreSQL: json_typeof function
+     *
+     * @example
+     * ```typescript
+     * // Get JSON type: json_typeof(data)
+     * User.findAll({ where: { data: { [Op.jsonTypeOf]: 'object' } } })
+     * // SQL: WHERE json_typeof(data) = 'object'
+     * ```
+     */
+    readonly jsonTypeOf: symbol;
+    /**
+     * Create a JSON column path reference for querying
+     * Returns a Symbol that can be used as a computed property key
+     *
+     * @example
+     * ```typescript
+     * // Using as computed property key (recommended)
+     * User.findAll({
+     *   where: {
+     *     settings: { [Op.json('$.theme')]: 'dark' }
+     *   }
+     * })
+     * // SQL: WHERE json_extract(settings, '$.theme') = 'dark'
+     *
+     * // Using with path prefix
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.json('address.city')]: 'NYC' }
+     *   }
+     * })
+     * // SQL: WHERE json_extract(data, '$.address.city') = 'NYC'
+     * ```
+     */
+    readonly json: (path: string) => symbol;
+    /**
+     * Create a JSON key path query
+     * Useful for accessing specific keys in a JSON/JSONB column
+     *
+     * @example
+     * ```typescript
+     * // Access JSON key 'name' from data column
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.key]: 'name' }
+     *   }
+     * })
+     *
+     * // Compare JSON key to a value
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.key]: { path: 'name', value: 'John' } }
+     *   }
+     * })
+     *
+     * // Nested key access
+     * User.findAll({
+     *   where: {
+     *     data: { [Op.key]: { path: 'profile.settings.theme', value: 'dark' } }
+     *   }
+     * })
+     * ```
+     */
+    readonly key: (pathOrOptions: string | {
+        path: string;
+        value?: any;
+    }) => Record<string, any>;
+    /**
+     * Create a raw SQL literal
+     * Useful for embedding raw SQL expressions like NOW(), CURRENT_TIMESTAMP, etc.
+     *
+     * @example
+     * ```typescript
+     * // Use with update to set current timestamp
+     * User.update({ lastLogin: Op.literal('NOW()') }, { where: { ... } })
+     *
+     * // Use in where clause to compare with current time
+     * User.findAll({
+     *   where: {
+     *     createdAt: { [Op.lt]: Op.literal('NOW()') }
+     *   }
+     * })
+     *
+     * // Compare column to a literal value
+     * User.findAll({
+     *   where: {
+     *     updatedAt: { [Op.gt]: Op.literal('createdAt') }
+     *   }
+     * })
+     *
+     * // Use with Op.where
+     * User.findAll({ where: Op.where(Op.col('created_at'), '>', Op.literal('NOW()')) })
+     * ```
+     */
+    readonly literal: (value: string) => LiteralValue;
+    /**
+     * Create a CAST expression for type casting
+     * SQL: CAST(value AS type)
+     *
+     * @example
+     * ```typescript
+     * // CAST('2023-01-01' AS DATE)
+     * User.findAll({
+     *   attributes: [[Op.cast('2023-01-01', 'DATE'), 'dateOnly']]
+     * })
+     *
+     * // CAST(column AS INTEGER)
+     * User.findAll({
+     *   attributes: [[Op.cast(col('createdAt'), 'INTEGER'), 'dateInt']]
+     * })
+     *
+     * // CAST to DECIMAL
+     * User.findAll({
+     *   attributes: [[Op.cast(col('price'), 'DECIMAL(10,2)'), 'priceDecimal']]
+     * })
+     * ```
+     */
+    readonly cast: (value: any, type: string) => CastExpression;
+    /**
+     * Create an EXTRACT expression for extracting date parts
+     * SQL: EXTRACT(part FROM field)
+     *
+     * @example
+     * ```typescript
+     * // EXTRACT(YEAR FROM createdAt)
+     * User.findAll({
+     *   attributes: [[Op.extract('createdAt', 'year'), 'year']]
+     * })
+     *
+     * // EXTRACT(MONTH FROM order_date)
+     * User.findAll({
+     *   attributes: [[Op.extract('orderDate', 'month'), 'month']]
+     * })
+     *
+     * // EXTRACT(HOUR FROM timestamp)
+     * User.findAll({
+     *   attributes: [[Op.extract('createdAt', 'hour'), 'hour']]
+     * })
+     * ```
+     */
+    readonly extract: (field: any, part: ExtractPart) => ExtractExpression;
+    /**
+     * Create a CONVERT expression for type conversion
+     * SQL: CONVERT(value, type) for MySQL, CAST for other dialects
+     *
+     * @example
+     * ```typescript
+     * // CONVERT(value, type)
+     * User.findAll({
+     *   attributes: [[Op.conv(col('value'), null, 'CHAR'), 'strValue']]
+     * })
+     *
+     * // MySQL charset conversion
+     * User.findAll({
+     *   attributes: [[Op.conv(col('name'), null, 'utf8mb4'), 'utf8Name']]
+     * })
+     * ```
+     */
+    readonly conv: (value: any, from: string | null | undefined, to: string) => ConvExpression;
+    /**
+     * Create a where clause with a column reference
+     * Supports both simple equality (2 args) and explicit operator (3 args)
+     *
+     * @example
+     * ```typescript
+     * // Simple equality (2 args) - defaults to =
+     * Op.where(Op.col('username'), 'john')
+     * // => { $where: { $col: 'username', $eq: 'john' } }
+     *
+     * // Compare column to a value with explicit operator
+     * Op.where(Op.col('user.id'), '=', 1)
+     * // => { $where: { $col: 'user.id', $eq: 1 } }
+     *
+     * // Compare column to another column
+     * Op.where(Op.col('balance'), '>', Op.col('credit_limit'))
+     * // => { $where: { $col: 'balance', $gt: { $col: 'credit_limit' } } }
+     *
+     * // Using with Op.eq symbol
+     * Op.where(Op.col('user.id'), Op.eq, 1)
+     * // => { $where: { $col: 'user.id', $eq: 1 } }
+     *
+     * // Using with findAll
+     * User.findAll({ where: Op.where(Op.col('username'), 'john') })
+     * User.findAll({ where: Op.where('status', 'active') })
+     * ```
+     */
+    readonly where: (column: {
+        $col: string;
+    } | string, operator: any, value?: any) => {
+        $where: {
+            $col: string;
+            [key: string]: any;
+        };
+    } | Record<string, any>;
+    /**
+     * Create an ascending order expression
+     * SQL: ORDER BY field ASC
+     *
+     * @example
+     * ```typescript
+     * // Order by name ascending
+     * User.findAll({ order: [Op.asc('name')] })
+     * // SQL: ORDER BY name ASC
+     *
+     * // Multiple order conditions
+     * User.findAll({ order: [Op.asc('name'), Op.desc('createdAt')] })
+     * ```
+     */
+    readonly asc: (field: string) => OrderExpression;
+    /**
+     * Create a descending order expression
+     * SQL: ORDER BY field DESC
+     *
+     * @example
+     * ```typescript
+     * // Order by createdAt descending (newest first)
+     * User.findAll({ order: [Op.desc('createdAt')] })
+     * // SQL: ORDER BY createdAt DESC
+     *
+     * // Combined with asc
+     * User.findAll({ order: [Op.asc('name'), Op.desc('createdAt')] })
+     * ```
+     */
+    readonly desc: (field: string) => OrderExpression;
+    /**
+     * Create a random order expression
+     * SQL: ORDER BY RANDOM() (SQLite/PostgreSQL) or ORDER BY RAND() (MySQL)
+     *
+     * @example
+     * ```typescript
+     * // Random ordering (useful for sampling)
+     * User.findAll({ order: [Op.random()] })
+     * // SQLite: ORDER BY RANDOM()
+     * // MySQL: ORDER BY RAND()
+     * // PostgreSQL: ORDER BY RANDOM()
+     *
+     * // With limit for random sample
+     * User.findAll({ order: [Op.random()], limit: 5 })
+     * ```
+     */
+    readonly random: () => OrderExpression;
+    /**
+     * Check if a value is not null
+     * Returns true if the value is not null or undefined
+     * Useful as a predicate for filtering arrays
+     *
+     * @example
+     * ```typescript
+     * // Filter out null values from an array
+     * const values = [1, null, 2, undefined, 3];
+     * const notNullValues = values.filter(Op.isNotNull);
+     * // => [1, 2, 3]
+     *
+     * // Using in array filter with objects
+     * const users = [{ name: 'John', age: null }, { name: 'Jane', age: 25 }];
+     * const withAge = users.filter(u => Op.isNotNull(u.age));
+     * // => [{ name: 'Jane', age: 25 }]
+     * ```
+     */
+    readonly isNotNullPredicate: (value: any) => boolean;
+    /**
+     * Create a full-text search MATCH AGAINST condition (MySQL)
+     * SQL: MATCH(columns) AGAINST(searchTerm [IN NATURAL LANGUAGE MODE | IN BOOLEAN MODE])
+     *
+     * @example
+     * ```typescript
+     * // Natural language mode search
+     * Article.findAll({
+     *   where: {
+     *     [Op.matchAgainst(['title', 'body'])]: 'database'
+     *   }
+     * })
+     * // SQL: WHERE MATCH(title, body) AGAINST('database' IN NATURAL LANGUAGE MODE)
+     *
+     * // Boolean mode search
+     * Article.findAll({
+     *   where: {
+     *     [Op.matchAgainst(['title', 'body'], { mode: 'boolean' })]: '+mysql -oracle'
+     *   }
+     * })
+     * // SQL: WHERE MATCH(title, body) AGAINST('+mysql -oracle' IN BOOLEAN MODE)
+     * ```
+     */
+    readonly matchAgainst: (columns: string | string[], options?: {
+        mode?: "natural" | "boolean";
+    }) => {
+        $match: {
+            columns: string[];
+            mode: "natural" | "boolean";
+        };
+    };
+    /**
+     * Create a full-text search condition (alias for matchAgainst with explicit mode)
+     * SQL: MATCH(columns) AGAINST(searchTerm IN NATURAL LANGUAGE MODE)
+     *
+     * @example
+     * ```typescript
+     * Article.findAll({
+     *   where: {
+     *     [Op.matchFulltext(['title', 'body'])]: 'database'
+     *   }
+     * })
+     * // SQL: WHERE MATCH(title, body) AGAINST('database' IN NATURAL LANGUAGE MODE)
+     * ```
+     */
+    readonly matchFulltext: (columns: string | string[]) => {
+        $match: {
+            columns: string[];
+            mode: "natural";
+        };
+    };
+    /**
+     * Create a PostgreSQL tsvector expression
+     * SQL: to_tsvector(config, column)
+     *
+     * @example
+     * ```typescript
+     * Article.findAll({
+     *   where: {
+     *     [Op.toTsvector('title')]: { $tsquery: 'database' }
+     *   }
+     * })
+     * // SQL: WHERE to_tsvector('english', title) @@ to_tsquery('english', 'database')
+     * ```
+     */
+    readonly toTsvector: (column: string, config?: string) => {
+        $tsvector: {
+            column: string;
+            config: string;
+        };
+    };
+    /**
+     * Create a PostgreSQL tsquery expression
+     * SQL: to_tsquery(config, query)
+     *
+     * @example
+     * ```typescript
+     * Article.findAll({
+     *   where: {
+     *     body: { [Op.toTsquery('database')]: true }
+     *   }
+     * })
+     * // SQL: WHERE body @@ to_tsquery('english', 'database')
+     * ```
+     */
+    readonly toTsquery: (query: string, config?: string) => {
+        $tsquery: {
+            query: string;
+            config: string;
+        };
+    };
+    /**
+     * ST_Distance - calculate distance between two geometries
+     * MySQL: ST_Distance(geom1, geom2)
+     * PostgreSQL: ST_Distance(geom1, geom2) - for geometry, ST_Distance(geog1, geog2) for geography
+     *
+     * @example
+     * ```typescript
+     * // Find locations within 100 meters of a point
+     * Location.findAll({
+     *   where: {
+     *     location: { [Op.stDWithin]: { from: 'POINT(0 0)', distance: 100, srid: 4326 } }
+     *   }
+     * })
+     * ```
+     */
+    readonly stDistance: symbol;
+    /**
+     * ST_Within - check if geometry A is within geometry B
+     * MySQL: ST_Within(geom1, geom2)
+     * PostgreSQL: ST_Within(geom1, geom2)
+     *
+     * @example
+     * ```typescript
+     * // Find locations within a polygon
+     * Location.findAll({
+     *   where: {
+     *     location: { [Op.stWithin]: { geometry: 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))', srid: 4326 } }
+     *   }
+     * })
+     * ```
+     */
+    readonly stWithin: symbol;
+    /**
+     * ST_Contains - check if geometry A contains geometry B
+     * MySQL: ST_Contains(geom1, geom2)
+     * PostgreSQL: ST_Contains(geom1, geom2)
+     *
+     * @example
+     * ```typescript
+     * // Find areas that contain a point
+     * Area.findAll({
+     *   where: {
+     *     boundary: { [Op.stContains]: { geometry: 'POINT(5 5)', srid: 4326 } }
+     *   }
+     * })
+     * ```
+     */
+    readonly stContains: symbol;
+    /**
+     * ST_Intersects - check if two geometries intersect
+     * MySQL: ST_Intersects(geom1, geom2)
+     * PostgreSQL: ST_Intersects(geom1, geom2)
+     *
+     * @example
+     * ```typescript
+     * // Find locations that intersect with a polygon
+     * Location.findAll({
+     *   where: {
+     *     location: { [Op.stIntersects]: { geometry: 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))', srid: 4326 } }
+     *   }
+     * })
+     * ```
+     */
+    readonly stIntersects: symbol;
+    /**
+     * ST_DWithin - check if geometries are within a given distance
+     * PostgreSQL: ST_DWithin (for both geometry and geography)
+     * MySQL 8.0+: ST_Distance_Sphere or ST_DWithin (with care)
+     *
+     * @example
+     * ```typescript
+     * // Find locations within 1km of a point
+     * Location.findAll({
+     *   where: {
+     *     location: { [Op.stDWithin]: { from: 'POINT(-122.4194 37.7749)', distance: 1000, srid: 4326 } }
+     *   }
+     * })
+     * ```
+     */
+    readonly stDWithin: symbol;
+    /**
+     * ST_Crosses - check if two geometries cross
+     * MySQL: ST_Crosses(geom1, geom2)
+     * PostgreSQL: ST_Crosses(geom1, geom2)
+     */
+    readonly stCrosses: symbol;
+    /**
+     * ST_Overlaps - check if two geometries overlap
+     * MySQL: ST_Overlaps(geom1, geom2)
+     * PostgreSQL: ST_Overlaps(geom1, geom2)
+     */
+    readonly stOverlaps: symbol;
+    /**
+     * ST_Touches - check if two geometries touch
+     * MySQL: ST_Touches(geom1, geom2)
+     * PostgreSQL: ST_Touches(geom1, geom2)
+     */
+    readonly stTouches: symbol;
+    /**
+     * ST_Equals - check if two geometries are equal
+     * MySQL: ST_Equals(geom1, geom2)
+     * PostgreSQL: ST_Equals(geom1, geom2)
+     */
+    readonly stEquals: symbol;
+    /**
+     * ST_IsValid - check if a geometry is valid
+     * MySQL: ST_IsValid(geom)
+     * PostgreSQL: ST_IsValid(geom)
+     */
+    readonly stIsValid: symbol;
+};
+/**
+ * Check if a value is a symbol operator
+ */
+export declare function isOperator(value: any): value is OperatorSymbol;
+/**
+ * Get the string representation of an operator symbol
+ */
+export declare function getOperatorString(op: OperatorSymbol): string;
+/**
+ * Create a where condition using an operator
+ */
+export interface WhereConditionOptions {
+    column: string;
+    operator: OperatorSymbol;
+    value: any;
+}
+/**
+ * Convert operator symbol to where clause key
+ */
+export declare function operatorToWhereKey(op: OperatorSymbol): string;
+/**
+ * Type for where condition object (plain object with field conditions)
+ */
+export type WhereConditionObject = Record<string, any>;
+/**
+ * Helper to create where conditions
+ * Supports multiple call signatures:
+ * - where({ status: 'active', age: { $gte: 18 } }) - create WHERE from object
+ * - where('age', Op.gte, 18) - create WHERE with operator
+ * - where({ OR: [...] }) or where({ AND: [...] }) - nested conditions
+ *
+ * @example
+ * // Object form - simple conditions
+ * where({ status: 'active' })
+ * // => { status: 'active' }
+ *
+ * // Object form - with operators
+ * where({ age: { $gte: 18 }, status: 'active' })
+ * // => { age: { $gte: 18 }, status: 'active' }
+ *
+ * // Three-argument form
+ * where('age', Op.gte, 18)
+ * // => { age: { $gte: 18 } }
+ *
+ * // Nested OR
+ * where({ OR: [{ status: 'active' }, { role: 'admin' }] })
+ * // => { $or: [{ status: 'active' }, { role: 'admin' }] }
+ *
+ * // Nested AND
+ * where({ AND: [{ age: { $gte: 18 } }, { status: 'active' }] })
+ * // => { $and: [{ age: { $gte: 18 } }, { status: 'active' }] }
+ */
+export declare function where(condition: WhereConditionObject): WhereConditionObject;
+export declare function where(column: string, operator: OperatorSymbol, value: any): Record<string, any>;
+/**
+ * Helper to create AND conditions
+ */
+export declare function and(...conditions: any[]): {
+    $and: any[];
+};
+/**
+ * Helper to create OR conditions
+ */
+export declare function or(...conditions: any[]): {
+    $or: any[];
+};
+/**
+ * Helper to create NOT conditions
+ */
+export declare function not(condition: any): {
+    $not: any;
+};
+/**
+ * Helper to create equality condition
+ */
+export declare function eq(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create not equal condition
+ */
+export declare function ne(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create greater than condition
+ */
+export declare function gt(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create greater than or equal condition
+ */
+export declare function gte(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create less than condition
+ */
+export declare function lt(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create less than or equal condition
+ */
+export declare function lte(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create LIKE condition
+ * Wraps the value with % on both sides for contains matching
+ */
+export declare function like(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create NOT LIKE condition
+ */
+export declare function notLike(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create IN condition
+ */
+export declare function inOp(column: string, values: any[]): Record<string, any>;
+/**
+ * Helper to create NOT IN condition
+ */
+export declare function notIn(column: string, values: any[]): Record<string, any>;
+/**
+ * Helper to create BETWEEN condition
+ */
+export declare function between(column: string, start: any, end: any): Record<string, any>;
+/**
+ * Helper to create NOT BETWEEN condition
+ */
+export declare function notBetween(column: string, start: any, end: any): Record<string, any>;
+/**
+ * Helper to create IS NULL condition
+ */
+export declare function isNull(column: string): Record<string, any>;
+/**
+ * Helper to create IS NOT NULL condition
+ */
+export declare function isNotNull(column: string): Record<string, any>;
+/**
+ * Helper to create NOT EXISTS condition for anti-joins
+ * Returns records where the subquery returns no rows
+ *
+ * @example
+ * // Find users with no orders
+ * User.findAll({
+ *   where: notExists('SELECT 1 FROM orders WHERE orders.user_id = users.id')
+ * })
+ */
+export declare function notExists(subquery: string | {
+    $literal: string;
+}): Record<string, any>;
+/**
+ * Helper to create EXISTS condition
+ * Returns records where the subquery returns at least one row
+ *
+ * @example
+ * // Find users with at least one order
+ * User.findAll({
+ *   where: exists('SELECT 1 FROM orders WHERE orders.user_id = users.id')
+ * })
+ */
+export declare function exists(subquery: string | {
+    $literal: string;
+}): Record<string, any>;
+/**
+ * Helper to create NOT IN with subquery condition for anti-joins
+ * Returns records where the column value is not in the subquery result
+ *
+ * @example
+ * // Find users not in the banned users list
+ * User.findAll({
+ *   where: notInSubquery('id', 'SELECT user_id FROM banned_users')
+ * })
+ */
+export declare function notInSubquery(column: string, subquery: string | {
+    $literal: string;
+}): Record<string, any>;
+/**
+ * Helper to create IN with subquery condition
+ * Returns records where the column value is in the subquery result
+ *
+ * @example
+ * // Find users that have placed orders
+ * User.findAll({
+ *   where: inSubquery('id', 'SELECT user_id FROM orders')
+ * })
+ */
+export declare function inSubquery(column: string, subquery: string | {
+    $literal: string;
+}): Record<string, any>;
+/**
+ * Helper to create an anti-join condition using LEFT JOIN WHERE NULL pattern
+ * This is useful for finding records that don't have related records
+ *
+ * @example
+ * // Find users with no orders - using LEFT JOIN WHERE NULL pattern
+ * User.findAll({
+ *   include: [{
+ *     model: Order,
+ *     where: { userId: { [Op.col]: 'User.id' } },
+ *     antiJoin: true
+ *   }]
+ * })
+ */
+export declare function antiJoin(model: any, options?: {
+    as?: string;
+    foreignKey?: string;
+    where?: Record<string, any>;
+    antiJoinType?: 'notExists' | 'notIn' | 'leftJoinIsNull';
+}): Record<string, any>;
+/**
+ * Helper to create an exclude condition (alias for antiJoin)
+ * Returns records that are NOT in the specified model/table
+ *
+ * @example
+ * // Find users not in the banned users table
+ * User.findAll({
+ *   include: [{ model: BannedUser, exclude: true }]
+ * })
+ */
+export declare function exclude(model: any, options?: {
+    as?: string;
+    foreignKey?: string;
+    where?: Record<string, any>;
+    antiJoinType?: 'notExists' | 'notIn' | 'leftJoinIsNull';
+}): Record<string, any>;
+/**
+ * Helper to create ILIKE (case-insensitive LIKE) condition
+ */
+export declare function iLike(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create NOT ILIKE (case-insensitive NOT LIKE) condition
+ */
+export declare function notILike(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create REGEXP condition
+ */
+export declare function regexp(column: string, pattern: string | RegExp): Record<string, any>;
+/**
+ * Helper to create NOT REGEXP condition
+ */
+export declare function notRegexp(column: string, pattern: string | RegExp): Record<string, any>;
+/**
+ * Helper to create IREGEXP (case-insensitive REGEXP) condition
+ */
+export declare function iRegexp(column: string, pattern: string | RegExp): Record<string, any>;
+/**
+ * Helper to create NOT IREGEXP (case-insensitive NOT REGEXP) condition
+ */
+export declare function notIRegexp(column: string, pattern: string | RegExp): Record<string, any>;
+/**
+ * Helper to create CONTAINS condition (for arrays/JSON)
+ */
+export declare function contains(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create OVERLAP condition (for arrays)
+ */
+export declare function overlap(column: string, value: any[]): Record<string, any>;
+/**
+ * Helper to create array contains condition
+ * PostgreSQL: @> operator
+ *
+ * @example
+ * ```typescript
+ * // Find products where tags contains both 'electronics' and 'sale'
+ * Product.findAll({ where: arrayContains('tags', ['electronics', 'sale']) })
+ * // SQL: WHERE tags @> ARRAY['electronics', 'sale']
+ * ```
+ */
+export declare function arrayContains(column: string, value: any[]): Record<string, any>;
+/**
+ * Helper to create array contained by condition
+ * PostgreSQL: <@ operator
+ *
+ * @example
+ * ```typescript
+ * // Find products where tags is contained by ['electronics', 'sale']
+ * Product.findAll({ where: arrayContainedBy('tags', ['electronics', 'sale']) })
+ * // SQL: WHERE tags <@ ARRAY['electronics', 'sale']
+ * ```
+ */
+export declare function arrayContainedBy(column: string, value: any[]): Record<string, any>;
+/**
+ * Helper to create array overlaps condition
+ * PostgreSQL: && operator
+ *
+ * @example
+ * ```typescript
+ * // Find products where tags overlaps with ['electronics', 'sale']
+ * Product.findAll({ where: arrayOverlaps('tags', ['electronics', 'sale']) })
+ * // SQL: WHERE tags && ARRAY['electronics', 'sale']
+ * ```
+ */
+export declare function arrayOverlaps(column: string, value: any[]): Record<string, any>;
+/**
+ * Helper to create array ANY condition
+ * PostgreSQL: = ANY() operator
+ *
+ * @example
+ * ```typescript
+ * // Find products where any tag equals 'electronics'
+ * Product.findAll({ where: arrayAny('tags', 'electronics') })
+ * // SQL: WHERE 'electronics' = ANY(tags)
+ * ```
+ */
+export declare function arrayAny(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create array ALL condition
+ * PostgreSQL: ALL() operator
+ *
+ * @example
+ * ```typescript
+ * // Find products where all prices are greater than 100
+ * Product.findAll({ where: arrayAll('prices', 100) })
+ * // SQL: WHERE 100 > ALL(prices)
+ * ```
+ */
+export declare function arrayAll(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create startsWith condition
+ * Creates a LIKE 'value%' pattern
+ *
+ * @example
+ * ```typescript
+ * // Find users whose name starts with 'John'
+ * User.findAll({ where: startsWith('name', 'John') })
+ * // SQL: WHERE name LIKE 'John%'
+ * ```
+ */
+export declare function startsWith(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create notStartsWith condition
+ * Creates a NOT LIKE 'value%' pattern
+ */
+export declare function notStartsWith(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create endsWith condition
+ * Creates a LIKE '%value' pattern
+ *
+ * @example
+ * ```typescript
+ * // Find users whose email ends with '@gmail.com'
+ * User.findAll({ where: endsWith('email', '@gmail.com') })
+ * // SQL: WHERE email LIKE '%@gmail.com'
+ * ```
+ */
+export declare function endsWith(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create notEndsWith condition
+ * Creates a NOT LIKE '%value' pattern
+ */
+export declare function notEndsWith(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create substring/contains condition
+ * Creates a LIKE '%value%' pattern
+ *
+ * @example
+ * ```typescript
+ * // Find users whose name contains 'john'
+ * User.findAll({ where: substring('name', 'john') })
+ * // SQL: WHERE name LIKE '%john%'
+ * ```
+ */
+export declare function substring(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create notSubstring condition
+ * Creates a NOT LIKE '%value%' pattern
+ */
+export declare function notSubstring(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create ANY condition for array queries
+ * PostgreSQL: column = ANY(array_column)
+ *
+ * @example
+ * ```typescript
+ * // Find users where role matches any value in the roles array
+ * User.findAll({ where: { roles: { [Op.any]: ['admin', 'moderator'] } } })
+ * ```
+ */
+export declare function anyOp(column: string, values: any[]): Record<string, any>;
+/**
+ * Helper to create ALL condition for array queries
+ * PostgreSQL: column = ALL(array_column)
+ *
+ * @example
+ * ```typescript
+ * // Find users where role matches all values in the roles array
+ * User.findAll({ where: { roles: { [Op.all]: ['admin', 'moderator'] } } })
+ * ```
+ */
+export declare function allOp(column: string, values: any[]): Record<string, any>;
+/**
+ * Helper to create MATCH condition for full-text search
+ * Database-specific: uses MATCH AGAINST in MySQL, @@ in PostgreSQL
+ *
+ * @example
+ * ```typescript
+ * // Full-text search
+ * User.findAll({ where: match('bio', 'javascript programming') })
+ * // MySQL: WHERE MATCH(bio) AGAINST('javascript programming')
+ * // PostgreSQL: WHERE bio @@ to_tsquery('javascript')
+ * ```
+ */
+export declare function match(column: string, pattern: string): Record<string, any>;
+export { inOp as in };
+export { anyOp as any };
+export { allOp as all };
+/**
+ * Sort direction for `ORDER BY` clauses.
+ *
+ * Companion enum for the string-literal union that `OrderExpression.direction`
+ * (and other order-direction fields across the public API) accepts. Passing the raw
+ * string literals `'ASC'` / `'DESC'` continues to work unchanged — the enum is purely
+ * an additive, opt-in convenience. Re-exported here from `./types` so it can be
+ * imported from either module.
+ *
+ * @example
+ * ```typescript
+ * // Using raw string literals (still supported)
+ * User.findAll({ order: [['name', 'ASC']] });
+ *
+ * // Using the SortDirection enum
+ * import { SortDirection } from 'prorm';
+ * User.findAll({ order: [['name', SortDirection.ASC]] });
+ * ```
+ */
+export { SortDirection } from './types';
+/**
+ * Represents an ORDER BY expression
+ */
+export interface OrderExpression {
+    __type: 'order';
+    field: string;
+    direction: SortDirection | 'ASC' | 'DESC' | 'RANDOM';
+}
+/**
+ * Check if a value is an order expression
+ */
+export declare function isOrderExpression(value: any): value is OrderExpression;
+/**
+ * Create an ascending order expression
+ * SQL: ORDER BY field ASC
+ *
+ * @example
+ * ```typescript
+ * // Order by name ascending
+ * User.findAll({ order: [asc('name')] })
+ * // SQL: ORDER BY name ASC
+ *
+ * // Multiple order conditions
+ * User.findAll({ order: [asc('name'), desc('createdAt')] })
+ *
+ * // Equivalent using the SortDirection enum directly (no helper function)
+ * import { SortDirection } from 'prorm';
+ * User.findAll({ order: [['name', SortDirection.ASC]] })
+ * ```
+ */
+export declare function asc(field: string): OrderExpression;
+/**
+ * Create a descending order expression
+ * SQL: ORDER BY field DESC
+ *
+ * @example
+ * ```typescript
+ * // Order by createdAt descending (newest first)
+ * User.findAll({ order: [desc('createdAt')] })
+ * // SQL: ORDER BY createdAt DESC
+ *
+ * // Combined with asc
+ * User.findAll({ order: [asc('name'), desc('createdAt')] })
+ * ```
+ */
+export declare function desc(field: string): OrderExpression;
+/**
+ * Create a random order expression
+ * SQL: ORDER BY RANDOM() (SQLite/PostgreSQL) or ORDER BY RAND() (MySQL)
+ *
+ * @example
+ * ```typescript
+ * // Random ordering (useful for sampling)
+ * User.findAll({ order: [random()] })
+ * // SQLite: ORDER BY RANDOM()
+ * // MySQL: ORDER BY RAND()
+ * // PostgreSQL: ORDER BY RANDOM()
+ *
+ * // With limit for random sample
+ * User.findAll({ order: [random()], limit: 5 })
+ * ```
+ */
+export declare function random(): OrderExpression;
+/**
+ * Create a full-text search MATCH AGAINST condition (MySQL)
+ * SQL: MATCH(columns) AGAINST(searchTerm [IN NATURAL LANGUAGE MODE | IN BOOLEAN MODE])
+ *
+ * @example
+ * ```typescript
+ * // Natural language mode search
+ * import { matchAgainst } from 'orm';
+ * Article.findAll({
+ *   where: {
+ *     [matchAgainst(['title', 'body'])]: 'database'
+ *   }
+ * })
+ * // SQL: WHERE MATCH(title, body) AGAINST('database' IN NATURAL LANGUAGE MODE)
+ *
+ * // Boolean mode search
+ * Article.findAll({
+ *   where: {
+ *     [matchAgainst(['title', 'body'], { mode: 'boolean' })]: '+mysql -oracle'
+ *   }
+ * })
+ * // SQL: WHERE MATCH(title, body) AGAINST('+mysql -oracle' IN BOOLEAN MODE)
+ * ```
+ */
+export declare function matchAgainst(columns: string | string[], options?: FullTextSearchOptions): {
+    $match: {
+        columns: string[];
+        mode: 'natural' | 'boolean';
+    };
+};
+/**
+ * Create an explicit full-text search condition (alias for natural language mode)
+ * SQL: MATCH(columns) AGAINST(searchTerm IN NATURAL LANGUAGE MODE)
+ *
+ * @example
+ * ```typescript
+ * import { matchFulltext } from 'orm';
+ * Article.findAll({
+ *   where: {
+ *     [matchFulltext(['title', 'body'])]: 'database'
+ *   }
+ * })
+ * // SQL: WHERE MATCH(title, body) AGAINST('database' IN NATURAL LANGUAGE MODE)
+ * ```
+ */
+export declare function matchFulltext(columns: string | string[]): {
+    $match: {
+        columns: string[];
+        mode: 'natural';
+    };
+};
+/**
+ * Create a PostgreSQL to_tsvector expression
+ * SQL: to_tsvector(config, column)
+ *
+ * @example
+ * ```typescript
+ * import { toTsvector } from 'orm';
+ * // Using with to_tsquery
+ * Article.findAll({
+ *   where: {
+ *     [toTsvector('title')]: { $tsquery: 'database' }
+ *   }
+ * })
+ * // SQL: WHERE to_tsvector('english', title) @@ to_tsquery('english', 'database')
+ * ```
+ */
+export declare function toTsvector(column: string, config?: string): {
+    $tsvector: {
+        column: string;
+        config: string;
+    };
+};
+/**
+ * Create a PostgreSQL to_tsquery expression
+ * SQL: to_tsquery(config, query)
+ *
+ * @example
+ * ```typescript
+ * import { toTsquery } from 'orm';
+ * Article.findAll({
+ *   where: {
+ *     body: { [toTsquery('database')]: true }
+ *   }
+ * })
+ * // SQL: WHERE body @@ to_tsquery('english', 'database')
+ * ```
+ */
+export declare function toTsquery(query: string, config?: string): {
+    $tsquery: {
+        query: string;
+        config: string;
+    };
+};
+/**
+ * Create a PostgreSQL plainto_tsquery expression (for phrase searching)
+ * SQL: plainto_tsquery(config, query)
+ *
+ * @example
+ * ```typescript
+ * import { plainToTsquery } from 'orm';
+ * Article.findAll({
+ *   where: {
+ *     body: { [plainToTsquery('database systems')]: true }
+ *   }
+ * })
+ * // SQL: WHERE body @@ plainto_tsquery('english', 'database systems')
+ * ```
+ */
+export declare function plainToTsquery(query: string, config?: string): {
+    $plainTsquery: {
+        query: string;
+        config: string;
+    };
+};
+/**
+ * Create a PostgreSQL phraseto_tsquery expression (for exact phrase matching)
+ * SQL: phraseto_tsquery(config, query)
+ *
+ * @example
+ * ```typescript
+ * import { phraseToTsquery } from 'orm';
+ * Article.findAll({
+ *   where: {
+ *     body: { [phraseToTsquery('database')]: true }
+ *   }
+ * })
+ * // SQL: WHERE body @@ phraseto_tsquery('english', 'database')
+ * ```
+ */
+export declare function phraseToTsquery(query: string, config?: string): {
+    $phraseTsquery: {
+        query: string;
+        config: string;
+    };
+};
+export default Op;
+/**
+ * Helper to create CONTAINED condition (for JSON/arrays)
+ * Checks if the JSON column is contained in the specified value
+ */
+export declare function contained(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create JSON key access condition
+ * Access a specific key in a JSON column for comparison
+ */
+export declare function jsonKey(column: string, path: string, value?: any): Record<string, any>;
+/**
+ * Helper to create JSON path extraction condition
+ * Used for querying JSON/JSONB columns with path-based extraction
+ *
+ * @example
+ * ```typescript
+ * // Simple JSON path query
+ * User.findAll({ where: json('settings', 'theme', 'dark') })
+ * // SQL: WHERE json_extract(settings, '$.theme') = 'dark'
+ *
+ * // Nested path
+ * User.findAll({ where: json('data', 'address.city', 'NYC') })
+ * // SQL: WHERE json_extract(data, '$.address.city') = 'NYC'
+ *
+ * // With dot notation path (auto-prepended with $)
+ * User.findAll({ where: json('preferences', 'notifications.enabled', true) })
+ * // SQL: WHERE json_extract(preferences, '$.notifications.enabled') = true
+ *
+ * // Using with Op.json symbol directly in object
+ * User.findAll({
+ *   where: {
+ *     settings: { [Op.json('theme')]: 'dark' }
+ *   }
+ * })
+ * // SQL: WHERE json_extract(settings, '$.theme') = 'dark'
+ * ```
+ */
+export declare function json(column: string, path: string, value?: any): Record<string, any>;
+/**
+ * Helper to create JSON contains condition
+ * Checks if JSON column contains a specific value or object
+ *
+ * @example
+ * ```typescript
+ * // Find users where preferences contains { theme: 'dark' }
+ * User.findAll({ where: { preferences: { [Op.jsonContains]: { theme: 'dark' } } } })
+ * // SQL (PostgreSQL): WHERE preferences @> '{"theme":"dark"}'
+ * // SQL (MySQL): WHERE JSON_CONTAINS(preferences, '{"theme":"dark"}')
+ *
+ * // Check if JSON array contains a value
+ * User.findAll({ where: { tags: { [Op.jsonContains]: 'admin' } } })
+ * ```
+ */
+export declare function jsonContains(column: string, value: any): Record<string, any>;
+/**
+ * Helper to create JSON has key condition
+ * Checks if JSON column has a specific key
+ *
+ * @example
+ * ```typescript
+ * // Find users where data column has 'role' key
+ * User.findAll({ where: { data: { [Op.jsonHasKey]: 'role' } } })
+ * // SQL (PostgreSQL): WHERE data ? 'role'
+ * // SQL (MySQL): WHERE JSON_CONTAINS_PATH(data, 'one', '$.role')
+ *
+ * // Nested key
+ * User.findAll({ where: { data: { [Op.jsonHasKey]: 'settings.theme' } } })
+ * ```
+ */
+export declare function jsonHasKey(column: string, key: string): Record<string, any>;
+/**
+ * Helper to create JSONB concatenation condition
+ * Concatenates two JSONB values (PostgreSQL || operator)
+ *
+ * @example
+ * ```typescript
+ * // Concatenate JSONB values
+ * User.findAll({ where: jsonConcat('data', { key: 'value' }) })
+ * // SQL: WHERE data || '{"key": "value"}'
+ * ```
+ */
+export declare function jsonConcat(column: string, jsonValue: object | any[]): Record<string, any>;
+/**
+ * Helper to create JSONB delete key condition
+ * Deletes a key from JSONB object (PostgreSQL - operator)
+ *
+ * @example
+ * ```typescript
+ * // Delete key from JSONB
+ * User.findAll({ where: jsonDelete('data', 'key') })
+ * // SQL: WHERE data - 'key'
+ * ```
+ */
+export declare function jsonDelete(column: string, key: string): Record<string, any>;
+/**
+ * Helper to create JSONB delete by path condition
+ * Deletes a key from JSONB by path (PostgreSQL #- operator)
+ *
+ * @example
+ * ```typescript
+ * // Delete by path
+ * User.findAll({ where: jsonDeletePath('data', ['a', 'b']) })
+ * // SQL: WHERE data #- '{a, b}'
+ * ```
+ */
+export declare function jsonDeletePath(column: string, path: string | string[]): Record<string, any>;
+/**
+ * Helper to create JSON path exists condition
+ * Checks if a JSON path exists and returns boolean (PostgreSQL @? operator)
+ *
+ * @example
+ * ```typescript
+ * // Check if path exists
+ * User.findAll({ where: jsonPathExists('data', '$.key') })
+ * // SQL: WHERE data @? '$.key'
+ * ```
+ */
+export declare function jsonPathExists(column: string, path: string): Record<string, any>;
+/**
+ * Helper to create JSON path query condition
+ * Evaluates JSON path and returns result (PostgreSQL @@ operator)
+ *
+ * @example
+ * ```typescript
+ * // Query JSON path
+ * User.findAll({ where: jsonPathQuery('data', '$.key') })
+ * // SQL: WHERE data @@ '$.key'
+ * ```
+ */
+export declare function jsonPathQuery(column: string, path: string): Record<string, any>;
+/**
+ * Represents a SQL function expression
+ * Used in attributes to create aggregate queries
+ *
+ * @example
+ * ```typescript
+ * // Count all records
+ * User.findAll({
+ *   attributes: [[fn('COUNT', col('id')), 'count']]
+ * })
+ *
+ * // Count distinct values
+ * User.findAll({
+ *   attributes: [[fn('COUNT', fn('DISTINCT', col('role'))), 'uniqueRoles']]
+ * })
+ *
+ * // Sum with group by
+ * User.findAll({
+ *   attributes: ['role', [fn('SUM', col('score')), 'totalScore']],
+ *   group: ['role']
+ * })
+ * ```
+ */
+export interface FnExpression {
+    __type: 'fn';
+    fn: string;
+    args: any[];
+}
+/**
+ * Type for extract parts
+ */
+export type ExtractPart = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second';
+/**
+ * Represents a CAST expression for type casting
+ * SQL: CAST(value AS type)
+ *
+ * @example
+ * ```typescript
+ * // CAST('2023-01-01' AS DATE)
+ * cast('2023-01-01', 'DATE')
+ *
+ * // CAST(column AS INTEGER)
+ * cast(col('amount'), 'INTEGER')
+ * ```
+ */
+export interface CastExpression {
+    __type: 'cast';
+    value: any;
+    type: string;
+}
+/**
+ * Represents an EXTRACT expression for extracting date parts
+ * SQL: EXTRACT(part FROM field)
+ *
+ * @example
+ * ```typescript
+ * // EXTRACT(YEAR FROM createdAt)
+ * extract('createdAt', 'year')
+ *
+ * // EXTRACT(MONTH FROM order_date)
+ * extract(col('order_date'), 'month')
+ * ```
+ */
+export interface ExtractExpression {
+    __type: 'extract';
+    field: any;
+    part: ExtractPart;
+}
+/**
+ * Represents a CONVERT expression for type conversion (MySQL)
+ * SQL: CONVERT(value, type) or CONVERT(value USING charset)
+ *
+ * @example
+ * ```typescript
+ * // CONVERT(value, type)
+ * conv(value, 'INTEGER', 'UNSIGNED')
+ *
+ * // CONVERT(value USING utf8mb4)
+ * conv(value, null, 'utf8mb4')
+ * ```
+ */
+export interface ConvExpression {
+    __type: 'conv';
+    value: any;
+    from?: string | null;
+    to: string;
+}
+/**
+ * Create a SQL function expression
+ * @param fnName - The SQL function name (e.g., 'COUNT', 'SUM', 'AVG', 'MAX', 'MIN')
+ * @param args - Function arguments (can include col() expressions)
+ */
+export declare function fn(fnName: string, ...args: any[]): FnExpression;
+/**
+ * Represents a column reference expression
+ */
+export interface ColExpression {
+    __type: 'col';
+    col: string;
+}
+/**
+ * Create a column reference for use in SQL functions
+ * @param colName - The column name (supports 'table.column' format)
+ *
+ * @example
+ * ```typescript
+ * col('id')           // -> "id"
+ * col('user.id')     // -> "user.id"
+ * col('users.name')  // -> "users.name"
+ * ```
+ */
+export declare function col(colName: string): ColExpression;
+/**
+ * Represents a literal SQL expression
+ */
+export interface LiteralExpression {
+    __type: 'literal';
+    sql: string;
+    /**
+     * Values substituted into the `?` placeholders in `sql`.
+     *
+     * Without this the only escape hatch for an expression the typed API can't
+     * build was string concatenation, which is an injection surface precisely
+     * where user input is most likely to appear. Prefer:
+     *
+     *   literalExpr('price * ? + ?', [rate, fee])
+     *
+     * over building the string yourself. Values are escaped by the dialect.
+     */
+    bindings?: unknown[];
+}
+/**
+ * Substitute a literal expression's bindings into its `?` placeholders.
+ *
+ * Dialects call this with their own `escape` so values are quoted according to
+ * the target database's rules. Exported so every dialect shares one
+ * implementation rather than re-deriving the placeholder scan.
+ */
+export declare function expandLiteralBindings(expr: {
+    sql: string;
+    bindings?: unknown[];
+}, escape: (value: unknown) => string): string;
+/**
+ * Create a literal SQL expression (inserted as-is into the query)
+ * Returns { $literal: value } format for raw SQL expressions
+ * Use with caution - this can lead to SQL injection if user input is included
+ *
+ * @example
+ * ```typescript
+ * // Use with update to set current timestamp
+ * User.update({ lastLogin: literal('NOW()') }, { where: { ... } })
+ *
+ * // Use in where clause to compare with current time
+ * User.findAll({
+ *   where: {
+ *     createdAt: { [Op.lt]: literal('NOW()') }
+ *   }
+ * })
+ *
+ * // Compare column to a literal value
+ * User.findAll({
+ *   where: {
+ *     updatedAt: { [Op.gt]: literal('createdAt') }
+ *   }
+ * })
+ * ```
+ */
+export declare function literal(value: string): {
+    $literal: string;
+};
+/**
+ * Create a literal SQL expression (inserted as-is into the query)
+ * Returns { __type: 'literal', sql: string } format
+ * Use with caution - this can lead to SQL injection if user input is included
+ *
+ * @example
+ * ```typescript
+ * literalExpr('COUNT(*)')  // -> { __type: 'literal', sql: 'COUNT(*)' }
+ * literalExpr('NOW()')    // -> { __type: 'literal', sql: 'NOW()' }
+ * literalExpr('1 + 1')    // -> { __type: 'literal', sql: '1 + 1' }
+ * ```
+ */
+export declare function literalExpr(sql: string, bindings?: unknown[]): LiteralExpression;
+/**
+ * Check if a value is a function expression
+ */
+export declare function isFnExpression(value: any): value is FnExpression;
+/**
+ * Check if a value is a column expression
+ */
+export declare function isColExpression(value: any): value is ColExpression;
+/**
+ * Check if a value is a literal expression
+ * Supports both { $literal: value } and { __type: 'literal', sql } formats
+ */
+export declare function isLiteralExpression(value: any): value is LiteralExpression | {
+    $literal: string;
+};
+/**
+ * Check if a value is a raw SQL literal ({ $literal: value } format)
+ */
+export declare function isRawLiteral(value: any): value is {
+    $literal: string;
+};
+/**
+ * Check if a value is a CAST expression
+ */
+export declare function isCastExpression(value: any): value is CastExpression;
+/**
+ * Check if a value is an EXTRACT expression
+ */
+export declare function isExtractExpression(value: any): value is ExtractExpression;
+/**
+ * Check if a value is a CONVERT expression
+ */
+export declare function isConvExpression(value: any): value is ConvExpression;
+/**
+ * Create a CAST expression for type casting
+ * SQL: CAST(value AS type)
+ *
+ * @example
+ * ```typescript
+ * // CAST('2023-01-01' AS DATE)
+ * User.findAll({
+ *   attributes: [[cast('2023-01-01', 'DATE'), 'dateOnly']]
+ * })
+ *
+ * // CAST(column AS INTEGER)
+ * User.findAll({
+ *   attributes: [[cast(col('amount'), 'INTEGER'), 'amountInt']]
+ * })
+ *
+ * // CAST with different types
+ * cast(col('price'), 'DECIMAL(10,2)')
+ * cast(col('text'), 'CHAR(100)')
+ * cast(col('json_data'), 'JSON')
+ * ```
+ */
+export declare function cast(value: any, type: string): CastExpression;
+/**
+ * Type coercion helpers for common SQL types
+ * Provides convenience methods for casting values to specific types
+ *
+ * @example
+ * ```typescript
+ * import { Cast, col } from 'orm';
+ *
+ * // Cast.string - CAST(value AS VARCHAR)
+ * User.findAll({
+ *   attributes: [[Cast.string(col('age')), 'ageStr']]
+ * })
+ *
+ * // Cast.integer - CAST(value AS INTEGER)
+ * User.findAll({
+ *   attributes: [[Cast.integer(col('price')), 'priceInt']]
+ * })
+ *
+ * // Cast.date - CAST(value AS DATE)
+ * User.findAll({
+ *   attributes: [[Cast.date(col('timestamp')), 'dateOnly']]
+ * })
+ *
+ * // Cast.boolean - CAST(value AS BOOLEAN)
+ * User.findAll({
+ *   attributes: [[Cast.boolean(col('flag')), 'flagBool']]
+ * })
+ *
+ * // Cast.float - CAST(value AS FLOAT)
+ * User.findAll({
+ *   attributes: [[Cast.float(col('amount')), 'amountFloat']]
+ * })
+ *
+ * // Cast.decimal - CAST(value AS DECIMAL)
+ * User.findAll({
+ *   attributes: [[Cast.decimal(col('price'), 10, 2), 'priceDecimal']]
+ * })
+ *
+ * // Cast.json - CAST(value AS JSON)
+ * User.findAll({
+ *   attributes: [[Cast.json(col('data')), 'dataJson']]
+ * })
+ * ```
+ */
+export declare const Cast: {
+    /**
+     * Cast to VARCHAR/string type
+     */
+    readonly string: (value: any) => CastExpression;
+    /**
+     * Cast to CHAR type
+     */
+    readonly char: (value: any, length?: number) => CastExpression;
+    /**
+     * Cast to TEXT type
+     */
+    readonly text: (value: any) => CastExpression;
+    /**
+     * Cast to INTEGER type
+     */
+    readonly integer: (value: any) => CastExpression;
+    /**
+     * Cast to BIGINT type
+     */
+    readonly bigint: (value: any) => CastExpression;
+    /**
+     * Cast to FLOAT type
+     */
+    readonly float: (value: any) => CastExpression;
+    /**
+     * Cast to DOUBLE type
+     */
+    readonly double: (value: any) => CastExpression;
+    /**
+     * Cast to DECIMAL type
+     */
+    readonly decimal: (value: any, precision?: number, scale?: number) => CastExpression;
+    /**
+     * Cast to BOOLEAN type
+     */
+    readonly boolean: (value: any) => CastExpression;
+    /**
+     * Cast to DATE type
+     */
+    readonly date: (value: any) => CastExpression;
+    /**
+     * Cast to DATETIME type
+     */
+    readonly datetime: (value: any) => CastExpression;
+    /**
+     * Cast to TIME type
+     */
+    readonly time: (value: any) => CastExpression;
+    /**
+     * Cast to TIMESTAMP type
+     */
+    readonly timestamp: (value: any) => CastExpression;
+    /**
+     * Cast to JSON type
+     */
+    readonly json: (value: any) => CastExpression;
+    /**
+     * Cast to BLOB type
+     */
+    readonly blob: (value: any) => CastExpression;
+    /**
+     * Cast to UUID type
+     */
+    readonly uuid: (value: any) => CastExpression;
+    /**
+     * Cast to specific type
+     */
+    readonly valueOf: (value: any, type: string) => CastExpression;
+};
+/**
+ * Type for Cast object
+ */
+export type CastType = typeof Cast;
+/**
+ * Create an EXTRACT expression for extracting date parts
+ * SQL: EXTRACT(part FROM field)
+ *
+ * @example
+ * ```typescript
+ * // EXTRACT(YEAR FROM createdAt)
+ * User.findAll({
+ *   attributes: [[extract('createdAt', 'year'), 'year']]
+ * })
+ *
+ * // EXTRACT(MONTH FROM order_date)
+ * User.findAll({
+ *   attributes: [[extract(col('order_date'), 'month'), 'month']]
+ * })
+ *
+ * // Use in WHERE clause
+ * User.findAll({
+ *   where: {
+ *     [extract('createdAt', 'year')]: 2024
+ *   }
+ * })
+ *
+ * // Available parts: year, month, day, hour, minute, second
+ * ```
+ */
+export declare function extract(field: any, part: ExtractPart): ExtractExpression;
+/**
+ * Create a CONVERT expression for type conversion
+ * SQL: CONVERT(value, type) for MySQL, or CAST for other dialects
+ *
+ * @example
+ * ```typescript
+ * // CONVERT(value, to_type)
+ * User.findAll({
+ *   attributes: [[conv(col('value'), null, 'CHAR'), 'strValue']]
+ * })
+ *
+ * // CONVERT with charset (MySQL)
+ * conv(col('name'), null, 'CHAR(255) CHARACTER SET utf8mb4')
+ *
+ * // Base type conversion
+ * conv(col('text'), 'CHAR', 'INTEGER')
+ * ```
+ */
+export declare function conv(value: any, from: string | null | undefined, to: string): ConvExpression;
+/**
+ * Create a SUM aggregate function expression
+ * SQL: SUM(column)
+ *
+ * @example
+ * ```typescript
+ * // Sum all scores
+ * User.findAll({
+ *   attributes: [[SUM(col('score')), 'totalScore']]
+ * })
+ *
+ * // Sum with condition
+ * User.findAll({
+ *   attributes: [[SUM(col('amount')), 'totalAmount']],
+ *   where: { status: 'completed' }
+ * })
+ * ```
+ */
+export declare function SUM(column: any): FnExpression;
+/**
+ * Create an AVG aggregate function expression
+ * SQL: AVG(column)
+ *
+ * @example
+ * ```typescript
+ * // Average score
+ * User.findAll({
+ *   attributes: [[AVG(col('score')), 'averageScore']]
+ * })
+ *
+ * // Average with group by
+ * User.findAll({
+ *   attributes: ['department', [AVG(col('salary')), 'avgSalary']],
+ *   group: ['department']
+ * })
+ * ```
+ */
+export declare function AVG(column: any): FnExpression;
+/**
+ * Create a COUNT aggregate function expression
+ * SQL: COUNT(column)
+ *
+ * @example
+ * ```typescript
+ * // Count all records
+ * User.findAll({
+ *   attributes: [[COUNT(col('id')), 'totalCount']]
+ * })
+ *
+ * // Count distinct values
+ * User.findAll({
+ *   attributes: [[COUNT(col('email')), 'uniqueEmails']]
+ * })
+ *
+ * // Count with DISTINCT
+ * User.findAll({
+ *   attributes: [[COUNT(fn('DISTINCT', col('role'))), 'uniqueRoles']]
+ * })
+ * ```
+ */
+export declare function COUNT(column?: any): FnExpression;
+/**
+ * Create a MAX aggregate function expression
+ * SQL: MAX(column)
+ *
+ * @example
+ * ```typescript
+ * // Maximum score
+ * User.findAll({
+ *   attributes: [[MAX(col('score')), 'highestScore']]
+ * })
+ *
+ * // Latest date
+ * User.findAll({
+ *   attributes: [[MAX(col('createdAt')), 'latestDate']]
+ * })
+ * ```
+ */
+export declare function MAX(column: any): FnExpression;
+/**
+ * Create a MIN aggregate function expression
+ * SQL: MIN(column)
+ *
+ * @example
+ * ```typescript
+ * // Minimum score
+ * User.findAll({
+ *   attributes: [[MIN(col('score')), 'lowestScore']]
+ * })
+ *
+ * // Earliest date
+ * User.findAll({
+ *   attributes: [[MIN(col('createdAt')), 'earliestDate']]
+ * })
+ * ```
+ */
+export declare function MIN(column: any): FnExpression;