import { mongo, Schema, FilterQuery, UpdateQuery, QueryOptions, UpdateWithAggregationPipeline, ProjectionType, PipelineStage, PopulateOptions, InsertManyOptions, ClientSession, AnyObject, AggregateOptions, MongooseBulkWriteOptions, AnyBulkWriteOperation, Cursor } from 'mongoose';
import type { UpdateResult, BulkWriteResult as MongoBulkWriteResult } from 'mongodb';
import { FindAllOption, FindAllResponse, IBaseRepository, META, ILogger } from './definitions';
interface BaseEntity {
    orgIds?: string[];
    [key: string]: any;
}
/**
 * Base repository class providing common database operations with error handling, logging, and validation
 *
 * REFACTORED: Uses modular operation classes for better maintainability and testability
 *
 * @template T - The entity type extending BaseEntity
 */
export declare abstract class BaseRepository<T extends BaseEntity> implements IBaseRepository<T> {
    private readonly memCacheConnections;
    private readonly name;
    private readonly schema;
    private readonly collection;
    private readonly isDiscriminator;
    private readonly discriminator?;
    private model;
    private readonly logger?;
    private readonly connectionManager;
    private readonly retryExecutor;
    private readonly createOps;
    private readonly readOps;
    private readonly updateOps;
    private readonly deleteOps;
    private readonly aggregateOps;
    /**
     * Creates a new BaseRepository instance
     *
     * @param name - Model name
     * @param schema - Mongoose schema
     * @param collection - Collection name (optional)
     * @param discriminator - Discriminator configuration (optional)
     * @param logger - Logger instance for development logging (optional)
     */
    constructor(name: string, schema: Schema, collection: string | null, discriminator?: {
        baseName: string;
        baseSchema: Schema;
        baseCollection: string;
    }, logger?: ILogger);
    /**
     * Initializes the Mongoose model
     * @private
     */
    private initializeModel;
    /**
     * Sets the model for a specific domain (deprecated - handled automatically)
     *
     * @deprecated This method is no-op in the refactored architecture.
     * Model registration is handled automatically by ConnectionManager.
     * @param domain - Domain identifier
     */
    setModel(domain: string): void;
    /**
     * Removes undefined values from an object
     * @protected
     */
    protected removeUndefinedValue(object: Record<string, unknown>): void;
    /**
     * Create body of $set function. It will use to update sub-document.
     *
     * Return: { "subDocumentName.$.key": "value" }
     */
    protected createSetOfSubDocument<Doc, SubDoc>(subDocumentName: keyof Doc, subDocument: Partial<SubDoc>): Record<string, unknown>;
    protected createObjectID(): string;
    /**
     * Creates a new document
     */
    create(entity: Partial<T>, session?: ClientSession, meta?: META): Promise<T>;
    /**
     * Inserts multiple documents
     */
    insertMany(docs: Array<Partial<T>>, options?: InsertManyOptions & {
        lean: true;
    }, meta?: META): Promise<any>;
    /**
     * Finds a single document matching the condition
     */
    findOne(cond?: FilterQuery<T>, projection?: ProjectionType<T> | null, options?: QueryOptions<T> | null, meta?: META): Promise<T | null>;
    /**
     * Finds all documents matching the condition with pagination
     */
    findAll(cond: FilterQuery<T>, options?: Partial<FindAllOption<T>>, meta?: META): Promise<FindAllResponse<T>>;
    /**
     * Finds multiple documents matching the filter
     */
    find(filter: FilterQuery<T>, projection?: ProjectionType<T> | null | undefined, options?: QueryOptions<T> | null | undefined, meta?: META): Promise<T[]>;
    /**
     * Counts documents matching the condition
     */
    countDocuments(cond: FilterQuery<T>, options?: mongo.CountOptions, meta?: META): Promise<number>;
    /**
     * Returns a cursor for iterating over documents
     */
    findCursor(filter: FilterQuery<T>, projection?: ProjectionType<T> | null, options?: QueryOptions<T> | null, meta?: META): Promise<Cursor<T, never>>;
    /**
     * Updates a document by ID
     */
    updateById(id: string, doc: Partial<T>, meta?: META): Promise<boolean>;
    /**
     * Finds a document and updates it, or creates it if it doesn't exist (upsert)
     */
    findOneAndUpdate(cond: FilterQuery<T>, doc: UpdateQuery<T & AnyObject>, options?: QueryOptions<T>, meta?: META): Promise<T | null>;
    /**
     * Updates a single document matching the filter
     */
    updateOne(filter?: FilterQuery<T>, update?: UpdateQuery<T & AnyObject> | UpdateWithAggregationPipeline, options?: mongo.UpdateOptions, meta?: META): Promise<T>;
    /**
     * Updates multiple documents matching the filter
     */
    updateMany(filter: FilterQuery<T>, update?: UpdateQuery<T & AnyObject> | UpdateWithAggregationPipeline, options?: mongo.UpdateOptions, meta?: META): Promise<UpdateResult>;
    /**
     * Deletes a document by ID
     */
    deleteById(id: string, meta?: META): Promise<boolean>;
    /**
     * Deletes multiple documents matching the filter
     */
    deleteMany(filter?: FilterQuery<T>, options?: mongo.DeleteOptions, meta?: META): Promise<any>;
    /**
     * Performs an aggregation pipeline operation
     */
    aggregate(pipeline?: PipelineStage[], options?: AggregateOptions, meta?: META): Promise<any>;
    /**
     * Populates document references
     */
    populate(docs: Array<any> | any, options: PopulateOptions | Array<PopulateOptions>, meta?: META): Promise<any>;
    /**
     * Finds documents and populates their references
     */
    findAndPopulate(filter: FilterQuery<T>, options: PopulateOptions | PopulateOptions[], projection?: ProjectionType<T> | null | undefined, meta?: META): Promise<any>;
    /**
     * Performs bulk write operations
     */
    bulkWrite(writes: Array<AnyBulkWriteOperation>, options?: MongooseBulkWriteOptions, meta?: META): Promise<MongoBulkWriteResult>;
}
export {};