ts-prorm-orm 1.1.0 → 1.2.0

package/dist/models/model.d.ts

@@ -0,0 +1,820 @@
+/**
+ * Model class for the ORM
+ * Represents a database table with CRUD operations, validations, and hooks
+ *
+ * Usage examples:
+ *
+ * // 1. Define methods in model options
+ * const User = prorm.define('User', {
+ *   firstName: Prorm.STRING,
+ *   lastName: Prorm.STRING,
+ * }, {
+ *   classMethods: {
+ *     findByEmail: function(email: string) {
+ *       return this.findOne({ where: { email } });
+ *     }
+ *   },
+ *   instanceMethods: {
+ *     getFullName: function() {
+ *       return this.firstName + ' ' + this.lastName;
+ *     }
+ *   }
+ * });
+ *
+ * // 2. Add methods after model definition
+ * User.addMethod('classMethod', 'findByUsername', function(username: string) {
+ *   return this.findOne({ where: { username } });
+ * });
+ *
+ * User.addMethod('instanceMethod', 'getFullName', function() {
+ *   return this.get('firstName') + ' ' + this.get('lastName');
+ * });
+ *
+ * // Usage:
+ * const user = await User.findByEmail('test@example.com');
+ * console.log(user.getFullName()); // Instance method call
+ * const userByName = await User.findByUsername('john'); // Class method call
+ */
+import { ModelStatic, ModelOptions, AttributeOptions, FindOptions, CreateOptions, UpdateOptions, DestroyOptions, SaveOptions, Transaction, HookHandler, ValidationErrorItem, BulkCreateOptions, CountOptions, UpsertOptions, IncrementDecrementOptions, FindOrCreateOptions, ReloadOptions } from '../types';
+import { Prorm } from '../prorm';
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationErrorItem[];
+}
+declare class ModelValidator {
+    private validations;
+    private modelName;
+    constructor(validations: Record<string, any>, modelName: string);
+    validate(data: Record<string, any>): ValidationResult;
+    private validateField;
+}
+declare class ModelInstance<T = any> {
+    isNewRecord: boolean;
+    isDirty: boolean;
+    primaryKey?: string;
+    transaction?: Transaction;
+    _previousDataValues: Record<string, any>;
+    dataValues: Record<string, any>;
+    private model;
+    private prorm;
+    private _changed;
+    private _previousChanged;
+    private _includes;
+    private _validationErrors;
+    private _validationCache;
+    private _self;
+    constructor(model: ModelStatic<any>, prorm: Prorm, values?: Record<string, any>, options?: {
+        isNewRecord?: boolean;
+    });
+    /**
+     * Create a Proxy-based instance for backward compatibility
+     * Allows accessing fields directly like instance.fieldName
+     */
+    private static createProxyInstance;
+    private castValuesFromDatabase;
+    private castValuesForDatabase;
+    private getDefaultValues;
+    private updatePrimaryKey;
+    /**
+     * Get the raw value from the instance's dataValues
+     * Returns the value directly from the dataValues object without any processing
+     *
+     * @param key - The attribute name to retrieve
+     * @returns The raw value stored in dataValues, or undefined if not set
+     *
+     * @example
+     * // Get raw value
+     * const email = user.getDataValue('email');
+     */
+    getDataValue(key: string): any;
+    /**
+     * Set a value directly in dataValues, bypassing accessors
+     * Sets the value without calling any setters and triggers change tracking
+     *
+     * @param key - The attribute name to set
+     * @param value - The value to set
+     *
+     * @example
+     * // Set raw value directly
+     * user.setDataValue('email', 'new@example.com');
+     */
+    setDataValue(key: string, value: any): void;
+    /**
+     * Get an attribute value with accessor support
+     * Handles virtual fields by calling their getter functions
+     *
+     * @param key - The attribute name to retrieve
+     * @returns The attribute value, or undefined if not set
+     *
+     * @example
+     * // Get attribute value
+     * const name = user.get('firstName');
+     *
+     * @example
+     * // Get virtual field value (calls the virtual getter)
+     * const fullName = user.get('fullName');
+     */
+    get(key: string): any;
+    /**
+     * Get a value at a JSON path within a JSON/JSONB column
+     * @example
+     * ```typescript
+     * // Get nested value from JSON column
+     * user.getJsonPath('settings.theme')
+     * // Returns: 'dark'
+     *
+     * // For data column like: { address: { city: 'NYC' } }
+     * user.getJsonPath('data.address.city')
+     * // Returns: 'NYC'
+     * ```
+     */
+    getJsonPath(path: string): any;
+    /**
+     * Get the raw value without any processing
+     * Returns the value directly from dataValues without virtual getter or JSON parsing
+     *
+     * @param key - The attribute name to retrieve
+     * @returns The raw value from dataValues, or undefined if not set
+     *
+     * @example
+     * // Get raw value without processing
+     * const rawEmail = user.getRaw('email');
+     */
+    getRaw(key: string): any;
+    /**
+     * Set an attribute value with mutator support
+     * Handles virtual field setters and auto-parses JSON strings
+     *
+     * @param key - The attribute name to set
+     * @param value - The value to set
+     * @returns The instance for chaining
+     *
+     * @example
+     * // Set a single attribute
+     * user.set('email', 'new@example.com');
+     *
+     * @example
+     * // Chain multiple sets
+     * user.set('firstName', 'John').set('lastName', 'Doe');
+     */
+    set(key: string, value: any): ModelInstance<T>;
+    /**
+     * Set multiple attribute values at once
+     * Iterates through the provided key-value pairs and sets each attribute
+     *
+     * @param values - An object containing attribute names and their values
+     * @returns The instance for chaining
+     *
+     * @example
+     * // Set multiple attributes
+     * user.setAttributes({
+     *   firstName: 'John',
+     *   lastName: 'Doe',
+     *   email: 'john@example.com'
+     * });
+     */
+    setAttributes(values: Record<string, any>): ModelInstance<T>;
+    /**
+     * Check if a field has changed since last save
+     * Returns a boolean if key is provided, or array of all changed field names otherwise
+     *
+     * @param key - Optional attribute name to check specific field
+     * @returns True if the field has changed, or array of changed field names if no key provided
+     *
+     * @example
+     * // Check specific field
+     * const hasChanged = user.changed('email');
+     *
+     * @example
+     * // Get all changed fields
+     * const changedFields = user.changed();
+     */
+    changed(key?: string): boolean | string[];
+    /**
+     * Get the previous value of a field before changes
+     * Returns the value from before the most recent change, or all previous values if no key provided
+     *
+     * @param key - Optional attribute name to get previous value
+     * @returns The previous value, or an object of all previous values if no key provided
+     *
+     * @example
+     * // Get previous value of specific field
+     * const oldEmail = user.previous('email');
+     *
+     * @example
+     * // Get all previous values
+     * const allPrevious = user.previous();
+     */
+    previous(key?: string): any;
+    /**
+     * Check if a specific field has changed
+     * @param key - The field name to check
+     * @returns true if the field has changed, false otherwise
+     */
+    isChanged(key: string): boolean;
+    /**
+     * Get the previous value of a specific field (including recent changes)
+     * @param key - The field name
+     * @returns The previous value or undefined if not changed
+     */
+    getPreviousValue(key: string): any;
+    /**
+     * Get all changed fields with their new and old values
+     * @returns Object with changed field names as keys and {previous, current} as values
+     */
+    getChangedFields(): Record<string, {
+        previous: any;
+        current: any;
+    }>;
+    /**
+     * Check if the record has any modifications
+     * @returns true if any field has been modified
+     */
+    isDirtyRecord(): boolean;
+    /**
+     * Check if the record or a specific field has changes
+     * @param key - Optional field name to check specific field
+     * @returns true if the record has any changes, or if the specific field has changed
+     */
+    hasChanges(key?: string): boolean;
+    /**
+     * Validate the instance and return boolean result synchronously
+     * Uses caching to improve performance on repeated calls
+     * @returns true if validation passes, false if there are errors
+     *
+     * @example
+     * if (user.isValid()) {
+     *   console.log('Valid!');
+     * }
+     */
+    isValid(): boolean;
+    /**
+     * Get only the changed fields with their new (current) values
+     * @returns Object with field names as keys and new values
+     */
+    getChanges(): Record<string, any>;
+    /**
+     * Reset all change tracking (mark as not dirty)
+     * Typically called after save
+     */
+    resetChangeTracking(): void;
+    /**
+     * Get a snapshot of the current values
+     * @returns Copy of dataValues
+     */
+    getSnapshot(): Record<string, any>;
+    /**
+     * Restore values from a snapshot
+     * @param snapshot - The snapshot to restore from
+     */
+    restoreFromSnapshot(snapshot: Record<string, any>): void;
+    /**
+     * Get the diff between current and previous values
+     * @returns Object with all differences
+     */
+    getDiff(): Record<string, {
+        from: any;
+        to: any;
+    }>;
+    /**
+     * Reset all changes and restore original values
+     * @returns void
+     *
+     * @example
+     * user.name = 'New Name';
+     * user.reset(); // Reverts to original values
+     */
+    reset(): void;
+    getInclude(alias: string): ModelInstance[] | undefined;
+    setInclude(alias: string, instances: ModelInstance[]): void;
+    toJSON(options?: {
+        includeAll?: boolean;
+        exclude?: string[];
+        include?: string[];
+        /** Only include these specific attributes */
+        attributes?: string[];
+        /** When true, bypass all transformations (no virtual fields, no hidden filtering) */
+        raw?: boolean;
+        /** Clone the result before returning (prevents mutation) */
+        clone?: boolean;
+        /** Handle duplicate column names from joined tables */
+        duplicateColumns?: Record<string, string>;
+        /** Map of table aliases to their model for resolving duplicate columns */
+        includedModels?: Map<string, ModelStatic<any>>;
+    }): Record<string, any>;
+    private buildJSONResult;
+    private getAttributesToInclude;
+    private invokeToJSONHook;
+    /**
+     * Validate the instance
+     *
+     * @param options - Can be:
+     *   - undefined or null: validate all fields
+     *   - string[]: validate specific fields (e.g., ['email', 'name'])
+     *   - object: { fields?: string[], hooks?: boolean }
+     *     - fields: specific fields to validate
+     *     - hooks: whether to run beforeValidate/afterValidate hooks (default: false)
+     *
+     * @returns Promise<{ valid: boolean, errors: ValidationErrorItem[] }>
+     *
+     * @example
+     * // Validate all fields
+     * const result = await user.validate();
+     * if (!result.valid) console.log(result.errors);
+     *
+     * @example
+     * // Validate specific fields
+     * const result = await user.validate(['email', 'name']);
+     *
+     * @example
+     * // Validate with hooks
+     * const result = await user.validate({ hooks: true });
+     */
+    validate(options?: string[] | {
+        fields?: string[];
+        hooks?: boolean;
+    }): Promise<{
+        valid: boolean;
+        errors: ValidationErrorItem[];
+    }>;
+    /**
+     * Validate synchronously
+     *
+     * @param options - Optional field names to validate or options object
+     * @returns ValidationResult - Object with valid status and errors
+     *
+     * @example
+     * const result = user.validateSync();
+     *
+     * @example
+     * // Validate specific fields
+     * const result = user.validateSync(['email', 'name']);
+     */
+    validateSync(options?: string[] | {
+        fields?: string[];
+    }): {
+        valid: boolean;
+        errors: ValidationErrorItem[];
+    };
+    /**
+     * Validate a specific field on the instance
+     *
+     * @param field - The field name to validate
+     * @returns ValidationErrorItem[] - Array of validation errors (empty if valid)
+     *
+     * @example
+     * const errors = user.validateField('email');
+     * if (errors.length > 0) console.log(errors[0].message);
+     */
+    validateField(field: string): ValidationErrorItem[];
+    isValidSync(): boolean;
+    getValidationErrors(): Promise<ValidationErrorItem[]>;
+    save(options?: SaveOptions): Promise<this>;
+    /**
+     * Reload the instance from the database.
+     * This fetches the current data from the database and updates the instance,
+     * overwriting any local changes.
+     *
+     * @param options - Reload options
+     * @returns Promise resolving to this instance
+     *
+     * @example
+     * const user = await User.findByPk(1);
+     * user.name = 'New Name';
+     * await user.reload(); // Reloads from DB, overwrites local changes
+     *
+     * @example
+     * // Reload with specific attributes
+     * await user.reload({ attributes: ['id', 'name', 'email'] });
+     */
+    reload(options?: ReloadOptions): Promise<this>;
+    destroy(options?: DestroyOptions): Promise<void>;
+    restore(options?: any): Promise<void>;
+    /**
+     * Reload the instance from the database.
+     * Re-fetches the record using the primary key and updates dataValues with fresh data.
+     * Resets all changed fields.
+     *
+     * @param options - Options for reload
+     * @param options.attributes - Optional array of attribute names to reload.
+     *                            If not provided, reloads all attributes.
+     * @param options.transaction - Optional transaction to use
+     * @param options.logging - Optional custom logging function
+     * @param options hooks - Whether to run hooks (default: true)
+     *
+     * @returns The reloaded instance
+     *
+     * @example
+     * // Reload only specific attributes
+     * await user.reload({ attributes: ['id', 'name'] });
+     */
+    /**
+     * Increment one or more numeric fields on the instance.
+     *
+     * @param fields - The field(s) to increment. Can be:
+     *   - A single field name: 'age'
+     *   - An array of field names: ['age', 'score']
+     *   - An object with field names as keys and increment values: { age: 1, score: 5 }
+     * @param options - Options including:
+     *   - by: The amount to increment by (default: 1)
+     *   - transaction: Transaction to use
+     *   - logging: Custom logging function
+     *   - hooks: Whether to run hooks
+     *
+     * @returns The updated instance
+     *
+     * @example
+     * // Increment a single field by 1 (default)
+     * await user.increment('age');
+     *
+     * @example
+     * // Increment a field by a specific amount
+     * await user.increment('age', { by: 5 });
+     *
+     * @example
+     * // Increment multiple fields by 1 each
+     * await user.increment(['age', 'score']);
+     *
+     * @example
+     * // Increment multiple fields by different amounts
+     * await user.increment({ age: 1, score: 5 });
+     *
+     * @example
+     * // Increment with transaction
+     * await user.increment('balance', { by: 100, transaction });
+     */
+    increment(fields: string | string[] | Record<string, number>, options?: IncrementDecrementOptions): Promise<this>;
+    /**
+     * Decrement one or more numeric fields on the instance.
+     *
+     * @param fields - The field(s) to decrement. Can be:
+     *   - A single field name: 'age'
+     *   - An array of field names: ['age', 'score']
+     *   - An object with field names as keys and decrement values: { age: 1, score: 5 }
+     * @param options - Options including:
+     *   - by: The amount to decrement by (default: 1)
+     *   - transaction: Transaction to use
+     *   - logging: Custom logging function
+     *   - hooks: Whether to run hooks
+     *
+     * @returns The updated instance
+     *
+     * @example
+     * // Decrement a single field by 1 (default)
+     * await user.decrement('age');
+     *
+     * @example
+     * // Decrement a field by a specific amount
+     * await user.decrement('balance', { by: 100 });
+     *
+     * @example
+     * // Decrement multiple fields by 1 each
+     * await user.decrement(['age', 'score']);
+     *
+     * @example
+     * // Decrement multiple fields by different amounts
+     * await user.decrement({ age: 1, score: 5 });
+     *
+     * @example
+     * // Decrement with transaction
+     * await user.decrement('balance', { by: 50, transaction });
+     */
+    decrement(fields: string | string[] | Record<string, number>, options?: IncrementDecrementOptions): Promise<this>;
+    /**
+     * Internal method to handle increment/decrement operations
+     */
+    private _incrementDecrement;
+    /**
+     * Run a raw query from instance context
+     * Uses the model's connection for executing custom queries
+     *
+     * @param sql - SQL query to execute
+     * @param options - Query options including replacements, raw mode, and transaction
+     * @returns Query result
+     *
+     * @example
+     * // Run a raw query on an instance
+     * const user = await User.findById(1);
+     * const result = await user.$query('SELECT * FROM orders WHERE user_id = ?', {
+     *   replacements: [user.id]
+     * });
+     *
+     * @example
+     * // Run raw query with model mapping
+     * const orders = await user.$query('SELECT * FROM orders WHERE user_id = ?', {
+     *   replacements: [user.id],
+     *   model: Order
+     * });
+     */
+    $query(sql: string, options?: {
+        replacements?: Record<string, unknown> | unknown[];
+        raw?: boolean;
+        model?: ModelStatic<any>;
+        transaction?: Transaction;
+    }): Promise<any>;
+    private runHook;
+    /**
+     * Get a related instance for a hasOne or belongsTo association
+     *
+     * @param associationName - The name of the association (e.g., 'profile', 'address')
+     * @param options - Find options to pass to the query
+     * @returns The associated instance or null
+     *
+     * @example
+     * const profile = await user.getRelated('profile');
+     * const address = await user.getRelated('address', { where: { active: true } });
+     */
+    getRelated(associationName: string, options?: FindOptions): Promise<ModelInstance<any> | null>;
+    /**
+     * Set a related instance for a hasOne or belongsTo association
+     *
+     * @param associationName - The name of the association (e.g., 'profile', 'address')
+     * @param value - The instance to set, null to remove association, or a foreign key value
+     * @param options - Options including save: false to skip saving
+     * @returns The updated instance
+     *
+     * @example
+     * await user.setRelated('profile', newProfile);
+     * await user.setRelated('address', null); // Remove association
+     * await user.setRelated('address', 5); // Set by foreign key value
+     */
+    setRelated(associationName: string, value: ModelInstance<any> | null | number | string, options?: {
+        save?: boolean;
+    }): Promise<this>;
+    /**
+     * Create and associate a new related instance
+     *
+     * @param associationName - The name of the association (e.g., 'profile', 'address')
+     * @param values - The values to create the new instance with
+     * @param options - Create options
+     * @returns The created associated instance
+     *
+     * @example
+     * const profile = await user.createRelated('profile', { bio: 'Hello world' });
+     * const address = await user.createRelated('address', { city: 'NYC', country: 'USA' });
+     */
+    createRelated(associationName: string, values?: Record<string, any>, options?: CreateOptions): Promise<ModelInstance<any>>;
+    /**
+     * Check if an associated instance exists
+     *
+     * @param associationName - The name of the association (e.g., 'profile', 'address')
+     * @param options - Count options
+     * @returns True if associated record exists
+     *
+     * @example
+     * const hasProfile = await user.hasRelated('profile');
+     * const hasAddress = await user.hasRelated('address');
+     */
+    hasRelated(associationName: string, options?: FindOptions): Promise<boolean>;
+}
+/**
+ * Create a Model class for a given table
+ */
+export declare function createModel<T extends Record<string, any>>(prorm: Prorm, modelName: string, attributes: Record<string, AttributeOptions>, options?: ModelOptions): ModelStatic<any>;
+/**
+ * Base Model class for decorator-based model definitions
+ *
+ * This class can be extended to create models using TypeScript decorators:
+ *
+ * @example
+ * ```typescript
+ * import { Model, DataTypes } from 'orm';
+ * import { Table, Attribute, PrimaryKey, AutoIncrement } from 'orm/decorators';
+ *
+ * @Table({ tableName: 'users' })
+ * export class User extends Model {
+ *   @Attribute(DataTypes.INTEGER)
+ *   @PrimaryKey
+ *   @AutoIncrement
+ *   declare id: number;
+ *
+ *   @Attribute(DataTypes.STRING)
+ *   declare name: string;
+ * }
+ *
+ * // Then initialize with prorm:
+ * prorm.addModel(User);
+ * await User.sync();
+ * ```
+ */
+declare class ModelClass {
+    static prorm?: Prorm;
+    static modelName?: string;
+    static tableName?: string;
+    static schema?: string;
+    static rawAttributes?: Record<string, any>;
+    static associations?: Record<string, any>;
+    static options?: ModelOptions;
+    static primaryKeyAttribute?: string;
+    static _scopes?: Record<string, any>;
+    /**
+     * Associations declared via User.hasMany(...)/.belongsTo(...)/etc before the model
+     * has been registered with prorm.addModel(). Queued here and replayed by
+     * Prorm.addModel() once the model (and its prorm/models[name] entry) exists, so
+     * association calls can be made either before or after addModel().
+     */
+    static _pendingAssociations?: Array<{
+        type: 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany';
+        target: any;
+        options?: any;
+    }>;
+    private static _queuePendingAssociation;
+    /**
+     * Scopes added via User.addScope(...) before the model has been registered with
+     * prorm.addModel(). Merged into the model's options.scopes by Prorm.addModel() so
+     * addScope() can be called either before or after addModel().
+     */
+    static _pendingScopes?: Record<string, any>;
+    static addScope(scopeName: string, scopeDef: any): void;
+    static hasMany(target: any, options?: any): any;
+    static belongsTo(target: any, options?: any): any;
+    static hasOne(target: any, options?: any): any;
+    static belongsToMany(target: any, options?: any): any;
+    static getAttributes(): string[];
+    static getTableName(): string;
+    static getPrimaryKeyAttribute(): string | undefined;
+    static findOne(findOptions?: FindOptions): Promise<ModelInstance | null>;
+    static findAll(findOptions?: FindOptions): Promise<ModelInstance[]>;
+    static findByPk(id: number | string, options?: FindOptions): Promise<ModelInstance | null>;
+    static findOrCreate(options: FindOrCreateOptions): Promise<[ModelInstance, boolean]>;
+    static findOrBuild(options: FindOrCreateOptions): Promise<[ModelInstance, boolean]>;
+    static findOrInitialize(options: FindOrCreateOptions): Promise<[ModelInstance, boolean]>;
+    /**
+     * Get the model attribute name for a database column (static version)
+     * @param columnName - The database column name
+     * @returns The model attribute name (or the column name if no mapping exists)
+     *
+     * @example
+     * User.getAttributeName('first_name'); // 'firstName' if field: 'first_name' is set
+     * User.getAttributeName('id'); // 'id'
+     */
+    static getAttributeName(columnName: string): string;
+    static build(values?: Record<string, any>, options?: Record<string, any>): ModelInstance;
+    static create(values?: Record<string, any>, options?: CreateOptions): Promise<any>;
+    static update(values: Record<string, any>, options: UpdateOptions): Promise<[number, any]>;
+    static destroy(options: DestroyOptions): Promise<number>;
+    static count(options?: CountOptions): Promise<number>;
+    static bulkCreate(records: Record<string, any>[], options?: BulkCreateOptions): Promise<ModelInstance[]>;
+    static upsert(values: Record<string, any>, options?: UpsertOptions): Promise<[ModelInstance, boolean]>;
+    static hook(hookName: string, handler: HookHandler): typeof ModelClass;
+    static addHook(hookName: string, handler: HookHandler): typeof ModelClass;
+    static beforeCreate(handler: HookHandler): typeof ModelClass;
+    static afterCreate(handler: HookHandler): typeof ModelClass;
+    static beforeUpdate(handler: HookHandler): typeof ModelClass;
+    static afterUpdate(handler: HookHandler): typeof ModelClass;
+    static beforeDestroy(handler: HookHandler): typeof ModelClass;
+    static afterDestroy(handler: HookHandler): typeof ModelClass;
+    /**
+     * Check if a hook is registered on the model
+     * @param hookName - The name of the hook (e.g., 'beforeCreate', 'afterSave')
+     * @returns True if the hook is registered, false otherwise
+     */
+    static hasHook(hookName: string): boolean;
+    /**
+     * Check if a hook is registered on the model (alias for hasHook)
+     * @param hookName - The name of the hook (e.g., 'beforeCreate', 'afterSave')
+     * @returns True if the hook is registered, false otherwise
+     */
+    static hasHooks(hookName: string): boolean;
+    /**
+     * Remove a hook from the model
+     * @param hookName - The name of the hook (e.g., 'beforeCreate', 'afterSave')
+     * @param hookOrHookId - Optional: The specific hook callback function OR hook ID to remove. If not provided, removes all hooks of this type
+     * @returns The model for chaining
+     */
+    static removeHook(hookName: string, hookOrHookId?: string | HookHandler): typeof ModelClass;
+}
+export { ModelClass as Model, ModelInstance, ModelValidator };
+export type { ValidationResult };
+declare const _default: {
+    createModel: typeof createModel;
+    ModelClass: typeof ModelClass;
+    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;
+        readonly arrayContains: symbol;
+        readonly arrayContainedBy: symbol;
+        readonly arrayOverlaps: symbol;
+        readonly arrayAny: symbol;
+        readonly arrayAll: symbol;
+        readonly contains: symbol;
+        readonly containedBy: symbol;
+        readonly keyExists: symbol;
+        readonly overlap: symbol;
+        readonly match: symbol;
+        readonly $json: symbol;
+        readonly jsonPath: symbol;
+        readonly jsonContains: symbol;
+        readonly jsonHasKey: symbol;
+        readonly jsonbExtract: symbol;
+        readonly jsonbExtractText: symbol;
+        readonly jsonbExtractPath: symbol;
+        readonly jsonbExtractPathText: symbol;
+        readonly jsonConcat: symbol;
+        readonly jsonDelete: symbol;
+        readonly jsonDeletePath: symbol;
+        readonly jsonPathExists: symbol;
+        readonly jsonPathQuery: symbol;
+        readonly jsonTypeOf: symbol;
+        readonly json: (path: string) => symbol;
+        readonly key: (pathOrOptions: string | {
+            path: string;
+            value?: any;
+        }) => Record<string, any>;
+        readonly literal: (value: string) => import("..").LiteralValue;
+        readonly cast: (value: any, type: string) => import("./operators").CastExpression;
+        readonly extract: (field: any, part: import("..").ExtractPart) => import("./operators").ExtractExpression;
+        readonly conv: (value: any, from: string | null | undefined, to: string) => import("./operators").ConvExpression;
+        readonly where: (column: {
+            $col: string;
+        } | string, operator: any, value?: any) => {
+            $where: {
+                $col: string;
+                [key: string]: any;
+            };
+        } | Record<string, any>;
+        readonly asc: (field: string) => import("./operators").OrderExpression;
+        readonly desc: (field: string) => import("./operators").OrderExpression;
+        readonly random: () => import("./operators").OrderExpression;
+        readonly isNotNullPredicate: (value: any) => boolean;
+        readonly matchAgainst: (columns: string | string[], options?: {
+            mode?: "natural" | "boolean";
+        }) => {
+            $match: {
+                columns: string[];
+                mode: "natural" | "boolean";
+            };
+        };
+        readonly matchFulltext: (columns: string | string[]) => {
+            $match: {
+                columns: string[];
+                mode: "natural";
+            };
+        };
+        readonly toTsvector: (column: string, config?: string) => {
+            $tsvector: {
+                column: string;
+                config: string;
+            };
+        };
+        readonly toTsquery: (query: string, config?: string) => {
+            $tsquery: {
+                query: string;
+                config: string;
+            };
+        };
+        readonly stDistance: symbol;
+        readonly stWithin: symbol;
+        readonly stContains: symbol;
+        readonly stIntersects: symbol;
+        readonly stDWithin: symbol;
+        readonly stCrosses: symbol;
+        readonly stOverlaps: symbol;
+        readonly stTouches: symbol;
+        readonly stEquals: symbol;
+        readonly stIsValid: symbol;
+    };
+};
+export default _default;