@iota-big3/sdk-quantum/dist/index-clean.d.ts

Quantum-ready architecture with post-quantum cryptography

/**
 * Clean Quantum SDK Implementation
 * @iota-big3/sdk-quantum
 */
import { EventEmitter } from 'events';
import { QuantumSDKConfig, PostQuantumAlgorithm, SecurityLevel, KeyPair, EncryptionResult, SignatureResult, QuantumCircuit, SimulationResult, QuantumDataEntry, QuantumAlgorithm, QuantumAdvantage } from './types-clean';
export * from './types-clean';
export { QuantumManager } from './core/quantum-manager-clean';
/**
 * Main Quantum SDK Class
 */
export declare class QuantumSDK extends EventEmitter {
    private manager;
    private config;
    constructor(config?: QuantumSDKConfig);
    generateKeyPair(algorithm?: PostQuantumAlgorithm): Promise<KeyPair>;
    encrypt(data: Uint8Array, keyId: string): Promise<EncryptionResult>;
    decrypt(encryptionResult: EncryptionResult): Promise<Uint8Array>;
    sign(data: Uint8Array, keyId: string): Promise<SignatureResult>;
    createCircuit(name: string, qubits: number): Promise<QuantumCircuit>;
    executeCircuit(circuitId: string, shots?: number): Promise<SimulationResult>;
    storeData(key: string, data: Uint8Array): Promise<string>;
    healthCheck(): Promise<{
        status: string;
        details: Record<string, unknown>;
    }>;
    isEnabled(): boolean;
    enable(): void;
    disable(): void;
    getKeyPairs(): KeyPair[];
    getCircuits(): QuantumCircuit[];
    getDataEntries(): QuantumDataEntry[];
}
/**
 * Utility Functions for Quantum Operations
 */
export declare class QuantumUtils {
    /**
     * Generate secure random bytes using quantum-safe methods
     */
    static generateSecureRandom(length: number): Uint8Array;
    /**
     * Calculate quantum-safe hash
     */
    static calculateQuantumHash(data: Uint8Array): string;
    /**
     * Validate post-quantum algorithm security level
     */
    static validateSecurityLevel(algorithm: PostQuantumAlgorithm, level: SecurityLevel): boolean;
    /**
     * Estimate quantum advantage for an algorithm
     */
    static estimateQuantumAdvantage(classicalComplexity: string, quantumComplexity: string): QuantumAdvantage;
    /**
     * Convert binary string to quantum state amplitudes
     */
    static binaryToAmplitudes(binaryString: string): {
        real: number;
        imaginary: number;
    }[];
    /**
     * Calculate quantum circuit depth
     */
    static calculateCircuitDepth(gates: {
        qubits: number[];
        type: string;
    }[]): number;
}
/**
 * Quantum Algorithm Templates
 */
export declare class QuantumAlgorithmTemplates {
    /**
     * Create Grover's search algorithm template
     */
    static createGroverAlgorithm(databaseSize: number): QuantumAlgorithm;
    /**
     * Create Shor's factoring algorithm template
     */
    static createShorAlgorithm(numberToFactor: number): QuantumAlgorithm;
    /**
     * Create Quantum Fourier Transform template
     */
    static createQFTAlgorithm(qubits: number): QuantumAlgorithm;
    /**
     * Create Variational Quantum Eigensolver template
     */
    static createVQEAlgorithm(moleculeSize: number): QuantumAlgorithm;
}
/**
 * Quantum Circuit Builder
 */
export declare class QuantumCircuitBuilder {
    private gates;
    private qubits;
    private name;
    constructor(name: string, qubits: number);
    /**
     * Add Hadamard gate
     */
    h(qubit: number): QuantumCircuitBuilder;
    /**
     * Add Pauli-X gate
     */
    x(qubit: number): QuantumCircuitBuilder;
    /**
     * Add Pauli-Y gate
     */
    y(qubit: number): QuantumCircuitBuilder;
    /**
     * Add Pauli-Z gate
     */
    z(qubit: number): QuantumCircuitBuilder;
    /**
     * Add CNOT gate
     */
    cnot(control: number, target: number): QuantumCircuitBuilder;
    /**
     * Add rotation around X axis
     */
    rx(qubit: number, angle: number): QuantumCircuitBuilder;
    /**
     * Add rotation around Y axis
     */
    ry(qubit: number, angle: number): QuantumCircuitBuilder;
    /**
     * Add rotation around Z axis
     */
    rz(qubit: number, angle: number): QuantumCircuitBuilder;
    /**
     * Build the quantum circuit
     */
    build(): Omit<QuantumCircuit, 'id' | 'createdAt'>;
    private validateQubit;
}
/**
 * Pre-built Quantum Circuit Templates
 */
export declare class QuantumCircuitTemplates {
    /**
     * Create Bell state preparation circuit
     */
    static bellState(): Omit<QuantumCircuit, 'id' | 'createdAt'>;
    /**
     * Create GHZ state preparation circuit
     */
    static ghzState(qubits: number): Omit<QuantumCircuit, 'id' | 'createdAt'>;
    /**
     * Create quantum teleportation circuit
     */
    static quantumTeleportation(): Omit<QuantumCircuit, 'id' | 'createdAt'>;
    /**
     * Create quantum random number generator circuit
     */
    static randomNumberGenerator(bits: number): Omit<QuantumCircuit, 'id' | 'createdAt'>;
}
export default QuantumSDK;
//# sourceMappingURL=index-clean.d.ts.map