/**
 * Post-Quantum Cryptography Module
 *
 * Provides post-quantum cryptographic primitives for the Vorion security platform:
 *
 * ## Key Encapsulation (KEM)
 * - **CRYSTALS-Kyber (ML-KEM)**: NIST FIPS 203 standardized KEM
 *   - Kyber512: Security Level 1
 *   - Kyber768: Security Level 3 (recommended)
 *   - Kyber1024: Security Level 5
 *
 * ## Digital Signatures
 * - **CRYSTALS-Dilithium (ML-DSA)**: NIST FIPS 204 standardized signatures
 *   - Dilithium2: Security Level 2
 *   - Dilithium3: Security Level 3 (recommended)
 *   - Dilithium5: Security Level 5
 *
 * ## Hybrid Modes
 * - X25519 + Kyber for KEM
 * - Ed25519 + Dilithium for signatures
 * - Configurable algorithm selection
 * - Backward compatibility support
 *
 * ## Migration Support
 * - Key rotation from classical to PQ
 * - Dual-signature verification
 * - Gradual rollout support
 * - Algorithm negotiation
 *
 * ## Usage
 *
 * ```typescript
 * import {
 *   createKyberService,
 *   createDilithiumService,
 *   createHybridCryptoProvider,
 *   createMigrationToolkit,
 * } from './security/crypto/post-quantum';
 *
 * // Key Encapsulation with Kyber
 * const kyber = createKyberService();
 * await kyber.initialize();
 *
 * const keyPair = await kyber.generateKeyPair('kyber768');
 * const { ciphertext, sharedSecret } = await kyber.encapsulate(keyPair.publicKey);
 * const { sharedSecret: recovered } = await kyber.decapsulate(keyPair.privateKey, ciphertext);
 *
 * // Digital Signatures with Dilithium
 * const dilithium = createDilithiumService();
 * await dilithium.initialize();
 *
 * const sigKeyPair = await dilithium.generateKeyPair('dilithium3');
 * const message = new TextEncoder().encode('Hello, PQ world!');
 * const { signature } = await dilithium.sign(sigKeyPair.privateKey, message);
 * const { valid } = await dilithium.verify(sigKeyPair.publicKey, message, signature);
 *
 * // Hybrid Mode (recommended for transition)
 * const hybrid = createHybridCryptoProvider();
 * await hybrid.initialize();
 *
 * const hybridKeyPair = await hybrid.generateKEMKeyPair();
 * const { sharedSecret } = await hybrid.encapsulate(hybridKeyPair);
 * ```
 *
 * ## PRODUCTION NOTE
 *
 * This module includes a reference implementation for demonstration and testing.
 * For production deployment, configure native bindings:
 *
 * - Install liboqs-node: `npm install liboqs-node`
 * - Or use @cloudflare/pq-crypto
 * - Or compile with OpenSSL 3.2+ with PQ provider
 *
 * The services automatically detect and use native bindings when available.
 *
 * @packageDocumentation
 * @module security/crypto/post-quantum
 */
export { KyberParameterSet, type KyberParameters, KYBER_PARAMETERS, type KyberKeyPair, DilithiumParameterSet, type DilithiumParameters, DILITHIUM_PARAMETERS, type DilithiumKeyPair, type PQAlgorithm, type PQKeyPair, pqKeyPairSchema, type EncapsulationResult, type DecapsulationResult, encapsulationResultSchema, decapsulationResultSchema, type SignatureResult, type VerificationResult, signatureResultSchema, verificationResultSchema, ClassicalKEMAlgorithm, ClassicalSignatureAlgorithm, type HybridKEMKeyPair, type HybridSignatureKeyPair, type HybridEncapsulationResult, type HybridSignatureResult, hybridKEMKeyPairSchema, hybridSignatureKeyPairSchema, hybridEncapsulationResultSchema, hybridSignatureResultSchema, type KyberConfig, type DilithiumConfig, type HybridConfig, DEFAULT_KYBER_CONFIG, DEFAULT_DILITHIUM_CONFIG, DEFAULT_HYBRID_CONFIG, kyberConfigSchema, dilithiumConfigSchema, hybridConfigSchema, PQErrorCode, MigrationPhase, type KeyRotationStatus, type AlgorithmNegotiationRequest, type AlgorithmNegotiationResult, keyRotationStatusSchema, algorithmNegotiationRequestSchema, algorithmNegotiationResultSchema, BenchmarkOperation, type BenchmarkResult, type BenchmarkSuiteResult, benchmarkResultSchema, benchmarkSuiteResultSchema, } from './types.js';
export { KyberService, KyberError, createKyberService, createInitializedKyberService, } from './kyber.js';
export { DilithiumService, DilithiumError, createDilithiumService, createInitializedDilithiumService, } from './dilithium.js';
export { HybridKEM, type HybridKEMConfig, createHybridKEM, HybridSign, type HybridSignatureConfig, createHybridSign, HybridCryptoProvider, HybridCryptoError, createHybridCryptoProvider, createInitializedHybridCryptoProvider, isHybridSignature, splitHybridSignature, } from './hybrid.js';
export { KeyRotationManager, createKeyRotationManager, DualSignatureVerifier, createDualSignatureVerifier, GradualRolloutManager, createGradualRolloutManager, AlgorithmNegotiator, createAlgorithmNegotiator, createMigrationToolkit, MigrationError, type MigrationConfig, } from './migration.js';
export { BenchmarkRunner, type BenchmarkConfig, createBenchmarkRunner, runQuickBenchmark, runFullBenchmark, } from './benchmark.js';
import { createInitializedKyberService } from './kyber.js';
import { createInitializedDilithiumService } from './dilithium.js';
import { type MigrationConfig } from './migration.js';
import { type HybridConfig } from './types.js';
/**
 * Create a fully initialized post-quantum crypto provider
 *
 * This is the recommended entry point for most use cases.
 * Returns a hybrid provider configured with sensible defaults.
 *
 * @example
 * ```typescript
 * const pq = await createPostQuantumProvider();
 *
 * // Generate keys
 * const kemKeys = await pq.generateKEMKeyPair();
 * const sigKeys = await pq.generateSignatureKeyPair();
 *
 * // Use for encryption
 * const { ciphertext, sharedSecret } = await pq.encapsulate(kemKeys);
 *
 * // Use for signing
 * const message = new Uint8Array([1, 2, 3, 4]);
 * const { signature } = await pq.signMessage(sigKeys, message);
 * ```
 */
export declare function createPostQuantumProvider(config?: Partial<HybridConfig>): Promise<import("./hybrid.js").HybridCryptoProvider>;
/**
 * Create services for a specific security level
 *
 * @param level - NIST security level (1, 3, or 5)
 */
export declare function createServicesForSecurityLevel(level: 1 | 3 | 5): Promise<{
    kyber: Awaited<ReturnType<typeof createInitializedKyberService>>;
    dilithium: Awaited<ReturnType<typeof createInitializedDilithiumService>>;
}>;
/**
 * Create a migration-ready setup with gradual rollout support
 *
 * @example
 * ```typescript
 * const migration = await createMigrationReadySetup({
 *   currentPhase: 'hybrid',
 *   rolloutPercentage: 10,
 * });
 *
 * // Check if user should use PQ
 * if (migration.rollout.shouldUsePQ(userId)) {
 *   // Use PQ cryptography
 * }
 * ```
 */
export declare function createMigrationReadySetup(config?: Partial<MigrationConfig>): Promise<{
    keyRotation: import("./migration.js").KeyRotationManager;
    dualVerifier: import("./migration.js").DualSignatureVerifier;
    rollout: import("./migration.js").GradualRolloutManager;
    negotiator: import("./migration.js").AlgorithmNegotiator;
}>;
/**
 * Module version and capabilities
 */
export declare const PQ_MODULE_INFO: {
    readonly version: "1.0.0";
    readonly algorithms: {
        readonly kem: readonly ["kyber512", "kyber768", "kyber1024"];
        readonly signatures: readonly ["dilithium2", "dilithium3", "dilithium5"];
        readonly hybrid: {
            readonly kem: readonly ["x25519+kyber", "ecdh-p256+kyber", "ecdh-p384+kyber"];
            readonly signatures: readonly ["ed25519+dilithium", "ecdsa-p256+dilithium", "ecdsa-p384+dilithium"];
        };
    };
    readonly nistStandards: {
        readonly kyber: "FIPS 203 (ML-KEM)";
        readonly dilithium: "FIPS 204 (ML-DSA)";
    };
    readonly recommended: {
        readonly kem: "kyber768";
        readonly signature: "dilithium3";
        readonly mode: "hybrid";
    };
};
//# sourceMappingURL=index.d.ts.map