/**
 * CRYSTALS-Kyber Key Encapsulation Mechanism (ML-KEM)
 *
 * Implements CRYSTALS-Kyber key encapsulation as specified in FIPS 203.
 * Kyber is a lattice-based KEM selected by NIST for post-quantum standardization.
 *
 * Security Levels:
 * - Kyber512: NIST Level 1 (equivalent to AES-128)
 * - Kyber768: NIST Level 3 (equivalent to AES-192) - RECOMMENDED
 * - Kyber1024: NIST Level 5 (equivalent to AES-256)
 *
 * PRODUCTION NOTE:
 * This implementation uses a reference implementation for demonstration.
 * For production use, integrate with:
 * - liboqs-node (https://github.com/nickolasburr/liboqs-node)
 * - @cloudflare/pq-crypto
 * - Native OpenSSL 3.2+ with provider
 *
 * @packageDocumentation
 * @module security/crypto/post-quantum/kyber
 */
import { VorionError } from '../../../common/errors.js';
import { type KyberKeyPair, type EncapsulationResult, type DecapsulationResult, type KyberConfig, type KyberParameterSet, type ClassicalKEMAlgorithm, type HybridKEMKeyPair, type HybridEncapsulationResult, KYBER_PARAMETERS } from './types.js';
/**
 * Kyber-specific error
 */
export declare class KyberError extends VorionError {
    readonly errorCode: string;
    code: string;
    statusCode: number;
    constructor(message: string, errorCode?: string, details?: Record<string, unknown>);
}
/**
 * CRYSTALS-Kyber Key Encapsulation Service
 *
 * Provides post-quantum secure key encapsulation using CRYSTALS-Kyber (ML-KEM).
 *
 * @example
 * ```typescript
 * const kyber = new KyberService();
 *
 * // Generate a key pair
 * const keyPair = await kyber.generateKeyPair('kyber768');
 *
 * // Encapsulate (sender side)
 * const { ciphertext, sharedSecret: senderSecret } = await kyber.encapsulate(keyPair.publicKey, 'kyber768');
 *
 * // Decapsulate (recipient side)
 * const { sharedSecret: recipientSecret } = await kyber.decapsulate(keyPair.privateKey, ciphertext, 'kyber768');
 *
 * // senderSecret === recipientSecret
 * ```
 */
export declare class KyberService {
    private readonly config;
    private nativeAvailable;
    constructor(config?: Partial<KyberConfig>);
    /**
     * Initialize the service and detect native bindings
     */
    initialize(): Promise<void>;
    /**
     * Check if native bindings are available
     */
    isNativeAvailable(): boolean;
    /**
     * Get parameter specifications for a parameter set
     */
    getParameters(parameterSet?: KyberParameterSet): typeof KYBER_PARAMETERS[KyberParameterSet];
    /**
     * Generate a Kyber key pair
     *
     * @param parameterSet - Kyber parameter set (default: configured default)
     * @returns Generated key pair
     */
    generateKeyPair(parameterSet?: KyberParameterSet): Promise<KyberKeyPair>;
    /**
     * Encapsulate a shared secret using a public key
     *
     * @param publicKey - Recipient's public key
     * @param parameterSet - Kyber parameter set
     * @returns Ciphertext and shared secret
     */
    encapsulate(publicKey: Uint8Array, parameterSet?: KyberParameterSet): Promise<EncapsulationResult>;
    /**
     * Decapsulate a shared secret using a private key
     *
     * @param privateKey - Recipient's private key
     * @param ciphertext - Ciphertext from sender
     * @param parameterSet - Kyber parameter set
     * @returns Recovered shared secret
     */
    decapsulate(privateKey: Uint8Array, ciphertext: Uint8Array, parameterSet?: KyberParameterSet): Promise<DecapsulationResult>;
    /**
     * Generate a hybrid key pair (X25519 + Kyber)
     *
     * @param kyberParameterSet - Kyber parameter set
     * @param classicalAlgorithm - Classical algorithm (default: X25519)
     * @returns Hybrid key pair
     */
    generateHybridKeyPair(kyberParameterSet?: KyberParameterSet, classicalAlgorithm?: ClassicalKEMAlgorithm): Promise<HybridKEMKeyPair>;
    /**
     * Hybrid encapsulation (X25519 + Kyber)
     *
     * @param hybridPublicKey - Hybrid public key (classical + PQ)
     * @param classicalAlgorithm - Classical algorithm
     * @param kyberParameterSet - Kyber parameter set
     * @returns Hybrid encapsulation result
     */
    hybridEncapsulate(classicalPublicKey: Uint8Array, pqPublicKey: Uint8Array, classicalAlgorithm?: ClassicalKEMAlgorithm, kyberParameterSet?: KyberParameterSet): Promise<HybridEncapsulationResult>;
    /**
     * Hybrid decapsulation (X25519 + Kyber)
     */
    hybridDecapsulate(classicalPrivateKey: Uint8Array, pqPrivateKey: Uint8Array, ciphertext: Uint8Array, classicalAlgorithm?: ClassicalKEMAlgorithm, kyberParameterSet?: KyberParameterSet): Promise<{
        sharedSecret: Uint8Array;
        success: boolean;
    }>;
    /**
     * Get service configuration
     */
    getConfig(): Readonly<KyberConfig>;
}
/**
 * Create a Kyber service instance
 */
export declare function createKyberService(config?: Partial<KyberConfig>): KyberService;
/**
 * Create and initialize a Kyber service
 */
export declare function createInitializedKyberService(config?: Partial<KyberConfig>): Promise<KyberService>;
//# sourceMappingURL=kyber.d.ts.map