import { DecryptionError } from "../common";
import { ILock } from "../../../utils/Lock";
import { Session } from "./Session";
import { DecryptionResult } from "../DecryptionResult";
import type { OlmMessage, OlmPayload } from "./types";
import type { Account } from "../Account";
import type { LockMap } from "../../../utils/LockMap";
import type { Transaction } from "../../storage/idb/Transaction";
import type { OlmEncryptedEvent } from "./types";
import type * as OlmNamespace from "@matrix-org/olm";
type Olm = typeof OlmNamespace;
type DecryptionResults = {
    results: DecryptionResult[];
    errors: DecryptionError[];
    senderKeyDecryption: SenderKeyDecryption;
};
type CreateAndDecryptResult = {
    session: Session;
    plaintext: string;
};
export declare class Decryption {
    private readonly account;
    private readonly pickleKey;
    private readonly now;
    private readonly ownUserId;
    private readonly olm;
    private readonly senderKeyLock;
    constructor(account: Account, pickleKey: string, now: () => number, ownUserId: string, olm: Olm, senderKeyLock: LockMap<string>);
    obtainDecryptionLock(events: OlmEncryptedEvent[]): Promise<ILock>;
    /**
     * It is importants the lock obtained from obtainDecryptionLock is for the same set of events as passed in here.
     * [decryptAll description]
     * @param  {[type]} events
     * @return {Promise<DecryptionChanges>}        [description]
     */
    decryptAll(events: OlmEncryptedEvent[], lock: ILock, txn: Transaction): Promise<DecryptionChanges>;
    _decryptAllForSenderKey(senderKey: string, events: OlmEncryptedEvent[], timestamp: number, readSessionsTxn: Transaction): Promise<DecryptionResults>;
    _decryptForSenderKey(senderKeyDecryption: SenderKeyDecryption, event: OlmEncryptedEvent, timestamp: number): DecryptionResult;
    _createSessionAndDecrypt(senderKey: string, message: OlmMessage, timestamp: number): CreateAndDecryptResult;
    _getMessageAndValidateEvent(event: OlmEncryptedEvent): OlmMessage;
    _getSessions(senderKey: string, txn: Transaction): Promise<Session[]>;
    _validatePayload(payload: OlmPayload, event: OlmEncryptedEvent): void;
}
declare class SenderKeyDecryption {
    readonly senderKey: string;
    readonly sessions: Session[];
    private readonly timestamp;
    constructor(senderKey: string, sessions: Session[], timestamp: number);
    addNewSession(session: Session): void;
    decrypt(message: OlmMessage): string | undefined;
    getModifiedSessions(): Session[];
    get hasNewSessions(): boolean;
    private decryptWithSession;
}
/**
 * @property {Array<DecryptionResult>} results
 * @property {Array<DecryptionError>} errors  see DecryptionError.event to retrieve the event that failed to decrypt.
 */
declare class DecryptionChanges {
    private readonly senderKeyDecryptions;
    readonly results: DecryptionResult[];
    readonly errors: DecryptionError[];
    private readonly account;
    private readonly lock;
    constructor(senderKeyDecryptions: SenderKeyDecryption[], results: DecryptionResult[], errors: DecryptionError[], account: Account, lock: ILock);
    get hasNewSessions(): boolean;
    write(txn: Transaction): void;
}
export {};