@vorionsys/platform-core 0.1.0

package/dist/security/crypto/post-quantum/types.d.ts

@@ -0,0 +1,1056 @@
+/**
+ * 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