import { Schema } from './schema';
import { type SearchIndexRegistry } from './search-index-registry';
import { ObjectId } from './objectid';
import { QueryBuilder } from './query-builder';
import { DocumentQueryBuilder } from './document-query-builder';
import { FindQueryBuilder } from './find-query-builder';
import { QueryableKeys } from './type-utils';
import { StorageStrategy } from './storage';
import { Document, type IDocument } from './document';
import type { Database } from './database';
export { Document };
export type { IDocument };
export type DeepPartial<T> = T extends object ? {
    [P in keyof T]?: DeepPartial<T[P]>;
} : T;
export type QueryOperator<T = unknown> = {
    $eq?: T;
    $ne?: T;
    $in?: T[];
    $nin?: T[];
    $gt?: T;
    $gte?: T;
    $lt?: T;
    $lte?: T;
    $regex?: string | RegExp;
    $exists?: boolean;
    $size?: number;
    $elemMatch?: Record<string, unknown>;
    $all?: T extends unknown[] ? T : never;
    $not?: QueryOperator<T>;
};
export type QueryValue<T = unknown> = T | QueryOperator<T>;
type LogicalQueryOperators<T extends object> = {
    $or?: Query<T>[];
    $and?: Query<T>[];
    $nor?: Query<T>[];
};
export type Query<T extends object = Record<string, unknown>> = {
    [K in QueryableKeys<T>]?: QueryValue<T[K]>;
} & LogicalQueryOperators<T>;
export type UpdateOperator<T extends object = Record<string, unknown>> = {
    $set?: Partial<T>;
    $unset?: Partial<Record<keyof T, unknown>>;
    $inc?: Partial<Record<keyof T, number>>;
    $dec?: Partial<Record<keyof T, number>>;
    $push?: Partial<Record<keyof T, unknown>>;
    $pull?: Partial<Record<keyof T, unknown>>;
    $addToSet?: Partial<Record<keyof T, unknown>>;
    $pop?: Partial<Record<keyof T, 1 | -1>>;
    $rename?: Partial<Record<keyof T, string>>;
};
export type Update<T extends object = Record<string, unknown>> = Partial<T> | UpdateOperator<T>;
export type QueryOptions<T extends object = Record<string, unknown>> = {
    sort?: Partial<Record<keyof T, 1 | -1>>;
    limit?: number;
    skip?: number;
    select?: Partial<Record<keyof T, 0 | 1>>;
    lean?: boolean;
};
export type PopulateOptions = {
    path: string;
    select?: string | string[] | Record<string, 0 | 1>;
    match?: Query<object>;
    populate?: PopulateOptions | PopulateOptions[];
    model?: string;
};
export declare class Model<T extends object = Record<string, unknown>> {
    private _storage;
    private _schema?;
    private _discriminatorKey?;
    private _discriminatorValue?;
    private _database?;
    private _storageInitPromise;
    private _searchIndexRegistry;
    constructor(schema?: Schema<T>, discriminatorValue?: string, storage?: StorageStrategy<T>, database?: Database);
    _setStorageInitPromise(promise: Promise<void>): void;
    private _ensureStorageReady;
    private _applyVirtuals;
    private _serializeDocument;
    private _applyFieldSelection;
    private _executePreHooks;
    private _executePostHooks;
    private _validateDocument;
    private _applyDefaults;
    private _ensureId;
    private _applyTimestamps;
    private _checkUniqueConstraints;
    _applyPopulate(docs: T[], options: string[] | PopulateOptions | PopulateOptions[]): Promise<T[]>;
    private _normalizePopulateOptions;
    private _populatePath;
    private _applyPopulateSelect;
    createIndex(fields: keyof T | Array<keyof T>, options?: {
        unique?: boolean;
    }): Promise<void>;
    private _hasNativeQuery;
    private _findDocumentsUsingIndexes;
    private _compareValues;
    private _matches;
    findOne(query: Query<T>, options?: QueryOptions<T>): DocumentQueryBuilder<T>;
    find(query?: Query<T>, options?: QueryOptions<T>): FindQueryBuilder<T>;
    _executeFindWithOptions(query: Query<T>, options?: QueryOptions<T>): Promise<Array<T & Document>>;
    create(doc: DeepPartial<T>): Promise<T & Document>;
    insertMany(docs: DeepPartial<T>[]): Promise<Array<T & Document>>;
    deleteOne(query: Query<T>): QueryBuilder<{
        deletedCount: number;
    }>;
    private _executeDeleteOne;
    deleteMany(query: Query<T>): QueryBuilder<{
        deletedCount: number;
    }>;
    private _executeDeleteMany;
    private _rebuildIndexes;
    private _updateIndexForDocument;
    private _applyUpdate;
    updateOne(query: Query<T>, update: Update<T>, options?: {
        upsert?: boolean;
    }): QueryBuilder<{
        modifiedCount: number;
        upsertedCount?: number;
    }>;
    private _executeUpdateOne;
    updateMany(query: Query<T>, update: Update<T>): QueryBuilder<{
        modifiedCount: number;
    }>;
    private _buildUpsertDocument;
    private _executeUpdateMany;
    countDocuments(query?: Query<T>): Promise<number>;
    findOneAndUpdate(query: Query<T>, update: Update<T>, options?: {
        returnDocument?: 'before' | 'after';
        new?: boolean;
        upsert?: boolean;
    }): DocumentQueryBuilder<T>;
    private _executeFindOneAndUpdate;
    findOneAndDelete(query: Query<T>): DocumentQueryBuilder<T>;
    private _executeFindOneAndDelete;
    distinct<K extends keyof T>(field: K, query?: Query<T>): Promise<Array<T[K]>>;
    findById(id: string | ObjectId): DocumentQueryBuilder<T>;
    findByIdAndUpdate(id: string | ObjectId, update: Update<T>, options?: {
        returnDocument?: 'before' | 'after';
        new?: boolean;
        upsert?: boolean;
    }): DocumentQueryBuilder<T>;
    findByIdAndDelete(id: string | ObjectId): DocumentQueryBuilder<T>;
    _getSearchIndexRegistry(): SearchIndexRegistry | null;
    aggregate<R = Record<string, unknown>>(pipeline: unknown[]): Promise<R[]>;
    discriminator<D extends object>(name: string, schema: Schema<D>): Model<T & D>;
}
//# sourceMappingURL=model.d.ts.map