import type { Collection, Document, OptionalUnlessRequiredId, WithId, UpdateFilter, InsertManyResult, UpdateResult, WithoutId, AggregationCursor, FindCursor, DeleteResult, InsertOneResult, ModifyResult } from 'mongodb';
import { HookedFindCursor, HookedFindCursorOptions } from "./hookedFindCursor.js";
import { HookedListenerCallback, AmendedFindOptions, AmendedDistinctOptions, AmendedAggregateOptions, AmendedInsertOneOptions, AmendedBulkWriteOptions, AmendedReplaceOptions, AmendedUpdateOptions, AmendedDeleteOptions, CollectionHookedEventMap, HookedCollectionInterface, ChainedCallbackEventMapWithCaller } from "./events/index.js";
import { AbstractHookedCollection } from "./abstractCollectionImpl.js";
import { CallbackAndOptionsOfEm, StandardInvokeHookOptions } from './awaiatableEventEmitter.js';
import { AmendedCountDocumentsOptions, AmendedCountOptions, AmendedEstimatedDocumentCountOptions, AmendedFindOneAndDeleteOptions, AmendedFindOneAndReplaceOptions, AmendedFindOneAndUpdateOptions, AmendedFindOneOptions, CollectionOnlyBeforeAfterErrorEventDefinitions, MaybeStrictFilter, ExternalBeforeAfterEvent } from './events/collectionEvents.js';
import { BeforeAfterErrorSharedEventDefinitions } from './events/sharedEvents.js';
import { BeforeAfterCallbackArgsAndReturn, CommonDefinition, ExtractStandardBeforeAfterEventDefinitions, KeysMatching, Merge } from './events/helpersTypes.js';
interface HookedFindCursorConstructor {
    new <CuSchema extends Document, CoSchema extends Document>(filter: MaybeStrictFilter<CoSchema> | undefined, cursor: FindCursor<CuSchema>, options: HookedFindCursorOptions<CuSchema>): HookedFindCursor<CuSchema>;
}
type HookedCollectionOptions = {
    transform?: (doc: any) => any;
    findCursorImpl?: HookedFindCursorConstructor;
    interceptExecute?: boolean;
};
export type StandardInvokeHookOptionsFromCollection<T> = T extends HookedCollection<any, any, any, any, infer AllEvents> ? StandardInvokeHookOptions<AllEvents> : never;
export type AllEventsFromCollection<T> = T extends HookedCollection<infer _TSchema, any, any, any, infer AllEvents> ? AllEvents : never;
export declare class HookedCollection<TSchema extends Document = Document, ExtraBeforeAfterEvents extends Record<string, ExternalBeforeAfterEvent<CommonDefinition & {
    result: any;
}>> = {}, ExtractedEvents extends ExtractStandardBeforeAfterEventDefinitions<ExtraBeforeAfterEvents> = ExtractStandardBeforeAfterEventDefinitions<ExtraBeforeAfterEvents>, ExtraEvents extends ChainedCallbackEventMapWithCaller = BeforeAfterCallbackArgsAndReturn<ExtractedEvents>, AllEvents extends (ChainedCallbackEventMapWithCaller & CollectionHookedEventMap<TSchema>) = Merge<CollectionHookedEventMap<TSchema>, ExtraEvents>> extends AbstractHookedCollection<TSchema> implements HookedCollectionInterface<TSchema> {
    #private;
    static Events: {
        before: {
            find: "before.find";
            update: "before.update";
            count: "before.count";
            delete: "before.delete";
            insert: "before.insert";
            aggregate: "before.aggregate";
            "find.cursor.next": "before.find.cursor.next";
            "find.cursor.toArray": "before.find.cursor.toArray";
            "find.cursor.forEach": "before.find.cursor.forEach";
            "find.cursor.asyncIterator": "before.find.cursor.asyncIterator";
            "aggregation.cursor.next": "before.aggregation.cursor.next";
            "aggregation.cursor.toArray": "before.aggregation.cursor.toArray";
            "aggregation.cursor.forEach": "before.aggregation.cursor.forEach";
            "aggregation.cursor.asyncIterator": "before.aggregation.cursor.asyncIterator";
            "aggregation.cursor.execute": "before.aggregation.cursor.execute";
            "find.cursor.execute": "before.find.cursor.execute";
            "aggregation.cursor.rewind": "before.aggregation.cursor.rewind";
            "find.cursor.rewind": "before.find.cursor.rewind";
            "aggregation.cursor.close": "before.aggregation.cursor.close";
            "find.cursor.close": "before.find.cursor.close";
            "cursor.execute": "before.cursor.execute";
            "cursor.next": "before.cursor.next";
            "cursor.toArray": "before.cursor.toArray";
            "cursor.forEach": "before.cursor.forEach";
            "cursor.asyncIterator": "before.cursor.asyncIterator";
            "cursor.rewind": "before.cursor.rewind";
            "cursor.close": "before.cursor.close";
            "*": "before.*";
            findOne: "before.findOne";
            insertOne: "before.insertOne";
            insertMany: "before.insertMany";
            deleteOne: "before.deleteOne";
            deleteMany: "before.deleteMany";
            replaceOne: "before.replaceOne";
            updateOne: "before.updateOne";
            updateMany: "before.updateMany";
            distinct: "before.distinct";
            countDocuments: "before.countDocuments";
            estimatedDocumentCount: "before.estimatedDocumentCount";
            "count*": "before.count*";
            "findOne*": "before.findOne*";
            findOneAndDelete: "before.findOneAndDelete";
            findOneAndUpdate: "before.findOneAndUpdate";
            findOneAndReplace: "before.findOneAndReplace";
            "find.cursor.count": "before.find.cursor.count";
        };
        afterSuccess: {
            find: "after.find.success";
            update: "after.update.success";
            count: "after.count.success";
            delete: "after.delete.success";
            insert: "after.insert.success";
            aggregate: "after.aggregate.success";
            "find.cursor.next": "after.find.cursor.next.success";
            "find.cursor.toArray": "after.find.cursor.toArray.success";
            "find.cursor.forEach": "after.find.cursor.forEach.success";
            "find.cursor.asyncIterator": "after.find.cursor.asyncIterator.success";
            "aggregation.cursor.next": "after.aggregation.cursor.next.success";
            "aggregation.cursor.toArray": "after.aggregation.cursor.toArray.success";
            "aggregation.cursor.forEach": "after.aggregation.cursor.forEach.success";
            "aggregation.cursor.asyncIterator": "after.aggregation.cursor.asyncIterator.success";
            "aggregation.cursor.execute": "after.aggregation.cursor.execute.success";
            "find.cursor.execute": "after.find.cursor.execute.success";
            "aggregation.cursor.rewind": "after.aggregation.cursor.rewind.success";
            "find.cursor.rewind": "after.find.cursor.rewind.success";
            "aggregation.cursor.close": "after.aggregation.cursor.close.success";
            "find.cursor.close": "after.find.cursor.close.success";
            "cursor.execute": "after.cursor.execute.success";
            "cursor.next": "after.cursor.next.success";
            "cursor.toArray": "after.cursor.toArray.success";
            "cursor.forEach": "after.cursor.forEach.success";
            "cursor.asyncIterator": "after.cursor.asyncIterator.success";
            "cursor.rewind": "after.cursor.rewind.success";
            "cursor.close": "after.cursor.close.success";
            "*": "after.*.success";
            findOne: "after.findOne.success";
            insertOne: "after.insertOne.success";
            insertMany: "after.insertMany.success";
            deleteOne: "after.deleteOne.success";
            deleteMany: "after.deleteMany.success";
            replaceOne: "after.replaceOne.success";
            updateOne: "after.updateOne.success";
            updateMany: "after.updateMany.success";
            distinct: "after.distinct.success";
            countDocuments: "after.countDocuments.success";
            estimatedDocumentCount: "after.estimatedDocumentCount.success";
            "count*": "after.count*.success";
            "findOne*": "after.findOne*.success";
            findOneAndDelete: "after.findOneAndDelete.success";
            findOneAndUpdate: "after.findOneAndUpdate.success";
            findOneAndReplace: "after.findOneAndReplace.success";
            "find.cursor.count": "after.find.cursor.count.success";
        };
        afterError: {
            find: "after.find.error";
            update: "after.update.error";
            count: "after.count.error";
            delete: "after.delete.error";
            insert: "after.insert.error";
            aggregate: "after.aggregate.error";
            "find.cursor.next": "after.find.cursor.next.error";
            "find.cursor.toArray": "after.find.cursor.toArray.error";
            "find.cursor.forEach": "after.find.cursor.forEach.error";
            "find.cursor.asyncIterator": "after.find.cursor.asyncIterator.error";
            "aggregation.cursor.next": "after.aggregation.cursor.next.error";
            "aggregation.cursor.toArray": "after.aggregation.cursor.toArray.error";
            "aggregation.cursor.forEach": "after.aggregation.cursor.forEach.error";
            "aggregation.cursor.asyncIterator": "after.aggregation.cursor.asyncIterator.error";
            "aggregation.cursor.execute": "after.aggregation.cursor.execute.error";
            "find.cursor.execute": "after.find.cursor.execute.error";
            "aggregation.cursor.rewind": "after.aggregation.cursor.rewind.error";
            "find.cursor.rewind": "after.find.cursor.rewind.error";
            "aggregation.cursor.close": "after.aggregation.cursor.close.error";
            "find.cursor.close": "after.find.cursor.close.error";
            "cursor.execute": "after.cursor.execute.error";
            "cursor.next": "after.cursor.next.error";
            "cursor.toArray": "after.cursor.toArray.error";
            "cursor.forEach": "after.cursor.forEach.error";
            "cursor.asyncIterator": "after.cursor.asyncIterator.error";
            "cursor.rewind": "after.cursor.rewind.error";
            "cursor.close": "after.cursor.close.error";
            "*": "after.*.error";
            findOne: "after.findOne.error";
            insertOne: "after.insertOne.error";
            insertMany: "after.insertMany.error";
            deleteOne: "after.deleteOne.error";
            deleteMany: "after.deleteMany.error";
            replaceOne: "after.replaceOne.error";
            updateOne: "after.updateOne.error";
            updateMany: "after.updateMany.error";
            distinct: "after.distinct.error";
            countDocuments: "after.countDocuments.error";
            estimatedDocumentCount: "after.estimatedDocumentCount.error";
            "count*": "after.count*.error";
            "findOne*": "after.findOne*.error";
            findOneAndDelete: "after.findOneAndDelete.error";
            findOneAndUpdate: "after.findOneAndUpdate.error";
            findOneAndReplace: "after.findOneAndReplace.error";
            "find.cursor.count": "after.find.cursor.count.error";
        };
        after: {
            find: "after.find";
            update: "after.update";
            count: "after.count";
            delete: "after.delete";
            insert: "after.insert";
            aggregate: "after.aggregate";
            "find.cursor.next": "after.find.cursor.next";
            "find.cursor.toArray": "after.find.cursor.toArray";
            "find.cursor.forEach": "after.find.cursor.forEach";
            "find.cursor.asyncIterator": "after.find.cursor.asyncIterator";
            "aggregation.cursor.next": "after.aggregation.cursor.next";
            "aggregation.cursor.toArray": "after.aggregation.cursor.toArray";
            "aggregation.cursor.forEach": "after.aggregation.cursor.forEach";
            "aggregation.cursor.asyncIterator": "after.aggregation.cursor.asyncIterator";
            "aggregation.cursor.execute": "after.aggregation.cursor.execute";
            "find.cursor.execute": "after.find.cursor.execute";
            "aggregation.cursor.rewind": "after.aggregation.cursor.rewind";
            "find.cursor.rewind": "after.find.cursor.rewind";
            "aggregation.cursor.close": "after.aggregation.cursor.close";
            "find.cursor.close": "after.find.cursor.close";
            "cursor.execute": "after.cursor.execute";
            "cursor.next": "after.cursor.next";
            "cursor.toArray": "after.cursor.toArray";
            "cursor.forEach": "after.cursor.forEach";
            "cursor.asyncIterator": "after.cursor.asyncIterator";
            "cursor.rewind": "after.cursor.rewind";
            "cursor.close": "after.cursor.close";
            "*": "after.*";
            findOne: "after.findOne";
            insertOne: "after.insertOne";
            insertMany: "after.insertMany";
            deleteOne: "after.deleteOne";
            deleteMany: "after.deleteMany";
            replaceOne: "after.replaceOne";
            updateOne: "after.updateOne";
            updateMany: "after.updateMany";
            distinct: "after.distinct";
            countDocuments: "after.countDocuments";
            estimatedDocumentCount: "after.estimatedDocumentCount";
            "count*": "after.count*";
            "findOne*": "after.findOne*";
            findOneAndDelete: "after.findOneAndDelete";
            findOneAndUpdate: "after.findOneAndUpdate";
            findOneAndReplace: "after.findOneAndReplace";
            "find.cursor.count": "after.find.cursor.count";
        };
    };
    map: CollectionHookedEventMap<TSchema>;
    constructor(collection: Collection<TSchema>, options?: HookedCollectionOptions);
    aggregate<T extends Document>(pipeline: Document[], options?: AmendedAggregateOptions): AggregationCursor<T>;
    /**
     * This function should be used exclusively to allow for instrumentation
     * it should be called at most once and calling this arbitrarily at runtime has undefined behaviour
     * it's expected to be used as follows: myCollection._setCollection(instrument(myCollection.rawCollection()))
     * this can be combined with patching the AbstractHookedCollection's init to ensure that all collections created will have an instrumented base collection
     * @param collection the collection to use
     */
    _setCollection(collection: Collection<TSchema>): void;
    rawCollection(): Collection<TSchema>;
    distinct<Key extends keyof WithId<TSchema>>(key: Key, filter?: MaybeStrictFilter<TSchema>, options?: AmendedDistinctOptions): Promise<import("mongodb").Flatten<WithId<TSchema>["_id" | keyof import("mongodb").EnhancedOmit<TSchema, "_id">]>[]>;
    findOne<T extends Document = TSchema>(filter?: MaybeStrictFilter<TSchema>, options?: AmendedFindOneOptions<TSchema> | undefined): Promise<T | null>;
    find<T extends Document = TSchema>(filter?: MaybeStrictFilter<TSchema>, options?: AmendedFindOptions<TSchema>): HookedFindCursor<T, TSchema>;
    protected _tryCatchEmit<HEM extends AllEvents, T extends (callArgs: HEM[BE]["emitArgs"]["args"] extends never ? {
        invocationSymbol: symbol;
    } : HEM[BE] extends {
        returns: any;
    } ? {
        invocationSymbol: symbol;
        beforeHooksResult: HEM[BE]["returns"];
    } : {
        invocationSymbol: symbol;
    }) => Promise<HEM[AE]["emitArgs"]["result"]>, BE extends `before.${IE}` & keyof HEM, AE extends `after.${IE}.success` & keyof HEM, IE extends keyof CollectionOnlyBeforeAfterErrorEventDefinitions<TSchema> | keyof BeforeAfterErrorSharedEventDefinitions<TSchema> | (KeysMatching<ExtraBeforeAfterEvents, {
        forCollection: true;
    }> & string), OIE extends keyof CollectionOnlyBeforeAfterErrorEventDefinitions<TSchema> | keyof BeforeAfterErrorSharedEventDefinitions<TSchema> | (KeysMatching<ExtraBeforeAfterEvents, {
        forCollection: true;
    }> & string), EA extends HEM[BE]["emitArgs"], OEA extends Omit<EA, "invocationSymbol" | "thisArg" | "signal">>(internalEvent: IE, emitArgs: OEA, beforeChainKey: (keyof OEA & HEM[BE]["returnEmitName"]) | undefined, fn: T, invocationOptions: StandardInvokeHookOptions<AllEvents, `before.${IE}` | `after.${IE}.success`> | undefined, ...additionalInternalEvents: OIE[] | {
        event: OIE;
        emitArgs: Partial<HEM[`before.${OIE}`]["emitArgs"]>;
    }[]): Promise<Awaited<ReturnType<T>>>;
    insertOne(doc: OptionalUnlessRequiredId<TSchema>, options?: AmendedInsertOneOptions): Promise<InsertOneResult<TSchema>>;
    insertMany(docs: OptionalUnlessRequiredId<TSchema>[], options?: AmendedBulkWriteOptions): Promise<InsertManyResult<TSchema>>;
    replaceOne(filter: MaybeStrictFilter<TSchema>, replacement: WithoutId<TSchema>, options?: AmendedReplaceOptions | undefined): Promise<Document | UpdateResult<TSchema>>;
    updateOne(filter: MaybeStrictFilter<TSchema>, update: UpdateFilter<TSchema> | Partial<TSchema>, options?: AmendedUpdateOptions): Promise<UpdateResult<TSchema>>;
    updateMany(filter: MaybeStrictFilter<TSchema>, update: UpdateFilter<TSchema>, options?: AmendedUpdateOptions | undefined): Promise<UpdateResult<TSchema>>;
    deleteOne(filter?: MaybeStrictFilter<TSchema>, options?: AmendedDeleteOptions): Promise<DeleteResult>;
    deleteMany(filter?: MaybeStrictFilter<TSchema>, options?: AmendedDeleteOptions): Promise<DeleteResult>;
    hooks<K extends keyof AllEvents>(eventName: K): CallbackAndOptionsOfEm<AllEvents, K>[];
    allHooksWithOptions(): {
        hook: import("./awaiatableEventEmitter.js").ChainedListenerCallback<AllEvents, keyof AllEvents>;
        eventName: keyof AllEvents;
        options: AllEvents[keyof AllEvents]["options"] | undefined;
    }[];
    on<K extends keyof AllEvents>(eventName: K, listener: HookedListenerCallback<K, AllEvents>, options?: AllEvents[K]["options"]): this;
    off<K extends keyof AllEvents>(eventName: K, listener: HookedListenerCallback<K, AllEvents>): this;
    count(filter?: MaybeStrictFilter<TSchema> | undefined, options?: AmendedCountOptions | undefined): Promise<number>;
    estimatedDocumentCount(options?: AmendedEstimatedDocumentCountOptions | undefined): Promise<number>;
    countDocuments(filter?: MaybeStrictFilter<Document> | undefined, options?: AmendedCountDocumentsOptions | undefined): Promise<number>;
    findOneAndDelete(filter: MaybeStrictFilter<TSchema>, options: AmendedFindOneAndDeleteOptions<TSchema> & {
        includeResultMetadata: true;
    }): Promise<ModifyResult<TSchema>>;
    findOneAndDelete(filter: MaybeStrictFilter<TSchema>, options: AmendedFindOneAndDeleteOptions<TSchema> & {
        includeResultMetadata: false;
    }): Promise<WithId<TSchema> | null>;
    findOneAndDelete(filter: MaybeStrictFilter<TSchema>, options: AmendedFindOneAndDeleteOptions<TSchema>): Promise<ModifyResult<TSchema>>;
    findOneAndDelete(filter: MaybeStrictFilter<TSchema>): Promise<ModifyResult<TSchema>>;
    findOneAndUpdate(filter: MaybeStrictFilter<TSchema>, update: UpdateFilter<TSchema>, options: AmendedFindOneAndUpdateOptions<TSchema> & {
        includeResultMetadata: true;
    }): Promise<ModifyResult<TSchema>>;
    findOneAndUpdate(filter: MaybeStrictFilter<TSchema>, update: UpdateFilter<TSchema>, options: AmendedFindOneAndUpdateOptions<TSchema> & {
        includeResultMetadata: false;
    }): Promise<WithId<TSchema> | null>;
    findOneAndUpdate(filter: MaybeStrictFilter<TSchema>, update: UpdateFilter<TSchema>, options: AmendedFindOneAndUpdateOptions<TSchema>): Promise<WithId<TSchema> | null>;
    findOneAndUpdate(filter: MaybeStrictFilter<TSchema>, update: UpdateFilter<TSchema>): Promise<ModifyResult<TSchema>>;
    findOneAndReplace(filter: MaybeStrictFilter<TSchema>, replacement: WithoutId<TSchema>, options: AmendedFindOneAndReplaceOptions<TSchema> & {
        includeResultMetadata: true;
    }): Promise<ModifyResult<TSchema>>;
    findOneAndReplace(filter: MaybeStrictFilter<TSchema>, replacement: WithoutId<TSchema>, options: AmendedFindOneAndReplaceOptions<TSchema> & {
        includeResultMetadata: false;
    }): Promise<WithId<TSchema> | null>;
    findOneAndReplace(filter: MaybeStrictFilter<TSchema>, replacement: WithoutId<TSchema>, options: AmendedFindOneAndReplaceOptions<TSchema>): Promise<ModifyResult<TSchema>>;
    findOneAndReplace(filter: MaybeStrictFilter<TSchema>, replacement: WithoutId<TSchema>): Promise<ModifyResult<TSchema>>;
}
export {};