/**
 * MongoDB-compatible Document Collection Implementation
 *
 * Core document collection with full MongoDB API compatibility
 * Implements schema-free storage with automatic optimization
 */
import { Document, ObjectId, QueryFilter, FindOptions, UpdateOperators, UpdateOptions, ReplaceOptions, InsertOneResult, InsertManyResult, UpdateResult, DeleteResult, ReplaceOneResult, BulkWriteOperation, BulkWriteOptions, BulkWriteResult, AggregationPipeline, AggregationOptions, AggregationCursor, IndexSpec, IndexInfo, ChangeStream, ChangeStreamOptions, QueryExplain, PaginationResult, IDocumentCollection, IChangeStreamManager } from './interface.js';
/**
 * MongoDB-compatible Document Collection
 */
export declare class DocumentCollection<T extends Document = Document> implements IDocumentCollection<T> {
    readonly name: string;
    readonly database: string;
    private d1;
    private kvStore?;
    private queryEngine;
    private indexManager;
    private changeStreamManager?;
    private options;
    constructor(name: string, database: string, d1: any, options?: {
        kvStore?: any;
        changeStreamManager?: IChangeStreamManager;
        maxDocumentSize?: number;
        enableValidation?: boolean;
        enableChangeStreams?: boolean;
        enableQueryCache?: boolean;
        queryCacheTTL?: number;
    });
    find(filter?: QueryFilter, options?: FindOptions): Promise<T[]>;
    findOne(filter?: QueryFilter, options?: FindOptions): Promise<T | null>;
    findWithPagination(filter?: QueryFilter, options?: FindOptions & {
        pageSize?: number;
        cursor?: string;
    }): Promise<PaginationResult<T>>;
    countDocuments(filter?: QueryFilter): Promise<number>;
    estimatedDocumentCount(): Promise<number>;
    exists(filter: QueryFilter): Promise<boolean>;
    distinct<K extends keyof T>(field: K, filter?: QueryFilter): Promise<T[K][]>;
    insertOne(document: Omit<T, '_id'> & {
        _id?: ObjectId;
    }): Promise<InsertOneResult>;
    insertMany(documents: (Omit<T, '_id'> & {
        _id?: ObjectId;
    })[], options?: {
        ordered?: boolean;
    }): Promise<InsertManyResult>;
    updateOne(filter: QueryFilter, update: UpdateOperators | Partial<T>, options?: UpdateOptions): Promise<UpdateResult>;
    updateMany(filter: QueryFilter, update: UpdateOperators | Partial<T>, options?: UpdateOptions): Promise<UpdateResult>;
    replaceOne(filter: QueryFilter, replacement: Omit<T, '_id'>, options?: ReplaceOptions): Promise<ReplaceOneResult>;
    findOneAndUpdate(filter: QueryFilter, update: UpdateOperators | Partial<T>, options?: UpdateOptions & {
        returnDocument?: 'before' | 'after';
        includeResultMetadata?: boolean;
    }): Promise<T | null>;
    findOneAndReplace(filter: QueryFilter, replacement: Omit<T, '_id'>, options?: ReplaceOptions & {
        returnDocument?: 'before' | 'after';
        includeResultMetadata?: boolean;
    }): Promise<T | null>;
    findOneAndDelete(filter: QueryFilter, options?: {
        includeResultMetadata?: boolean;
    }): Promise<T | null>;
    deleteOne(filter: QueryFilter): Promise<DeleteResult>;
    deleteMany(filter: QueryFilter): Promise<DeleteResult>;
    bulkWrite(operations: BulkWriteOperation[], options?: BulkWriteOptions): Promise<BulkWriteResult>;
    initializeOrderedBulkOp(): any;
    initializeUnorderedBulkOp(): any;
    aggregate<R = any>(pipeline: AggregationPipeline, options?: AggregationOptions): Promise<AggregationCursor<R>>;
    aggregateToArray<R = any>(pipeline: AggregationPipeline, options?: AggregationOptions): Promise<R[]>;
    createIndex(keyPattern: IndexSpec['key'], options?: IndexSpec['options']): Promise<string>;
    createIndexes(indexSpecs: IndexSpec[]): Promise<string[]>;
    dropIndex(indexName: string): Promise<void>;
    dropIndexes(): Promise<void>;
    listIndexes(): Promise<IndexInfo[]>;
    indexExists(indexName: string): Promise<boolean>;
    indexStats(): Promise<Record<string, any>>;
    reIndex(): Promise<void>;
    watch<TDoc extends Document = Document>(pipeline?: AggregationPipeline, options?: ChangeStreamOptions): Promise<ChangeStream<TDoc>>;
    drop(): Promise<boolean>;
    rename(newName: string, options?: {
        dropTarget?: boolean;
    }): Promise<void>;
    stats(): Promise<any>;
    validate(options?: {
        full?: boolean;
    }): Promise<any>;
    explain(operation: 'find' | 'aggregate' | 'update' | 'delete', query: any, options?: any): Promise<QueryExplain>;
    hint(query: QueryFilter): Promise<string[]>;
    analyzeFields(): Promise<any>;
    getIndexRecommendations(): Promise<IndexSpec[]>;
    migrateField(fieldPath: string, transform: (value: any) => any, options?: {
        dryRun?: boolean;
    }): Promise<number>;
    private prepareDocumentForInsert;
    private validateDocument;
    private ensureIndexedFields;
    private buildInsertQuery;
    private buildUpsertDocument;
    private extractIdFromFilter;
    private processQueryResults;
    private recordQueryPattern;
    private emitChangeEvent;
    private getCacheKey;
    private getCachedResult;
    private cacheResult;
    private generateObjectId;
}
//# sourceMappingURL=collection.d.ts.map