export interface KeyPair {
    publicKey: Uint8Array;
    privateKey: Uint8Array;
}
export interface EncryptedMessage {
    dhPublicKey: Uint8Array;
    iv: Uint8Array;
    ciphertext: Uint8Array;
    messageNumber: number;
}
export interface RatchetOptions {
    keyPair: KeyPair;
    isInitiator: boolean;
    verboseLog?: boolean;
    revertStateOnFailure?: boolean;
}
export interface MessageCounter {
    chainKey: Uint8Array;
    messageNumber: number;
}
export interface RatchetState {
    rootKey: Uint8Array;
    sendChainKey: Uint8Array;
    recvChainKey: Uint8Array;
    remotePublicKey: Uint8Array;
    sendMessageNumber: number;
    recvMessageNumber: number;
    previousChainLength: number;
    needToRatchet: boolean;
    isFirstMessage: boolean;
    isInitiator: boolean;
    sentPublicKeys: string[];
    currentDHPublicKey: Uint8Array;
    currentDHPrivateKey: Uint8Array;
    messageKeyCache: {
        [chainKey: string]: {
            [messageNumber: number]: string;
        };
    };
    sentMessageKeyCache: {
        [chainKey: string]: {
            [messageNumber: number]: string;
        };
    };
}
export declare class Ratchet {
    private readonly crypto;
    private readonly subtle;
    private initialPublicKey;
    private initialPrivateKey;
    private currentDHPublicKey;
    private currentDHPrivateKey;
    private rootKey;
    private sendChainKey;
    private recvChainKey;
    private remotePublicKey;
    private isInitiator;
    private needToRatchet;
    private isFirstMessage;
    private verboseLog;
    private debugLog;
    private revertStateOnFailure;
    private sendMessageNumber;
    private recvMessageNumber;
    private previousChainLength;
    private messageKeyCache;
    private sentMessageKeyCache;
    private sentPublicKeys;
    private readonly MAX_SKIP;
    private readonly MAX_CACHE_SIZE;
    private readonly MESSAGE_KEY_TTL;
    constructor(options: RatchetOptions);
    private hkdf;
    private kdfRoot;
    private kdfChainKey;
    private kdfMessageKey;
    initialize(remotePublicKey: Uint8Array): Promise<void>;
    private getCacheKey;
    private storeReceivedMessageKey;
    encrypt(plaintext: string): Promise<EncryptedMessage>;
    decrypt(packet: EncryptedMessage): Promise<string>;
    private decryptReceivedMessage;
    private storeSentMessageKey;
    isSentMessage(packet: EncryptedMessage): boolean;
    restoreState(state: RatchetState): void;
    getState(): RatchetState;
    private publicKeyToString;
    private areBuffersEqual;
}