/**
 * Post-Quantum Cryptography Types
 *
 * Type definitions for post-quantum cryptographic operations including:
 * - CRYSTALS-Kyber key encapsulation mechanism (KEM)
 * - CRYSTALS-Dilithium digital signatures
 * - Hybrid classical/PQ modes
 *
 * Based on NIST PQC standardization (FIPS 203, FIPS 204)
 *
 * @packageDocumentation
 * @module security/crypto/post-quantum/types
 */
import { z } from 'zod';
/**
 * Kyber parameter sets as defined in FIPS 203
 * - kyber512: NIST Security Level 1 (equivalent to AES-128)
 * - kyber768: NIST Security Level 3 (equivalent to AES-192)
 * - kyber1024: NIST Security Level 5 (equivalent to AES-256)
 */
export declare const KyberParameterSet: {
    readonly KYBER512: "kyber512";
    readonly KYBER768: "kyber768";
    readonly KYBER1024: "kyber1024";
};
export type KyberParameterSet = (typeof KyberParameterSet)[keyof typeof KyberParameterSet];
export declare const kyberParameterSetSchema: z.ZodNativeEnum<{
    readonly KYBER512: "kyber512";
    readonly KYBER768: "kyber768";
    readonly KYBER1024: "kyber1024";
}>;
/**
 * Kyber parameter specifications
 */
export interface KyberParameters {
    /** Parameter set name */
    name: KyberParameterSet;
    /** NIST security level (1, 3, or 5) */
    securityLevel: 1 | 3 | 5;
    /** Public key size in bytes */
    publicKeySize: number;
    /** Private key size in bytes */
    privateKeySize: number;
    /** Ciphertext size in bytes */
    ciphertextSize: number;
    /** Shared secret size in bytes */
    sharedSecretSize: number;
    /** k parameter (module rank) */
    k: number;
}
/**
 * Kyber parameter specifications for each security level
 */
export declare const KYBER_PARAMETERS: Record<KyberParameterSet, KyberParameters>;
/**
 * Dilithium parameter sets as defined in FIPS 204
 * - dilithium2: NIST Security Level 2 (recommended minimum)
 * - dilithium3: NIST Security Level 3
 * - dilithium5: NIST Security Level 5
 */
export declare const DilithiumParameterSet: {
    readonly DILITHIUM2: "dilithium2";
    readonly DILITHIUM3: "dilithium3";
    readonly DILITHIUM5: "dilithium5";
};
export type DilithiumParameterSet = (typeof DilithiumParameterSet)[keyof typeof DilithiumParameterSet];
export declare const dilithiumParameterSetSchema: z.ZodNativeEnum<{
    readonly DILITHIUM2: "dilithium2";
    readonly DILITHIUM3: "dilithium3";
    readonly DILITHIUM5: "dilithium5";
}>;
/**
 * Dilithium parameter specifications
 */
export interface DilithiumParameters {
    /** Parameter set name */
    name: DilithiumParameterSet;
    /** NIST security level (2, 3, or 5) */
    securityLevel: 2 | 3 | 5;
    /** Public key size in bytes */
    publicKeySize: number;
    /** Private key size in bytes */
    privateKeySize: number;
    /** Signature size in bytes */
    signatureSize: number;
    /** k parameter */
    k: number;
    /** l parameter */
    l: number;
}
/**
 * Dilithium parameter specifications for each security level
 */
export declare const DILITHIUM_PARAMETERS: Record<DilithiumParameterSet, DilithiumParameters>;
/**
 * Post-quantum algorithm identifier
 */
export type PQAlgorithm = KyberParameterSet | DilithiumParameterSet;
/**
 * Post-quantum key pair
 */
export interface PQKeyPair {
    /** Public key bytes */
    publicKey: Uint8Array;
    /** Private key bytes */
    privateKey: Uint8Array;
    /** Algorithm identifier */
    algorithm: PQAlgorithm;
    /** Key generation timestamp */
    generatedAt?: Date;
    /** Key expiration timestamp */
    expiresAt?: Date;
    /** Key identifier for tracking */
    keyId?: string;
}
export declare const pqKeyPairSchema: z.ZodObject<{
    publicKey: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    privateKey: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    algorithm: z.ZodUnion<[z.ZodNativeEnum<{
        readonly KYBER512: "kyber512";
        readonly KYBER768: "kyber768";
        readonly KYBER1024: "kyber1024";
    }>, z.ZodNativeEnum<{
        readonly DILITHIUM2: "dilithium2";
        readonly DILITHIUM3: "dilithium3";
        readonly DILITHIUM5: "dilithium5";
    }>]>;
    generatedAt: z.ZodOptional<z.ZodDate>;
    expiresAt: z.ZodOptional<z.ZodDate>;
    keyId: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    privateKey?: Uint8Array<ArrayBuffer>;
    algorithm?: "kyber512" | "kyber768" | "kyber1024" | "dilithium2" | "dilithium3" | "dilithium5";
    expiresAt?: Date;
    publicKey?: Uint8Array<ArrayBuffer>;
    keyId?: string;
    generatedAt?: Date;
}, {
    privateKey?: Uint8Array<ArrayBuffer>;
    algorithm?: "kyber512" | "kyber768" | "kyber1024" | "dilithium2" | "dilithium3" | "dilithium5";
    expiresAt?: Date;
    publicKey?: Uint8Array<ArrayBuffer>;
    keyId?: string;
    generatedAt?: Date;
}>;
/**
 * Kyber-specific key pair
 */
export interface KyberKeyPair extends PQKeyPair {
    algorithm: KyberParameterSet;
}
/**
 * Dilithium-specific key pair
 */
export interface DilithiumKeyPair extends PQKeyPair {
    algorithm: DilithiumParameterSet;
}
/**
 * Result of KEM encapsulation
 */
export interface EncapsulationResult {
    /** Ciphertext to send to recipient */
    ciphertext: Uint8Array;
    /** Shared secret established with recipient */
    sharedSecret: Uint8Array;
}
export declare const encapsulationResultSchema: z.ZodObject<{
    ciphertext: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    sharedSecret: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
}, "strip", z.ZodTypeAny, {
    ciphertext?: Uint8Array<ArrayBuffer>;
    sharedSecret?: Uint8Array<ArrayBuffer>;
}, {
    ciphertext?: Uint8Array<ArrayBuffer>;
    sharedSecret?: Uint8Array<ArrayBuffer>;
}>;
/**
 * Result of KEM decapsulation
 */
export interface DecapsulationResult {
    /** Recovered shared secret */
    sharedSecret: Uint8Array;
    /** Whether decapsulation was successful */
    success: boolean;
}
export declare const decapsulationResultSchema: z.ZodObject<{
    sharedSecret: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    success: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    success?: boolean;
    sharedSecret?: Uint8Array<ArrayBuffer>;
}, {
    success?: boolean;
    sharedSecret?: Uint8Array<ArrayBuffer>;
}>;
/**
 * Digital signature result
 */
export interface SignatureResult {
    /** The digital signature */
    signature: Uint8Array;
    /** Algorithm used for signing */
    algorithm: DilithiumParameterSet;
    /** Message digest (if pre-hashed) */
    messageDigest?: Uint8Array;
}
export declare const signatureResultSchema: z.ZodObject<{
    signature: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    algorithm: z.ZodNativeEnum<{
        readonly DILITHIUM2: "dilithium2";
        readonly DILITHIUM3: "dilithium3";
        readonly DILITHIUM5: "dilithium5";
    }>;
    messageDigest: z.ZodOptional<z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>>;
}, "strip", z.ZodTypeAny, {
    algorithm?: "dilithium2" | "dilithium3" | "dilithium5";
    signature?: Uint8Array<ArrayBuffer>;
    messageDigest?: Uint8Array<ArrayBuffer>;
}, {
    algorithm?: "dilithium2" | "dilithium3" | "dilithium5";
    signature?: Uint8Array<ArrayBuffer>;
    messageDigest?: Uint8Array<ArrayBuffer>;
}>;
/**
 * Signature verification result
 */
export interface VerificationResult {
    /** Whether the signature is valid */
    valid: boolean;
    /** Error message if verification failed */
    error?: string;
}
export declare const verificationResultSchema: z.ZodObject<{
    valid: z.ZodBoolean;
    error: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    error?: string;
    valid?: boolean;
}, {
    error?: string;
    valid?: boolean;
}>;
/**
 * Classical algorithm for hybrid KEM
 */
export declare const ClassicalKEMAlgorithm: {
    readonly X25519: "x25519";
    readonly ECDH_P256: "ecdh-p256";
    readonly ECDH_P384: "ecdh-p384";
};
export type ClassicalKEMAlgorithm = (typeof ClassicalKEMAlgorithm)[keyof typeof ClassicalKEMAlgorithm];
export declare const classicalKEMAlgorithmSchema: z.ZodNativeEnum<{
    readonly X25519: "x25519";
    readonly ECDH_P256: "ecdh-p256";
    readonly ECDH_P384: "ecdh-p384";
}>;
/**
 * Classical algorithm for hybrid signatures
 */
export declare const ClassicalSignatureAlgorithm: {
    readonly ED25519: "ed25519";
    readonly ECDSA_P256: "ecdsa-p256";
    readonly ECDSA_P384: "ecdsa-p384";
};
export type ClassicalSignatureAlgorithm = (typeof ClassicalSignatureAlgorithm)[keyof typeof ClassicalSignatureAlgorithm];
export declare const classicalSignatureAlgorithmSchema: z.ZodNativeEnum<{
    readonly ED25519: "ed25519";
    readonly ECDSA_P256: "ecdsa-p256";
    readonly ECDSA_P384: "ecdsa-p384";
}>;
/**
 * Hybrid KEM key pair combining classical and PQ
 */
export interface HybridKEMKeyPair {
    /** Classical public key */
    classicalPublicKey: Uint8Array;
    /** Classical private key */
    classicalPrivateKey: Uint8Array;
    /** PQ public key */
    pqPublicKey: Uint8Array;
    /** PQ private key */
    pqPrivateKey: Uint8Array;
    /** Classical algorithm */
    classicalAlgorithm: ClassicalKEMAlgorithm;
    /** PQ algorithm */
    pqAlgorithm: KyberParameterSet;
    /** Key identifier */
    keyId?: string;
    /** Generation timestamp */
    generatedAt?: Date;
}
export declare const hybridKEMKeyPairSchema: z.ZodObject<{
    classicalPublicKey: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    classicalPrivateKey: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    pqPublicKey: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    pqPrivateKey: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    classicalAlgorithm: z.ZodNativeEnum<{
        readonly X25519: "x25519";
        readonly ECDH_P256: "ecdh-p256";
        readonly ECDH_P384: "ecdh-p384";
    }>;
    pqAlgorithm: z.ZodNativeEnum<{
        readonly KYBER512: "kyber512";
        readonly KYBER768: "kyber768";
        readonly KYBER1024: "kyber1024";
    }>;
    keyId: z.ZodOptional<z.ZodString>;
    generatedAt: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    keyId?: string;
    generatedAt?: Date;
    classicalPublicKey?: Uint8Array<ArrayBuffer>;
    classicalPrivateKey?: Uint8Array<ArrayBuffer>;
    pqPublicKey?: Uint8Array<ArrayBuffer>;
    pqPrivateKey?: Uint8Array<ArrayBuffer>;
    classicalAlgorithm?: "x25519" | "ecdh-p256" | "ecdh-p384";
    pqAlgorithm?: "kyber512" | "kyber768" | "kyber1024";
}, {
    keyId?: string;
    generatedAt?: Date;
    classicalPublicKey?: Uint8Array<ArrayBuffer>;
    classicalPrivateKey?: Uint8Array<ArrayBuffer>;
    pqPublicKey?: Uint8Array<ArrayBuffer>;
    pqPrivateKey?: Uint8Array<ArrayBuffer>;
    classicalAlgorithm?: "x25519" | "ecdh-p256" | "ecdh-p384";
    pqAlgorithm?: "kyber512" | "kyber768" | "kyber1024";
}>;
/**
 * Hybrid signature key pair combining classical and PQ
 */
export interface HybridSignatureKeyPair {
    /** Classical public key */
    classicalPublicKey: Uint8Array;
    /** Classical private key */
    classicalPrivateKey: Uint8Array;
    /** PQ public key */
    pqPublicKey: Uint8Array;
    /** PQ private key */
    pqPrivateKey: Uint8Array;
    /** Classical algorithm */
    classicalAlgorithm: ClassicalSignatureAlgorithm;
    /** PQ algorithm */
    pqAlgorithm: DilithiumParameterSet;
    /** Key identifier */
    keyId?: string;
    /** Generation timestamp */
    generatedAt?: Date;
}
export declare const hybridSignatureKeyPairSchema: z.ZodObject<{
    classicalPublicKey: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    classicalPrivateKey: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    pqPublicKey: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    pqPrivateKey: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    classicalAlgorithm: z.ZodNativeEnum<{
        readonly ED25519: "ed25519";
        readonly ECDSA_P256: "ecdsa-p256";
        readonly ECDSA_P384: "ecdsa-p384";
    }>;
    pqAlgorithm: z.ZodNativeEnum<{
        readonly DILITHIUM2: "dilithium2";
        readonly DILITHIUM3: "dilithium3";
        readonly DILITHIUM5: "dilithium5";
    }>;
    keyId: z.ZodOptional<z.ZodString>;
    generatedAt: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    keyId?: string;
    generatedAt?: Date;
    classicalPublicKey?: Uint8Array<ArrayBuffer>;
    classicalPrivateKey?: Uint8Array<ArrayBuffer>;
    pqPublicKey?: Uint8Array<ArrayBuffer>;
    pqPrivateKey?: Uint8Array<ArrayBuffer>;
    classicalAlgorithm?: "ed25519" | "ecdsa-p256" | "ecdsa-p384";
    pqAlgorithm?: "dilithium2" | "dilithium3" | "dilithium5";
}, {
    keyId?: string;
    generatedAt?: Date;
    classicalPublicKey?: Uint8Array<ArrayBuffer>;
    classicalPrivateKey?: Uint8Array<ArrayBuffer>;
    pqPublicKey?: Uint8Array<ArrayBuffer>;
    pqPrivateKey?: Uint8Array<ArrayBuffer>;
    classicalAlgorithm?: "ed25519" | "ecdsa-p256" | "ecdsa-p384";
    pqAlgorithm?: "dilithium2" | "dilithium3" | "dilithium5";
}>;
/**
 * Hybrid encapsulation result
 */
export interface HybridEncapsulationResult {
    /** Combined ciphertext (classical + PQ) */
    ciphertext: Uint8Array;
    /** Classical ciphertext component */
    classicalCiphertext: Uint8Array;
    /** PQ ciphertext component */
    pqCiphertext: Uint8Array;
    /** Combined shared secret */
    sharedSecret: Uint8Array;
}
export declare const hybridEncapsulationResultSchema: z.ZodObject<{
    ciphertext: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    classicalCiphertext: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    pqCiphertext: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    sharedSecret: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
}, "strip", z.ZodTypeAny, {
    ciphertext?: Uint8Array<ArrayBuffer>;
    sharedSecret?: Uint8Array<ArrayBuffer>;
    classicalCiphertext?: Uint8Array<ArrayBuffer>;
    pqCiphertext?: Uint8Array<ArrayBuffer>;
}, {
    ciphertext?: Uint8Array<ArrayBuffer>;
    sharedSecret?: Uint8Array<ArrayBuffer>;
    classicalCiphertext?: Uint8Array<ArrayBuffer>;
    pqCiphertext?: Uint8Array<ArrayBuffer>;
}>;
/**
 * Hybrid signature result
 */
export interface HybridSignatureResult {
    /** Combined signature (classical || PQ) */
    signature: Uint8Array;
    /** Classical signature component */
    classicalSignature: Uint8Array;
    /** PQ signature component */
    pqSignature: Uint8Array;
    /** Classical algorithm used */
    classicalAlgorithm: ClassicalSignatureAlgorithm;
    /** PQ algorithm used */
    pqAlgorithm: DilithiumParameterSet;
}
export declare const hybridSignatureResultSchema: z.ZodObject<{
    signature: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    classicalSignature: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    pqSignature: z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>;
    classicalAlgorithm: z.ZodNativeEnum<{
        readonly ED25519: "ed25519";
        readonly ECDSA_P256: "ecdsa-p256";
        readonly ECDSA_P384: "ecdsa-p384";
    }>;
    pqAlgorithm: z.ZodNativeEnum<{
        readonly DILITHIUM2: "dilithium2";
        readonly DILITHIUM3: "dilithium3";
        readonly DILITHIUM5: "dilithium5";
    }>;
}, "strip", z.ZodTypeAny, {
    signature?: Uint8Array<ArrayBuffer>;
    classicalAlgorithm?: "ed25519" | "ecdsa-p256" | "ecdsa-p384";
    pqAlgorithm?: "dilithium2" | "dilithium3" | "dilithium5";
    classicalSignature?: Uint8Array<ArrayBuffer>;
    pqSignature?: Uint8Array<ArrayBuffer>;
}, {
    signature?: Uint8Array<ArrayBuffer>;
    classicalAlgorithm?: "ed25519" | "ecdsa-p256" | "ecdsa-p384";
    pqAlgorithm?: "dilithium2" | "dilithium3" | "dilithium5";
    classicalSignature?: Uint8Array<ArrayBuffer>;
    pqSignature?: Uint8Array<ArrayBuffer>;
}>;
/**
 * Kyber service configuration
 */
export interface KyberConfig {
    /** Default parameter set */
    defaultParameterSet: KyberParameterSet;
    /** Enable hybrid mode with classical algorithm */
    enableHybridMode: boolean;
    /** Classical algorithm for hybrid mode */
    hybridClassicalAlgorithm: ClassicalKEMAlgorithm;
    /** Use native bindings if available */
    preferNativeBindings: boolean;
}
export declare const kyberConfigSchema: z.ZodObject<{
    defaultParameterSet: z.ZodDefault<z.ZodNativeEnum<{
        readonly KYBER512: "kyber512";
        readonly KYBER768: "kyber768";
        readonly KYBER1024: "kyber1024";
    }>>;
    enableHybridMode: z.ZodDefault<z.ZodBoolean>;
    hybridClassicalAlgorithm: z.ZodDefault<z.ZodNativeEnum<{
        readonly X25519: "x25519";
        readonly ECDH_P256: "ecdh-p256";
        readonly ECDH_P384: "ecdh-p384";
    }>>;
    preferNativeBindings: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    defaultParameterSet?: "kyber512" | "kyber768" | "kyber1024";
    enableHybridMode?: boolean;
    hybridClassicalAlgorithm?: "x25519" | "ecdh-p256" | "ecdh-p384";
    preferNativeBindings?: boolean;
}, {
    defaultParameterSet?: "kyber512" | "kyber768" | "kyber1024";
    enableHybridMode?: boolean;
    hybridClassicalAlgorithm?: "x25519" | "ecdh-p256" | "ecdh-p384";
    preferNativeBindings?: boolean;
}>;
export declare const DEFAULT_KYBER_CONFIG: KyberConfig;
/**
 * Dilithium service configuration
 */
export interface DilithiumConfig {
    /** Default parameter set */
    defaultParameterSet: DilithiumParameterSet;
    /** Enable hybrid mode with classical algorithm */
    enableHybridMode: boolean;
    /** Classical algorithm for hybrid mode */
    hybridClassicalAlgorithm: ClassicalSignatureAlgorithm;
    /** Use native bindings if available */
    preferNativeBindings: boolean;
    /** Pre-hash messages before signing (for large messages) */
    preHashMessages: boolean;
    /** Hash algorithm for pre-hashing */
    preHashAlgorithm: 'sha256' | 'sha384' | 'sha512';
}
export declare const dilithiumConfigSchema: z.ZodObject<{
    defaultParameterSet: z.ZodDefault<z.ZodNativeEnum<{
        readonly DILITHIUM2: "dilithium2";
        readonly DILITHIUM3: "dilithium3";
        readonly DILITHIUM5: "dilithium5";
    }>>;
    enableHybridMode: z.ZodDefault<z.ZodBoolean>;
    hybridClassicalAlgorithm: z.ZodDefault<z.ZodNativeEnum<{
        readonly ED25519: "ed25519";
        readonly ECDSA_P256: "ecdsa-p256";
        readonly ECDSA_P384: "ecdsa-p384";
    }>>;
    preferNativeBindings: z.ZodDefault<z.ZodBoolean>;
    preHashMessages: z.ZodDefault<z.ZodBoolean>;
    preHashAlgorithm: z.ZodDefault<z.ZodEnum<["sha256", "sha384", "sha512"]>>;
}, "strip", z.ZodTypeAny, {
    defaultParameterSet?: "dilithium2" | "dilithium3" | "dilithium5";
    enableHybridMode?: boolean;
    hybridClassicalAlgorithm?: "ed25519" | "ecdsa-p256" | "ecdsa-p384";
    preferNativeBindings?: boolean;
    preHashMessages?: boolean;
    preHashAlgorithm?: "sha256" | "sha512" | "sha384";
}, {
    defaultParameterSet?: "dilithium2" | "dilithium3" | "dilithium5";
    enableHybridMode?: boolean;
    hybridClassicalAlgorithm?: "ed25519" | "ecdsa-p256" | "ecdsa-p384";
    preferNativeBindings?: boolean;
    preHashMessages?: boolean;
    preHashAlgorithm?: "sha256" | "sha512" | "sha384";
}>;
export declare const DEFAULT_DILITHIUM_CONFIG: DilithiumConfig;
/**
 * Hybrid mode configuration
 */
export interface HybridConfig {
    /** Require both classical and PQ verification to pass */
    requireBothValid: boolean;
    /** Backward compatibility mode (accept classical-only) */
    backwardCompatibilityMode: boolean;
    /** Default KEM configuration */
    kem: {
        classicalAlgorithm: ClassicalKEMAlgorithm;
        pqAlgorithm: KyberParameterSet;
    };
    /** Default signature configuration */
    signature: {
        classicalAlgorithm: ClassicalSignatureAlgorithm;
        pqAlgorithm: DilithiumParameterSet;
    };
}
export declare const hybridConfigSchema: z.ZodObject<{
    requireBothValid: z.ZodDefault<z.ZodBoolean>;
    backwardCompatibilityMode: z.ZodDefault<z.ZodBoolean>;
    kem: z.ZodObject<{
        classicalAlgorithm: z.ZodDefault<z.ZodNativeEnum<{
            readonly X25519: "x25519";
            readonly ECDH_P256: "ecdh-p256";
            readonly ECDH_P384: "ecdh-p384";
        }>>;
        pqAlgorithm: z.ZodDefault<z.ZodNativeEnum<{
            readonly KYBER512: "kyber512";
            readonly KYBER768: "kyber768";
            readonly KYBER1024: "kyber1024";
        }>>;
    }, "strip", z.ZodTypeAny, {
        classicalAlgorithm?: "x25519" | "ecdh-p256" | "ecdh-p384";
        pqAlgorithm?: "kyber512" | "kyber768" | "kyber1024";
    }, {
        classicalAlgorithm?: "x25519" | "ecdh-p256" | "ecdh-p384";
        pqAlgorithm?: "kyber512" | "kyber768" | "kyber1024";
    }>;
    signature: z.ZodObject<{
        classicalAlgorithm: z.ZodDefault<z.ZodNativeEnum<{
            readonly ED25519: "ed25519";
            readonly ECDSA_P256: "ecdsa-p256";
            readonly ECDSA_P384: "ecdsa-p384";
        }>>;
        pqAlgorithm: z.ZodDefault<z.ZodNativeEnum<{
            readonly DILITHIUM2: "dilithium2";
            readonly DILITHIUM3: "dilithium3";
            readonly DILITHIUM5: "dilithium5";
        }>>;
    }, "strip", z.ZodTypeAny, {
        classicalAlgorithm?: "ed25519" | "ecdsa-p256" | "ecdsa-p384";
        pqAlgorithm?: "dilithium2" | "dilithium3" | "dilithium5";
    }, {
        classicalAlgorithm?: "ed25519" | "ecdsa-p256" | "ecdsa-p384";
        pqAlgorithm?: "dilithium2" | "dilithium3" | "dilithium5";
    }>;
}, "strip", z.ZodTypeAny, {
    signature?: {
        classicalAlgorithm?: "ed25519" | "ecdsa-p256" | "ecdsa-p384";
        pqAlgorithm?: "dilithium2" | "dilithium3" | "dilithium5";
    };
    requireBothValid?: boolean;
    backwardCompatibilityMode?: boolean;
    kem?: {
        classicalAlgorithm?: "x25519" | "ecdh-p256" | "ecdh-p384";
        pqAlgorithm?: "kyber512" | "kyber768" | "kyber1024";
    };
}, {
    signature?: {
        classicalAlgorithm?: "ed25519" | "ecdsa-p256" | "ecdsa-p384";
        pqAlgorithm?: "dilithium2" | "dilithium3" | "dilithium5";
    };
    requireBothValid?: boolean;
    backwardCompatibilityMode?: boolean;
    kem?: {
        classicalAlgorithm?: "x25519" | "ecdh-p256" | "ecdh-p384";
        pqAlgorithm?: "kyber512" | "kyber768" | "kyber1024";
    };
}>;
export declare const DEFAULT_HYBRID_CONFIG: HybridConfig;
/**
 * Post-quantum cryptography error codes
 */
export declare const PQErrorCode: {
    /** Key generation failed */
    readonly KEY_GENERATION_FAILED: "PQ_KEY_GENERATION_FAILED";
    /** Encapsulation failed */
    readonly ENCAPSULATION_FAILED: "PQ_ENCAPSULATION_FAILED";
    /** Decapsulation failed */
    readonly DECAPSULATION_FAILED: "PQ_DECAPSULATION_FAILED";
    /** Signing failed */
    readonly SIGNING_FAILED: "PQ_SIGNING_FAILED";
    /** Verification failed */
    readonly VERIFICATION_FAILED: "PQ_VERIFICATION_FAILED";
    /** Invalid key format */
    readonly INVALID_KEY_FORMAT: "PQ_INVALID_KEY_FORMAT";
    /** Invalid parameter set */
    readonly INVALID_PARAMETER_SET: "PQ_INVALID_PARAMETER_SET";
    /** Native bindings not available */
    readonly NATIVE_BINDINGS_UNAVAILABLE: "PQ_NATIVE_BINDINGS_UNAVAILABLE";
    /** Hybrid mode error */
    readonly HYBRID_MODE_ERROR: "PQ_HYBRID_MODE_ERROR";
    /** Algorithm mismatch */
    readonly ALGORITHM_MISMATCH: "PQ_ALGORITHM_MISMATCH";
    /** Key expired */
    readonly KEY_EXPIRED: "PQ_KEY_EXPIRED";
    /** Migration error */
    readonly MIGRATION_ERROR: "PQ_MIGRATION_ERROR";
};
export type PQErrorCode = (typeof PQErrorCode)[keyof typeof PQErrorCode];
/**
 * Migration phase for classical to PQ transition
 */
export declare const MigrationPhase: {
    /** Classical only (pre-migration) */
    readonly CLASSICAL_ONLY: "classical-only";
    /** Hybrid mode (both classical and PQ) */
    readonly HYBRID: "hybrid";
    /** PQ primary with classical fallback */
    readonly PQ_PRIMARY: "pq-primary";
    /** PQ only (post-migration) */
    readonly PQ_ONLY: "pq-only";
};
export type MigrationPhase = (typeof MigrationPhase)[keyof typeof MigrationPhase];
export declare const migrationPhaseSchema: z.ZodNativeEnum<{
    /** Classical only (pre-migration) */
    readonly CLASSICAL_ONLY: "classical-only";
    /** Hybrid mode (both classical and PQ) */
    readonly HYBRID: "hybrid";
    /** PQ primary with classical fallback */
    readonly PQ_PRIMARY: "pq-primary";
    /** PQ only (post-migration) */
    readonly PQ_ONLY: "pq-only";
}>;
/**
 * Key rotation status
 */
export interface KeyRotationStatus {
    /** Current key ID */
    currentKeyId: string;
    /** Previous key ID (if any) */
    previousKeyId?: string;
    /** Current migration phase */
    phase: MigrationPhase;
    /** Rotation timestamp */
    rotatedAt: Date;
    /** Next scheduled rotation */
    nextRotationAt?: Date;
    /** Classical key active */
    classicalKeyActive: boolean;
    /** PQ key active */
    pqKeyActive: boolean;
}
export declare const keyRotationStatusSchema: z.ZodObject<{
    currentKeyId: z.ZodString;
    previousKeyId: z.ZodOptional<z.ZodString>;
    phase: z.ZodNativeEnum<{
        /** Classical only (pre-migration) */
        readonly CLASSICAL_ONLY: "classical-only";
        /** Hybrid mode (both classical and PQ) */
        readonly HYBRID: "hybrid";
        /** PQ primary with classical fallback */
        readonly PQ_PRIMARY: "pq-primary";
        /** PQ only (post-migration) */
        readonly PQ_ONLY: "pq-only";
    }>;
    rotatedAt: z.ZodDate;
    nextRotationAt: z.ZodOptional<z.ZodDate>;
    classicalKeyActive: z.ZodBoolean;
    pqKeyActive: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    rotatedAt?: Date;
    phase?: "hybrid" | "classical-only" | "pq-primary" | "pq-only";
    currentKeyId?: string;
    previousKeyId?: string;
    nextRotationAt?: Date;
    classicalKeyActive?: boolean;
    pqKeyActive?: boolean;
}, {
    rotatedAt?: Date;
    phase?: "hybrid" | "classical-only" | "pq-primary" | "pq-only";
    currentKeyId?: string;
    previousKeyId?: string;
    nextRotationAt?: Date;
    classicalKeyActive?: boolean;
    pqKeyActive?: boolean;
}>;
/**
 * Algorithm negotiation request
 */
export interface AlgorithmNegotiationRequest {
    /** Supported KEM algorithms */
    supportedKEM: (ClassicalKEMAlgorithm | KyberParameterSet)[];
    /** Supported signature algorithms */
    supportedSignatures: (ClassicalSignatureAlgorithm | DilithiumParameterSet)[];
    /** Preferred algorithms */
    preferred?: {
        kem?: ClassicalKEMAlgorithm | KyberParameterSet;
        signature?: ClassicalSignatureAlgorithm | DilithiumParameterSet;
    };
    /** Whether hybrid mode is supported */
    hybridSupported: boolean;
}
export declare const algorithmNegotiationRequestSchema: z.ZodObject<{
    supportedKEM: z.ZodArray<z.ZodUnion<[z.ZodNativeEnum<{
        readonly X25519: "x25519";
        readonly ECDH_P256: "ecdh-p256";
        readonly ECDH_P384: "ecdh-p384";
    }>, z.ZodNativeEnum<{
        readonly KYBER512: "kyber512";
        readonly KYBER768: "kyber768";
        readonly KYBER1024: "kyber1024";
    }>]>, "many">;
    supportedSignatures: z.ZodArray<z.ZodUnion<[z.ZodNativeEnum<{
        readonly ED25519: "ed25519";
        readonly ECDSA_P256: "ecdsa-p256";
        readonly ECDSA_P384: "ecdsa-p384";
    }>, z.ZodNativeEnum<{
        readonly DILITHIUM2: "dilithium2";
        readonly DILITHIUM3: "dilithium3";
        readonly DILITHIUM5: "dilithium5";
    }>]>, "many">;
    preferred: z.ZodOptional<z.ZodObject<{
        kem: z.ZodOptional<z.ZodUnion<[z.ZodNativeEnum<{
            readonly X25519: "x25519";
            readonly ECDH_P256: "ecdh-p256";
            readonly ECDH_P384: "ecdh-p384";
        }>, z.ZodNativeEnum<{
            readonly KYBER512: "kyber512";
            readonly KYBER768: "kyber768";
            readonly KYBER1024: "kyber1024";
        }>]>>;
        signature: z.ZodOptional<z.ZodUnion<[z.ZodNativeEnum<{
            readonly ED25519: "ed25519";
            readonly ECDSA_P256: "ecdsa-p256";
            readonly ECDSA_P384: "ecdsa-p384";
        }>, z.ZodNativeEnum<{
            readonly DILITHIUM2: "dilithium2";
            readonly DILITHIUM3: "dilithium3";
            readonly DILITHIUM5: "dilithium5";
        }>]>>;
    }, "strip", z.ZodTypeAny, {
        signature?: "dilithium2" | "dilithium3" | "dilithium5" | "ed25519" | "ecdsa-p256" | "ecdsa-p384";
        kem?: "kyber512" | "kyber768" | "kyber1024" | "x25519" | "ecdh-p256" | "ecdh-p384";
    }, {
        signature?: "dilithium2" | "dilithium3" | "dilithium5" | "ed25519" | "ecdsa-p256" | "ecdsa-p384";
        kem?: "kyber512" | "kyber768" | "kyber1024" | "x25519" | "ecdh-p256" | "ecdh-p384";
    }>>;
    hybridSupported: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    preferred?: {
        signature?: "dilithium2" | "dilithium3" | "dilithium5" | "ed25519" | "ecdsa-p256" | "ecdsa-p384";
        kem?: "kyber512" | "kyber768" | "kyber1024" | "x25519" | "ecdh-p256" | "ecdh-p384";
    };
    supportedKEM?: ("kyber512" | "kyber768" | "kyber1024" | "x25519" | "ecdh-p256" | "ecdh-p384")[];
    supportedSignatures?: ("dilithium2" | "dilithium3" | "dilithium5" | "ed25519" | "ecdsa-p256" | "ecdsa-p384")[];
    hybridSupported?: boolean;
}, {
    preferred?: {
        signature?: "dilithium2" | "dilithium3" | "dilithium5" | "ed25519" | "ecdsa-p256" | "ecdsa-p384";
        kem?: "kyber512" | "kyber768" | "kyber1024" | "x25519" | "ecdh-p256" | "ecdh-p384";
    };
    supportedKEM?: ("kyber512" | "kyber768" | "kyber1024" | "x25519" | "ecdh-p256" | "ecdh-p384")[];
    supportedSignatures?: ("dilithium2" | "dilithium3" | "dilithium5" | "ed25519" | "ecdsa-p256" | "ecdsa-p384")[];
    hybridSupported?: boolean;
}>;
/**
 * Algorithm negotiation result
 */
export interface AlgorithmNegotiationResult {
    /** Selected KEM algorithm */
    selectedKEM: ClassicalKEMAlgorithm | KyberParameterSet | null;
    /** Selected signature algorithm */
    selectedSignature: ClassicalSignatureAlgorithm | DilithiumParameterSet | null;
    /** Whether hybrid mode was selected */
    hybridMode: boolean;
    /** Negotiation successful */
    success: boolean;
    /** Error message if failed */
    error?: string;
}
export declare const algorithmNegotiationResultSchema: z.ZodObject<{
    selectedKEM: z.ZodUnion<[z.ZodNativeEnum<{
        readonly X25519: "x25519";
        readonly ECDH_P256: "ecdh-p256";
        readonly ECDH_P384: "ecdh-p384";
    }>, z.ZodNativeEnum<{
        readonly KYBER512: "kyber512";
        readonly KYBER768: "kyber768";
        readonly KYBER1024: "kyber1024";
    }>, z.ZodNull]>;
    selectedSignature: z.ZodUnion<[z.ZodNativeEnum<{
        readonly ED25519: "ed25519";
        readonly ECDSA_P256: "ecdsa-p256";
        readonly ECDSA_P384: "ecdsa-p384";
    }>, z.ZodNativeEnum<{
        readonly DILITHIUM2: "dilithium2";
        readonly DILITHIUM3: "dilithium3";
        readonly DILITHIUM5: "dilithium5";
    }>, z.ZodNull]>;
    hybridMode: z.ZodBoolean;
    success: z.ZodBoolean;
    error: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    error?: string;
    success?: boolean;
    selectedKEM?: "kyber512" | "kyber768" | "kyber1024" | "x25519" | "ecdh-p256" | "ecdh-p384";
    selectedSignature?: "dilithium2" | "dilithium3" | "dilithium5" | "ed25519" | "ecdsa-p256" | "ecdsa-p384";
    hybridMode?: boolean;
}, {
    error?: string;
    success?: boolean;
    selectedKEM?: "kyber512" | "kyber768" | "kyber1024" | "x25519" | "ecdh-p256" | "ecdh-p384";
    selectedSignature?: "dilithium2" | "dilithium3" | "dilithium5" | "ed25519" | "ecdsa-p256" | "ecdsa-p384";
    hybridMode?: boolean;
}>;
/**
 * Benchmark operation type
 */
export declare const BenchmarkOperation: {
    readonly KEY_GENERATION: "key_generation";
    readonly ENCAPSULATION: "encapsulation";
    readonly DECAPSULATION: "decapsulation";
    readonly SIGN: "sign";
    readonly VERIFY: "verify";
};
export type BenchmarkOperation = (typeof BenchmarkOperation)[keyof typeof BenchmarkOperation];
/**
 * Single benchmark result
 */
export interface BenchmarkResult {
    /** Operation type */
    operation: BenchmarkOperation;
    /** Algorithm used (includes hybrid algorithms like 'hybrid-kem', 'hybrid-sign') */
    algorithm: string;
    /** Number of iterations */
    iterations: number;
    /** Total time in milliseconds */
    totalTimeMs: number;
    /** Average time per operation in milliseconds */
    avgTimeMs: number;
    /** Minimum time in milliseconds */
    minTimeMs: number;
    /** Maximum time in milliseconds */
    maxTimeMs: number;
    /** Standard deviation */
    stdDevMs: number;
    /** Operations per second */
    opsPerSecond: number;
    /** Memory usage in bytes (if available) */
    memoryUsageBytes?: number;
}
export declare const benchmarkResultSchema: z.ZodObject<{
    operation: z.ZodNativeEnum<{
        readonly KEY_GENERATION: "key_generation";
        readonly ENCAPSULATION: "encapsulation";
        readonly DECAPSULATION: "decapsulation";
        readonly SIGN: "sign";
        readonly VERIFY: "verify";
    }>;
    algorithm: z.ZodString;
    iterations: z.ZodNumber;
    totalTimeMs: z.ZodNumber;
    avgTimeMs: z.ZodNumber;
    minTimeMs: z.ZodNumber;
    maxTimeMs: z.ZodNumber;
    stdDevMs: z.ZodNumber;
    opsPerSecond: z.ZodNumber;
    memoryUsageBytes: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    algorithm?: string;
    operation?: "sign" | "verify" | "key_generation" | "encapsulation" | "decapsulation";
    iterations?: number;
    totalTimeMs?: number;
    avgTimeMs?: number;
    minTimeMs?: number;
    maxTimeMs?: number;
    stdDevMs?: number;
    opsPerSecond?: number;
    memoryUsageBytes?: number;
}, {
    algorithm?: string;
    operation?: "sign" | "verify" | "key_generation" | "encapsulation" | "decapsulation";
    iterations?: number;
    totalTimeMs?: number;
    avgTimeMs?: number;
    minTimeMs?: number;
    maxTimeMs?: number;
    stdDevMs?: number;
    opsPerSecond?: number;
    memoryUsageBytes?: number;
}>;
/**
 * Complete benchmark suite results
 */
export interface BenchmarkSuiteResult {
    /** Timestamp of benchmark run */
    timestamp: Date;
    /** Platform information */
    platform: {
        nodeVersion: string;
        arch: string;
        cpuModel: string;
        cpuCores: number;
    };
    /** Individual benchmark results */
    results: BenchmarkResult[];
    /** Whether native bindings were used */
    nativeBindingsUsed: boolean;
}
export declare const benchmarkSuiteResultSchema: z.ZodObject<{
    timestamp: z.ZodDate;
    platform: z.ZodObject<{
        nodeVersion: z.ZodString;
        arch: z.ZodString;
        cpuModel: z.ZodString;
        cpuCores: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        nodeVersion?: string;
        arch?: string;
        cpuModel?: string;
        cpuCores?: number;
    }, {
        nodeVersion?: string;
        arch?: string;
        cpuModel?: string;
        cpuCores?: number;
    }>;
    results: z.ZodArray<z.ZodObject<{
        operation: z.ZodNativeEnum<{
            readonly KEY_GENERATION: "key_generation";
            readonly ENCAPSULATION: "encapsulation";
            readonly DECAPSULATION: "decapsulation";
            readonly SIGN: "sign";
            readonly VERIFY: "verify";
        }>;
        algorithm: z.ZodString;
        iterations: z.ZodNumber;
        totalTimeMs: z.ZodNumber;
        avgTimeMs: z.ZodNumber;
        minTimeMs: z.ZodNumber;
        maxTimeMs: z.ZodNumber;
        stdDevMs: z.ZodNumber;
        opsPerSecond: z.ZodNumber;
        memoryUsageBytes: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        algorithm?: string;
        operation?: "sign" | "verify" | "key_generation" | "encapsulation" | "decapsulation";
        iterations?: number;
        totalTimeMs?: number;
        avgTimeMs?: number;
        minTimeMs?: number;
        maxTimeMs?: number;
        stdDevMs?: number;
        opsPerSecond?: number;
        memoryUsageBytes?: number;
    }, {
        algorithm?: string;
        operation?: "sign" | "verify" | "key_generation" | "encapsulation" | "decapsulation";
        iterations?: number;
        totalTimeMs?: number;
        avgTimeMs?: number;
        minTimeMs?: number;
        maxTimeMs?: number;
        stdDevMs?: number;
        opsPerSecond?: number;
        memoryUsageBytes?: number;
    }>, "many">;
    nativeBindingsUsed: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    timestamp?: Date;
    results?: {
        algorithm?: string;
        operation?: "sign" | "verify" | "key_generation" | "encapsulation" | "decapsulation";
        iterations?: number;
        totalTimeMs?: number;
        avgTimeMs?: number;
        minTimeMs?: number;
        maxTimeMs?: number;
        stdDevMs?: number;
        opsPerSecond?: number;
        memoryUsageBytes?: number;
    }[];
    platform?: {
        nodeVersion?: string;
        arch?: string;
        cpuModel?: string;
        cpuCores?: number;
    };
    nativeBindingsUsed?: boolean;
}, {
    timestamp?: Date;
    results?: {
        algorithm?: string;
        operation?: "sign" | "verify" | "key_generation" | "encapsulation" | "decapsulation";
        iterations?: number;
        totalTimeMs?: number;
        avgTimeMs?: number;
        minTimeMs?: number;
        maxTimeMs?: number;
        stdDevMs?: number;
        opsPerSecond?: number;
        memoryUsageBytes?: number;
    }[];
    platform?: {
        nodeVersion?: string;
        arch?: string;
        cpuModel?: string;
        cpuCores?: number;
    };
    nativeBindingsUsed?: boolean;
}>;
//# sourceMappingURL=types.d.ts.map