import type { SubtleAlgorithm, KeyUsage, BinaryLike, BufferLike, JWK, AnyAlgorithm, ImportFormat, EncryptDecryptParams } from './utils';
import { CryptoKey } from './keys';
import type { CryptoKeyPair } from './utils/types';
import type { EncapsulateResult } from './utils';
export declare const PQC_SEEDLESS_PKCS8_LENGTHS: Readonly<Record<string, number>>;
export declare function isCryptoKeyPair(result: CryptoKey | CryptoKeyPair): result is CryptoKeyPair;
export declare class Subtle {
    static supports(operation: string, algorithm: SubtleAlgorithm | AnyAlgorithm, lengthOrAdditionalAlgorithm?: unknown): boolean;
    decrypt(algorithm: EncryptDecryptParams, key: CryptoKey, data: BufferLike): Promise<ArrayBuffer>;
    digest(algorithm: SubtleAlgorithm | AnyAlgorithm, data: BufferLike): Promise<ArrayBuffer>;
    deriveBits(algorithm: SubtleAlgorithm, baseKey: CryptoKey, length?: number | null): Promise<ArrayBuffer>;
    deriveKey(algorithm: SubtleAlgorithm, baseKey: CryptoKey, derivedKeyAlgorithm: SubtleAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
    encrypt(algorithm: EncryptDecryptParams, key: CryptoKey, data: BufferLike): Promise<ArrayBuffer>;
    exportKey(format: ImportFormat, key: CryptoKey): Promise<ArrayBuffer | JWK>;
    wrapKey(format: ImportFormat, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: EncryptDecryptParams): Promise<ArrayBuffer>;
    unwrapKey(format: ImportFormat, wrappedKey: BufferLike, unwrappingKey: CryptoKey, unwrapAlgorithm: EncryptDecryptParams, unwrappedKeyAlgorithm: SubtleAlgorithm | AnyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
    generateKey(algorithm: SubtleAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey | CryptoKeyPair>;
    getPublicKey(key: CryptoKey, keyUsages: KeyUsage[]): Promise<CryptoKey>;
    importKey(format: ImportFormat, data: BufferLike | BinaryLike | JWK, algorithm: SubtleAlgorithm | AnyAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
    sign(algorithm: SubtleAlgorithm, key: CryptoKey, data: BufferLike): Promise<ArrayBuffer>;
    verify(algorithm: SubtleAlgorithm, key: CryptoKey, signature: BufferLike, data: BufferLike): Promise<boolean>;
    private _encapsulateCore;
    private _decapsulateCore;
    encapsulateBits(algorithm: SubtleAlgorithm, key: CryptoKey): Promise<EncapsulateResult>;
    encapsulateKey(algorithm: SubtleAlgorithm, key: CryptoKey, sharedKeyAlgorithm: SubtleAlgorithm | AnyAlgorithm, extractable: boolean, usages: KeyUsage[]): Promise<{
        key: CryptoKey;
        ciphertext: ArrayBuffer;
    }>;
    decapsulateBits(algorithm: SubtleAlgorithm, key: CryptoKey, ciphertext: BufferLike): Promise<ArrayBuffer>;
    decapsulateKey(algorithm: SubtleAlgorithm, key: CryptoKey, ciphertext: BufferLike, sharedKeyAlgorithm: SubtleAlgorithm | AnyAlgorithm, extractable: boolean, usages: KeyUsage[]): Promise<CryptoKey>;
}
export declare const subtle: Subtle;
//# sourceMappingURL=subtle.d.ts.map