import type Mongo from './mongo';
import type { Abortable } from 'events';
import type { Namespace } from './decorators';
import { ShellApiWithMongoClass } from './decorators';
import { asPrintable, namespaceInfo } from './enums';
import type { FindAndModifyShellOptions, FindAndModifyMethodShellOptions, RemoveShellOptions, MapReduceShellOptions, GenericCollectionSchema, GenericDatabaseSchema, GenericServerSideSchema, StringKey, SearchIndexDefinition } from './helpers';
import type { AnyBulkWriteOperation, BulkWriteOptions, CountOptions, CountDocumentsOptions, ChangeStreamOptions, CreateIndexesOptions, DeleteOptions, DistinctOptions, Document, EstimatedDocumentCountOptions, ExplainVerbosityLike, FindOneAndDeleteOptions, FindOneAndReplaceOptions, FindOneAndUpdateOptions, FindOptions, InsertOneOptions, ReplaceOptions, RunCommandOptions, UpdateOptions, DropCollectionOptions, CheckMetadataConsistencyOptions, AggregateOptions, SearchIndexDescription } from '@mongosh/service-provider-core';
import type { RunCommandCursor, Database, DatabaseWithSchema } from './index';
import { AggregationCursor, BulkWriteResult, CommandResult, Cursor, DeleteResult, Explainable, InsertManyResult, InsertOneResult, UpdateResult } from './index';
import Bulk from './bulk';
import PlanCache from './plan-cache';
import ChangeStreamCursor from './change-stream-cursor';
import type { MQLDocument, MQLQuery, MQLPipeline } from './mql-types';
export type CollectionWithSchema<M extends GenericServerSideSchema = GenericServerSideSchema, D extends GenericDatabaseSchema = M[keyof M], C extends GenericCollectionSchema = D[keyof D], N extends StringKey<D> = StringKey<D>> = Collection<M, D, C, N> & {
    [k in StringKey<D> as k extends `${N}.${infer S}` ? S : never]: Collection<M, D, D[k], k>;
};
export declare class Collection<M extends GenericServerSideSchema = GenericServerSideSchema, D extends GenericDatabaseSchema = M[keyof M], C extends GenericCollectionSchema = D[keyof D], N extends StringKey<D> = StringKey<D>> extends ShellApiWithMongoClass {
    _mongo: Mongo<M>;
    _database: DatabaseWithSchema<M, D>;
    _name: N;
    _cachedSampleDocs: Document[];
    constructor(mongo: Mongo<M>, database: DatabaseWithSchema<M, D> | Database<M, D>, name: N);
    [namespaceInfo](): Namespace;
    [asPrintable](): string;
    private _emitCollectionApiCall;
    aggregate(pipeline: MQLPipeline, options: AggregateOptions & {
        explain: ExplainVerbosityLike;
    } & Abortable): Promise<Document>;
    aggregate(pipeline: MQLPipeline, options?: AggregateOptions & Abortable): Promise<AggregationCursor>;
    aggregate(...stages: MQLPipeline): Promise<AggregationCursor>;
    bulkWrite(operations: AnyBulkWriteOperation[], options?: BulkWriteOptions): Promise<BulkWriteResult>;
    count(query?: {}, options?: CountOptions): Promise<number>;
    countDocuments(query?: MQLQuery, options?: CountDocumentsOptions & Abortable): Promise<number>;
    deleteMany(filter: Document, options?: DeleteOptions): Promise<DeleteResult | Document>;
    deleteOne(filter: Document, options?: DeleteOptions): Promise<DeleteResult | Document>;
    distinct(field: string): Promise<Document>;
    distinct(field: string, query: MQLQuery): Promise<Document>;
    distinct(field: string, query: MQLQuery, options: DistinctOptions): Promise<Document>;
    estimatedDocumentCount(options?: EstimatedDocumentCountOptions): Promise<number>;
    find(query?: MQLQuery, projection?: Document, options?: FindOptions & {
        explain?: ExplainVerbosityLike;
    } & Abortable): Promise<Cursor>;
    findAndModify(options: FindAndModifyMethodShellOptions): Promise<Document | null>;
    findOne(query?: MQLQuery, projection?: Document, options?: FindOptions & Abortable): Promise<MQLDocument | null>;
    renameCollection(newName: string, dropTarget?: boolean): Promise<Document>;
    findOneAndDelete(filter: Document, options?: FindOneAndDeleteOptions): Promise<Document | null>;
    findOneAndReplace(filter: Document, replacement: Document, options?: FindAndModifyShellOptions<FindOneAndReplaceOptions>): Promise<Document>;
    findOneAndUpdate(filter: Document, update: Document | Document[], options?: FindAndModifyShellOptions<FindOneAndUpdateOptions>): Promise<Document>;
    insert(docs: MQLDocument | MQLDocument[], options?: BulkWriteOptions): Promise<InsertManyResult>;
    insertMany(docs: MQLDocument[], options?: BulkWriteOptions): Promise<InsertManyResult>;
    insertOne(doc: MQLDocument, options?: InsertOneOptions): Promise<InsertOneResult>;
    isCapped(): Promise<boolean>;
    remove(query: MQLQuery, options?: boolean | RemoveShellOptions): Promise<DeleteResult | Document>;
    replaceOne(filter: Document, replacement: Document, options?: ReplaceOptions): Promise<UpdateResult>;
    update(filter: Document, update: Document, options?: UpdateOptions & {
        multi?: boolean;
    }): Promise<UpdateResult | Document>;
    updateMany(filter: Document, update: Document, options?: UpdateOptions): Promise<UpdateResult | Document>;
    updateOne(filter: Document, update: Document, options?: UpdateOptions & {
        sort?: Document;
    }): Promise<UpdateResult | Document>;
    compactStructuredEncryptionData(): Promise<Document>;
    convertToCapped(size: number): Promise<Document>;
    _createIndexes(keyPatterns: Document[], options?: CreateIndexesOptions, commitQuorum?: number | string): Promise<string[]>;
    createIndexes(keyPatterns: Document[], options?: CreateIndexesOptions, commitQuorum?: number | string): Promise<string[]>;
    createIndex(keys: Document, options?: CreateIndexesOptions, commitQuorum?: number | string): Promise<string>;
    ensureIndex(keys: Document, options?: CreateIndexesOptions, commitQuorum?: number | string): Promise<Document>;
    getIndexes(): Promise<Document[]>;
    getIndexSpecs(): Promise<Document[]>;
    getIndices(): Promise<Document[]>;
    getIndexKeys(): Promise<Document[]>;
    dropIndexes(indexes?: string | string[] | Document | Document[]): Promise<Document>;
    dropIndex(index: string | Document): Promise<Document>;
    _getSingleStorageStatValue(key: string): Promise<number>;
    totalIndexSize(...args: any[]): Promise<number>;
    reIndex(): Promise<Document>;
    getDB(): DatabaseWithSchema<M, D>;
    getMongo(): Mongo<M>;
    dataSize(): Promise<number>;
    storageSize(): Promise<number>;
    totalSize(): Promise<number>;
    drop(options?: DropCollectionOptions): Promise<boolean>;
    exists(): Promise<Document>;
    getFullName(): string;
    getName(): N;
    runCommand(commandName: string | Document, options?: RunCommandOptions): Promise<Document>;
    explain(verbosity?: ExplainVerbosityLike): Explainable;
    _getLegacyCollStats(scale: number): Promise<Document>;
    _aggregateAndScaleCollStats(collStats: Document[], scale: number): Promise<Document>;
    _getAggregatedCollStats(scale: number): Promise<Document>;
    stats(originalOptions?: Document | number): Promise<Document>;
    latencyStats(options?: Document): Promise<Document[]>;
    initializeOrderedBulkOp(): Promise<Bulk>;
    initializeUnorderedBulkOp(): Promise<Bulk>;
    getPlanCache(): PlanCache;
    mapReduce(map: Function | string, reduce: Function | string, optionsOrOutString: MapReduceShellOptions): Promise<Document>;
    validate(options?: boolean | Document): Promise<Document>;
    getShardVersion(): Promise<Document>;
    _getShardedCollectionInfo(config: DatabaseWithSchema<M, D>, collStats: Document[]): Promise<Document>;
    getShardDistribution(): Promise<CommandResult<GetShardDistributionResult>>;
    getShardLocation(): Promise<{
        shards: string[];
        sharded: boolean;
    }>;
    watch(pipeline?: MQLPipeline | ChangeStreamOptions, options?: ChangeStreamOptions): Promise<ChangeStreamCursor>;
    hideIndex(index: string | Document): Promise<Document>;
    unhideIndex(index: string | Document): Promise<Document>;
    analyzeShardKey(key: Document, options?: Document): Promise<Document>;
    configureQueryAnalyzer(options: Document): Promise<Document>;
    checkMetadataConsistency(options?: CheckMetadataConsistencyOptions): Promise<RunCommandCursor>;
    getSearchIndexes(indexName?: string | Document, options?: Document): Promise<Document[]>;
    createSearchIndex(name: string, definition: SearchIndexDefinition): Promise<string>;
    createSearchIndex(name: string, type: 'search' | 'vectorSearch', definition: SearchIndexDefinition): Promise<string>;
    createSearchIndex(definition: SearchIndexDefinition, type?: 'search' | 'vectorSearch'): Promise<string>;
    createSearchIndex(description: SearchIndexDescription): Promise<string>;
    createSearchIndexes(specs: SearchIndexDescription[]): Promise<string[]>;
    dropSearchIndex(indexName: string): Promise<void>;
    updateSearchIndex(indexName: string, definition: Document): Promise<void>;
    _getSampleDocs(): Promise<Document[]>;
    _getSampleDocsForCompletion(): Promise<Document[]>;
}
export type GetShardDistributionResult = {
    Totals: {
        data: string;
        docs: number;
        chunks: number;
    } & {
        [individualShardDistribution: `Shard ${string}`]: [
            `${number} % data`,
            `${number} % docs in cluster`,
            `${string} avg obj size on shard`
        ];
    };
    [individualShardResult: `Shard ${string} at ${string}`]: {
        data: string;
        docs: number;
        chunks: number;
        'estimated data per chunk': string;
        'estimated docs per chunk': number;
    };
};