/**
 * Local SoftHSM Provider Implementation
 * Software-based HSM emulation for development and testing
 *
 * WARNING: This provider is NOT suitable for production use.
 * It stores keys in memory and does not provide the security
 * guarantees of a real Hardware Security Module.
 */
import { BaseHSMProvider, HSMProviderConfig, HSMStatus, KeySpec, KeyHandle, EncryptionOptions } from './provider';
export interface SoftHSMConfig extends HSMProviderConfig {
    /** Token label */
    tokenLabel?: string;
    /** Token PIN */
    tokenPin?: string;
    /** Persist keys to file (for testing) */
    persistPath?: string;
    /** Simulated latency in ms (to mimic real HSM) */
    simulatedLatency?: number;
    /** Maximum key count */
    maxKeys?: number;
    /** Whether to warn when used */
    suppressWarnings?: boolean;
}
export declare class SoftHSMProvider extends BaseHSMProvider {
    readonly name = "SoftHSM (Development)";
    readonly isProduction = false;
    private softConfig;
    private keyStore;
    private tokenId;
    private initialized;
    constructor(config: SoftHSMConfig);
    /**
     * Connect to SoftHSM (simulated)
     */
    connect(): Promise<void>;
    /**
     * Simulate HSM latency
     */
    private simulateLatency;
    /**
     * Load persisted keys from file
     */
    private loadPersistedKeys;
    /**
     * Save keys to persistence
     */
    private persistKeys;
    /**
     * Disconnect from SoftHSM
     */
    disconnect(): Promise<void>;
    /**
     * Get HSM status
     */
    getStatus(): Promise<HSMStatus>;
    /**
     * Generate key in SoftHSM
     */
    generateKey(spec: KeySpec): Promise<KeyHandle>;
    /**
     * Import key into SoftHSM
     */
    importKey(keyMaterial: Buffer, spec: KeySpec): Promise<KeyHandle>;
    /**
     * Export public key
     */
    exportPublicKey(keyHandle: string): Promise<Buffer>;
    /**
     * Get key
     */
    getKey(keyHandle: string): Promise<KeyHandle | null>;
    /**
     * List keys
     */
    listKeys(filter?: Partial<KeySpec>): Promise<KeyHandle[]>;
    /**
     * Sign data using actual cryptographic operations
     */
    sign(keyHandle: string, data: Buffer, algorithm: string): Promise<Buffer>;
    /**
     * Verify signature using actual cryptographic operations
     */
    verify(keyHandle: string, data: Buffer, signature: Buffer, algorithm: string): Promise<boolean>;
    /**
     * Encrypt data using actual cryptographic operations
     */
    encrypt(keyHandle: string, data: Buffer, options?: EncryptionOptions): Promise<Buffer>;
    /**
     * Decrypt data using actual cryptographic operations
     */
    decrypt(keyHandle: string, ciphertext: Buffer, options?: EncryptionOptions): Promise<Buffer>;
    /**
     * Wrap key
     */
    wrapKey(wrappingKeyHandle: string, keyToWrap: string, algorithm?: string): Promise<Buffer>;
    /**
     * Unwrap key
     */
    unwrapKey(wrappingKeyHandle: string, wrappedKey: Buffer, spec: KeySpec, algorithm?: string): Promise<string>;
    /**
     * Destroy key
     */
    destroyKey(keyHandle: string): Promise<void>;
    /**
     * Export key material (TESTING ONLY - never in production HSM)
     */
    exportKeyMaterial(keyHandle: string): Promise<Buffer>;
    /**
     * Clear all keys (TESTING ONLY)
     */
    clearAllKeys(): Promise<void>;
    /**
     * Get token info
     */
    getTokenInfo(): Promise<{
        label: string;
        tokenId: string;
        keyCount: number;
        maxKeys: number;
    }>;
}
//# sourceMappingURL=local-softHSM.d.ts.map