import { type AbstractType } from "@dao-xyz/borsh";
import { Ed25519PublicKey } from "./ed25519.js";
import { X25519Keypair, X25519PublicKey } from "./x25519.js";
export * from "./errors.js";
export declare const equals: (array1?: Uint8Array, array2?: Uint8Array) => boolean;
export type MaybePromise<T> = Promise<T> | T;
export type PublicKeyEncryptionParameters = {
    type?: "publicKey";
    receiverPublicKeys: (X25519PublicKey | Ed25519PublicKey)[];
};
export type SymmetricKeyEncryptionParameters = {
    type?: "hash";
};
export type KeyExchangeOptions = PublicKeyEncryptionParameters | SymmetricKeyEncryptionParameters;
type EncryptReturnValue<T, Parameters extends KeyExchangeOptions> = EncryptedThing<T, EnvelopeFromParameter<Parameters>>;
type CipherWithEnvelope<E = PublicKeyEnvelope | HashedKeyEnvelope> = {
    cipher: Uint8Array;
    nonce: Uint8Array;
    envelope: E;
};
type SymmetricKeys = Uint8Array;
type PublicKeyEncryptionKeys = X25519Keypair;
type EnvelopeFromParameter<Parameters extends KeyExchangeOptions> = Parameters extends PublicKeyEncryptionParameters ? PublicKeyEnvelope : HashedKeyEnvelope;
type EncryptProvide<Parameters extends KeyExchangeOptions> = (bytes: Uint8Array, parameters: Parameters) => Promise<CipherWithEnvelope<EnvelopeFromParameter<Parameters>>>;
interface KeyProvider {
    exportByKey(publicKey: X25519PublicKey): Promise<X25519Keypair | undefined>;
}
export declare const createLocalEncryptProvider: <K extends PublicKeyEncryptionKeys | SymmetricKeys, Parameters extends KeyExchangeOptions = K extends PublicKeyEncryptionKeys ? PublicKeyEncryptionParameters : SymmetricKeyEncryptionParameters>(keys: K) => (bytes: Uint8Array, parameters: Parameters) => Promise<CipherWithEnvelope<EnvelopeFromParameter<Parameters>>>;
export type DecryptProvider = (encrypted: Uint8Array, nonce: Uint8Array, exchange: Envelope) => Promise<Uint8Array>;
type KeyResolver = <T extends X25519PublicKey | Uint8Array>(key: T) => Promise<(T extends X25519PublicKey ? X25519Keypair : Uint8Array) | undefined>;
export declare const createDecrypterFromKeyResolver: (keyResolver: KeyResolver) => DecryptProvider;
export declare abstract class MaybeEncrypted<T> {
    /**
     * Will throw error if not decrypted
     */
    get decrypted(): DecryptedThing<T>;
    decrypt(keyResolver?: X25519Keypair | KeyProvider): MaybePromise<DecryptedThing<T>>;
    decrypt(provider?: DecryptProvider): MaybePromise<DecryptedThing<T>>;
    equals(other: MaybeEncrypted<T>): boolean;
    /**
     * Clear cached data
     */
    clear(): void;
    abstract get byteLength(): number;
}
export declare class DecryptedThing<T> extends MaybeEncrypted<T> {
    _data?: Uint8Array;
    constructor(props?: {
        data?: Uint8Array;
        value?: T;
    });
    _value?: T;
    getValue(clazz: AbstractType<T>): T;
    encrypt<Parameters extends KeyExchangeOptions>(provider: EncryptProvide<Parameters>, parameters: Parameters): Promise<EncryptReturnValue<T, Parameters>>;
    encrypt(x25519Keypair: X25519Keypair, receiverPublicKeys: (X25519PublicKey | Ed25519PublicKey)[]): Promise<EncryptReturnValue<T, PublicKeyEncryptionParameters>>;
    get decrypted(): this;
    decrypt(): this;
    equals(other: MaybeEncrypted<T>): boolean;
    clear(): void;
    get byteLength(): number;
}
export declare class CipherWithNonce {
    nonce: Uint8Array;
    cipher: Uint8Array;
    constructor(props: {
        nonce: Uint8Array;
        cipher: Uint8Array;
    });
    equals(other: CipherWithNonce): boolean;
}
export declare class K {
    _encryptedKey: CipherWithNonce;
    _receiverPublicKey: X25519PublicKey;
    constructor(props: {
        encryptedKey: CipherWithNonce;
        receiverPublicKey: X25519PublicKey;
    });
    equals(other: K): boolean;
}
declare abstract class Envelope {
    abstract equals(other: Envelope): boolean;
}
declare class PublicKeyEnvelope extends Envelope {
    _senderPublicKey: X25519PublicKey;
    _ks: K[];
    constructor(props: {
        senderPublicKey: X25519PublicKey;
        ks: K[];
    });
    equals(other: PublicKeyEnvelope): boolean;
}
declare class HashedKeyEnvelope extends Envelope {
    hash: Uint8Array;
    constructor(props: {
        hash: Uint8Array;
    });
    equals(other: HashedKeyEnvelope): boolean;
}
export declare class EncryptedThing<T, E extends Envelope = PublicKeyEnvelope | HashedKeyEnvelope> extends MaybeEncrypted<T> {
    _encrypted: Uint8Array;
    _nonce: Uint8Array;
    _keyexchange: E;
    constructor(props: {
        encrypted: Uint8Array;
        nonce: Uint8Array;
        envelope: E;
    });
    _decrypted?: DecryptedThing<T>;
    get decrypted(): DecryptedThing<T>;
    decrypt(keyResolver?: X25519Keypair | KeyProvider): Promise<DecryptedThing<T>>;
    decrypt(provider?: DecryptProvider): Promise<DecryptedThing<T>>;
    equals(other: MaybeEncrypted<T>): boolean;
    clear(): void;
    get byteLength(): number;
}
//# sourceMappingURL=encryption.d.ts.map