/**
 * MongoDB-compatible Document Storage Interface
 *
 * Core interface defining the API for document storage operations
 * Provides full MongoDB compatibility with NoSQL optimizations
 */
export { Document, ObjectId, QueryFilter, FindOptions, UpdateOperators, UpdateOptions, ReplaceOptions, InsertOneResult, InsertManyResult, UpdateResult, DeleteResult, ReplaceOneResult, BulkWriteOperation, BulkWriteOptions, BulkWriteResult, AggregationPipeline, AggregationOptions, AggregationCursor, IndexSpec, IndexInfo, ChangeStream, ChangeStreamOptions, QueryExplain, CollectionOptions, CollectionInfo, ClientSession, TransactionOptions, PaginationResult, ChangeEvent, DocumentError, IndexMapping, FieldAnalysis, SchemaEvolutionEvent, CollectionAnalytics } from './types.js';
export interface IDocumentCollection<T extends Document = Document> {
    readonly name: string;
    readonly database: string;
    /**
     * Find documents matching the filter
     */
    find(filter?: QueryFilter, options?: FindOptions): Promise<T[]>;
    /**
     * Find a single document matching the filter
     */
    findOne(filter?: QueryFilter, options?: FindOptions): Promise<T | null>;
    /**
     * Find documents with cursor-based pagination
     */
    findWithPagination(filter?: QueryFilter, options?: FindOptions & {
        pageSize?: number;
        cursor?: string;
    }): Promise<PaginationResult<T>>;
    /**
     * Count documents matching the filter
     */
    countDocuments(filter?: QueryFilter): Promise<number>;
    /**
     * Get estimated document count (faster but less accurate)
     */
    estimatedDocumentCount(): Promise<number>;
    /**
     * Check if any documents match the filter
     */
    exists(filter: QueryFilter): Promise<boolean>;
    /**
     * Get distinct values for a field
     */
    distinct<K extends keyof T>(field: K, filter?: QueryFilter): Promise<T[K][]>;
    /**
     * Insert a single document
     */
    insertOne(document: Omit<T, '_id'> & {
        _id?: ObjectId;
    }): Promise<InsertOneResult>;
    /**
     * Insert multiple documents
     */
    insertMany(documents: (Omit<T, '_id'> & {
        _id?: ObjectId;
    })[], options?: {
        ordered?: boolean;
    }): Promise<InsertManyResult>;
    /**
     * Update a single document
     */
    updateOne(filter: QueryFilter, update: UpdateOperators | Partial<T>, options?: UpdateOptions): Promise<UpdateResult>;
    /**
     * Update multiple documents
     */
    updateMany(filter: QueryFilter, update: UpdateOperators | Partial<T>, options?: UpdateOptions): Promise<UpdateResult>;
    /**
     * Replace a single document
     */
    replaceOne(filter: QueryFilter, replacement: Omit<T, '_id'>, options?: ReplaceOptions): Promise<ReplaceOneResult>;
    /**
     * Find and update a document atomically
     */
    findOneAndUpdate(filter: QueryFilter, update: UpdateOperators | Partial<T>, options?: UpdateOptions & {
        returnDocument?: 'before' | 'after';
        includeResultMetadata?: boolean;
    }): Promise<T | null>;
    /**
     * Find and replace a document atomically
     */
    findOneAndReplace(filter: QueryFilter, replacement: Omit<T, '_id'>, options?: ReplaceOptions & {
        returnDocument?: 'before' | 'after';
        includeResultMetadata?: boolean;
    }): Promise<T | null>;
    /**
     * Find and delete a document atomically
     */
    findOneAndDelete(filter: QueryFilter, options?: {
        includeResultMetadata?: boolean;
    }): Promise<T | null>;
    /**
     * Delete a single document
     */
    deleteOne(filter: QueryFilter): Promise<DeleteResult>;
    /**
     * Delete multiple documents
     */
    deleteMany(filter: QueryFilter): Promise<DeleteResult>;
    /**
     * Execute multiple operations in a single batch
     */
    bulkWrite(operations: BulkWriteOperation[], options?: BulkWriteOptions): Promise<BulkWriteResult>;
    /**
     * Initialize an ordered bulk operation builder
     */
    initializeOrderedBulkOp(): IBulkOperationBuilder;
    /**
     * Initialize an unordered bulk operation builder
     */
    initializeUnorderedBulkOp(): IBulkOperationBuilder;
    /**
     * Execute an aggregation pipeline
     */
    aggregate<R = any>(pipeline: AggregationPipeline, options?: AggregationOptions): Promise<AggregationCursor<R>>;
    /**
     * Execute aggregation and return all results
     */
    aggregateToArray<R = any>(pipeline: AggregationPipeline, options?: AggregationOptions): Promise<R[]>;
    /**
     * Create a single index
     */
    createIndex(keyPattern: IndexSpec['key'], options?: IndexSpec['options']): Promise<string>;
    /**
     * Create multiple indexes
     */
    createIndexes(indexSpecs: IndexSpec[]): Promise<string[]>;
    /**
     * Drop an index
     */
    dropIndex(indexName: string): Promise<void>;
    /**
     * Drop all indexes except _id
     */
    dropIndexes(): Promise<void>;
    /**
     * List all indexes
     */
    listIndexes(): Promise<IndexInfo[]>;
    /**
     * Check if an index exists
     */
    indexExists(indexName: string): Promise<boolean>;
    /**
     * Get index statistics
     */
    indexStats(): Promise<Record<string, any>>;
    /**
     * Reindex the collection
     */
    reIndex(): Promise<void>;
    /**
     * Watch for changes in the collection
     */
    watch<T extends Document = Document>(pipeline?: AggregationPipeline, options?: ChangeStreamOptions): Promise<ChangeStream<T>>;
    /**
     * Drop the collection
     */
    drop(): Promise<boolean>;
    /**
     * Rename the collection
     */
    rename(newName: string, options?: {
        dropTarget?: boolean;
    }): Promise<void>;
    /**
     * Get collection statistics
     */
    stats(): Promise<any>;
    /**
     * Validate collection data and indexes
     */
    validate(options?: {
        full?: boolean;
    }): Promise<any>;
    /**
     * Explain query execution plan
     */
    explain(operation: 'find' | 'aggregate' | 'update' | 'delete', query: any, options?: any): Promise<QueryExplain>;
    /**
     * Get query hints for optimization
     */
    hint(query: QueryFilter): Promise<string[]>;
    /**
     * Get field usage analytics
     */
    analyzeFields(): Promise<any>;
    /**
     * Get index recommendations
     */
    getIndexRecommendations(): Promise<IndexSpec[]>;
    /**
     * Migrate field types
     */
    migrateField(fieldPath: string, transform: (value: any) => any, options?: {
        dryRun?: boolean;
    }): Promise<number>;
}
export interface IBulkOperationBuilder {
    /**
     * Add an insert operation
     */
    insert(document: Document): this;
    /**
     * Find documents for bulk operations
     */
    find(filter: QueryFilter): IBulkFindOperations;
    /**
     * Execute the bulk operation
     */
    execute(): Promise<BulkWriteResult>;
    /**
     * Get the current batch size
     */
    length: number;
}
export interface IBulkFindOperations {
    /**
     * Update one document
     */
    updateOne(update: UpdateOperators): this;
    /**
     * Update multiple documents
     */
    update(update: UpdateOperators): this;
    /**
     * Replace one document
     */
    replaceOne(replacement: Document): this;
    /**
     * Upsert one document
     */
    upsert(): IBulkUpsertOperations;
    /**
     * Delete one document
     */
    deleteOne(): this;
    /**
     * Delete multiple documents
     */
    delete(): this;
}
export interface IBulkUpsertOperations {
    /**
     * Update one document with upsert
     */
    updateOne(update: UpdateOperators): this;
    /**
     * Replace one document with upsert
     */
    replaceOne(replacement: Document): this;
}
export interface IDocumentDatabase {
    readonly name: string;
    /**
     * Get a collection
     */
    collection<T extends Document = Document>(name: string): IDocumentCollection<T>;
    /**
     * Create a collection with options
     */
    createCollection(name: string, options?: CollectionOptions): Promise<IDocumentCollection>;
    /**
     * Drop a collection
     */
    dropCollection(name: string): Promise<boolean>;
    /**
     * List all collections
     */
    listCollections(): Promise<CollectionInfo[]>;
    /**
     * Rename a collection
     */
    renameCollection(fromName: string, toName: string, options?: {
        dropTarget?: boolean;
    }): Promise<void>;
    /**
     * Get database statistics
     */
    stats(): Promise<any>;
    /**
     * Drop the database
     */
    drop(): Promise<void>;
    /**
     * Start a new session
     */
    startSession(options?: any): Promise<ClientSession>;
    /**
     * Execute operations in a transaction
     */
    withTransaction<T>(session: ClientSession, fn: () => Promise<T>, options?: TransactionOptions): Promise<T>;
}
export interface IDocumentStorageEngine {
    /**
     * Initialize the storage engine
     */
    initialize(): Promise<void>;
    /**
     * Create database connection
     */
    createDatabase(name: string): Promise<IDocumentDatabase>;
    /**
     * Get existing database
     */
    getDatabase(name: string): Promise<IDocumentDatabase | null>;
    /**
     * Drop database
     */
    dropDatabase(name: string): Promise<boolean>;
    /**
     * List all databases
     */
    listDatabases(): Promise<string[]>;
    /**
     * Close all connections
     */
    close(): Promise<void>;
    /**
     * Health check
     */
    ping(): Promise<boolean>;
    /**
     * Get storage metrics
     */
    getMetrics(): Promise<any>;
}
export interface IQueryEngine {
    /**
     * Parse MongoDB query to SQL
     */
    translateQuery(collection: string, filter: QueryFilter, options?: FindOptions): Promise<{
        sql: string;
        params: any[];
    }>;
    /**
     * Parse MongoDB update to SQL
     */
    translateUpdate(collection: string, filter: QueryFilter, update: UpdateOperators, options?: UpdateOptions): Promise<{
        sql: string;
        params: any[];
    }>;
    /**
     * Parse aggregation pipeline
     */
    translateAggregation(collection: string, pipeline: AggregationPipeline, options?: AggregationOptions): Promise<{
        sql: string;
        params: any[];
        stages: string[];
    }>;
    /**
     * Optimize query execution plan
     */
    optimizeQuery(query: any): Promise<any>;
    /**
     * Analyze query performance
     */
    analyzeQuery(query: any): Promise<any>;
}
export interface IIndexManager {
    /**
     * Ensure field is indexed if needed
     */
    ensureFieldIndex(collection: string, fieldPath: string, value: any): Promise<boolean>;
    /**
     * Get available index column
     */
    getAvailableIndexColumn(collection: string): Promise<string | null>;
    /**
     * Register field mapping
     */
    registerFieldMapping(collection: string, fieldPath: string, indexColumn: string, dataType: string): Promise<void>;
    /**
     * Get field mapping
     */
    getFieldMapping(collection: string, fieldPath: string): Promise<{
        indexColumn: string;
        dataType: string;
    } | null>;
    /**
     * Analyze query patterns for indexing
     */
    analyzeQueryPatterns(collection: string): Promise<IndexSpec[]>;
    /**
     * Backfill index for existing documents
     */
    backfillIndex(collection: string, fieldPath: string, indexColumn: string): Promise<number>;
}
export interface IChangeStreamManager {
    /**
     * Create a change stream
     */
    createStream<T extends Document = Document>(collection: string, pipeline?: AggregationPipeline, options?: ChangeStreamOptions): Promise<ChangeStream<T>>;
    /**
     * Close a change stream
     */
    closeStream(streamId: string): Promise<void>;
    /**
     * Emit change events
     */
    emitChange(collection: string, change: any): Promise<void>;
    /**
     * List active streams
     */
    listActiveStreams(): Promise<string[]>;
}
export interface DocumentStorageConfig {
    d1Database: any;
    kvStore?: any;
    r2Bucket?: any;
    maxIndexedFields?: number;
    autoIndexThreshold?: number;
    queryTimeout?: number;
    maxDocumentSize?: number;
    enableQueryCache?: boolean;
    queryCacheTTL?: number;
    enableAutoIndexing?: boolean;
    enableSchemaEvolution?: boolean;
    enableChangeStreams?: boolean;
    maxChangeStreamConnections?: number;
    enableQueryLogging?: boolean;
    enablePerformanceMetrics?: boolean;
}
//# sourceMappingURL=interface.d.ts.map