import { Observable } from 'rxjs';
import { Auth } from './Auth';
import { AggregateOptions, BulkWriteResult, ChangeStreamOptions, Document, DocumentEvent, DocumentExtraOptions, DocumentFilter, DocumentLiveQuery, DocumentOptions, DocumentPipeline, DocumentQuery, FindOptions, LiveQueryMessage, ManyInsertResponse, ManyUpdateResponse, ManyUpsertResponse, QueryMethod, Sort } from './types';
export type MaybeArray<T> = T | T[];
export type RunResult<TSchema = Document> = number | MaybeArray<TSchema> | ManyInsertResponse<TSchema> | ManyUpdateResponse | ManyUpsertResponse | BulkWriteResult | void;
export declare const BordaLiveQueryMemo: Map<string, WebSocket>;
export declare class BordaQuery<TSchema = Document> {
    #private;
    get app(): string;
    get collection(): string;
    get inspect(): boolean;
    get unlocked(): boolean;
    get auth(): Auth;
    constructor({ app, inspect, collection, auth, }: {
        app: string;
        collection: string;
        inspect?: boolean;
        auth?: Auth;
    });
    /**
     * unlock can only be used in server environment
     * with proper ApiKey+ApiSecret defined
     */
    unlock(isUnlocked?: boolean): this;
    /**
     * doc modifiers
     */
    projection(project: any): this;
    sort(by: Sort): this;
    filter(by: DocumentFilter<TSchema>): this;
    limit(by: number): this;
    skip(by: number): this;
    include(fields: string[]): this;
    exclude(fields: string[]): this;
    pipeline(docs: DocumentPipeline<TSchema>[]): this;
    /**
     * find documents using mongo-like queries
     */
    find(options?: FindOptions & DocumentExtraOptions): Promise<TSchema[]>;
    /**
     * find a document using mongo-like queries
     * or direclty by passing its objectId
     */
    findOne(objectId: string): Promise<TSchema>;
    findOne(objectId: string, options?: FindOptions & DocumentExtraOptions): Promise<TSchema>;
    findOne(options?: DocumentExtraOptions): Promise<TSchema>;
    /**
     * update a document using mongo-like queries
     * or direclty by passing its objectId
     */
    update(doc: TSchema, options?: DocumentExtraOptions): Promise<void>;
    update(objectId: string, doc: TSchema, options?: DocumentExtraOptions): Promise<void>;
    updateMany(doc: TSchema, options?: DocumentExtraOptions): Promise<ManyUpdateResponse>;
    insert(doc: Partial<Document>, options?: DocumentExtraOptions): Promise<TSchema>;
    /**
     * insert many documents
     * The number of operations in each group cannot exceed the value of the maxWriteBatchSize of the database. As of MongoDB 3.6, this value is 100,000.
     * learn more https://www.mongodb.com/docs/manual/reference/method/db.collection.insertMany/
     */
    insertMany(docs: Partial<TSchema>[], options?: DocumentExtraOptions): Promise<ManyInsertResponse<TSchema>>;
    /**
     * update or insert a document
     */
    upsert(doc: Partial<TSchema>, options?: DocumentExtraOptions): Promise<BulkWriteResult>;
    /**
     * update or insert many documents
     */
    upsertMany(docs: Partial<TSchema>[], options?: DocumentExtraOptions): Promise<ManyUpsertResponse>;
    /**
     * delete a document using mongo-like queries
     * or direclty by passing its objectId
     */
    delete(options?: DocumentExtraOptions): Promise<void>;
    delete(objectId: string, options?: DocumentExtraOptions): Promise<void>;
    deleteMany(options?: DocumentExtraOptions): Promise<ManyUpdateResponse>;
    /**
     * count documents using mongo-like queries
     */
    count(options?: FindOptions & DocumentExtraOptions): Promise<number>;
    /**
     * aggregate documents using mongo-like queries
     */
    aggregate(options?: AggregateOptions & DocumentExtraOptions): Promise<TSchema[]>;
    /**
     * doc retrieval
     */
    run(method: QueryMethod, options?: DocumentOptions, docOrDocs?: Partial<TSchema> | Partial<TSchema>[], objectId?: string): Promise<RunResult<TSchema>>;
    on(event: DocumentEvent, options?: ChangeStreamOptions): Observable<LiveQueryMessage<TSchema>>;
    once(): Observable<LiveQueryMessage<TSchema>>;
    get bridge(): {
        run: (query: DocumentQuery<TSchema>) => Promise<number | void | ManyUpdateResponse | ManyUpsertResponse | BulkWriteResult | TSchema[] | ManyInsertResponse<TSchema> | Awaited<TSchema>>;
        on: (query: DocumentLiveQuery<TSchema>) => Observable<LiveQueryMessage<TSchema>>;
        once: (query: DocumentLiveQuery<TSchema>) => Observable<LiveQueryMessage<TSchema>>;
    };
}
export declare class BordaClientQuery<TSchema = Document> extends BordaQuery<TSchema> {
    #private;
    constructor({ app, auth, inspect, collection, serverURL, serverKey, serverSecret, serverHeaderPrefix, webSocketURL, }: {
        app: string;
        auth: Auth;
        collection: string;
        inspect?: boolean;
        serverURL: string;
        serverKey: string;
        serverSecret: string;
        serverHeaderPrefix: string;
        webSocketURL?: string;
    });
    get bridge(): {
        run: ({ collection, pipeline, method, objectId, filter, doc, docs, options, unlock, projection, sort, limit, skip, include, exclude, }: DocumentQuery<TSchema>) => Promise<number | void | ManyUpdateResponse | ManyUpsertResponse | BulkWriteResult | TSchema[] | ManyInsertResponse<TSchema>>;
        on: (liveQuery: DocumentLiveQuery<TSchema>, options?: ChangeStreamOptions) => Observable<LiveQueryMessage<TSchema>>;
        once: (liveQuery: DocumentLiveQuery<TSchema>) => Observable<LiveQueryMessage<TSchema>>;
    };
}