/**
 * Hardware Security Module (HSM) Integration Layer
 *
 * This module provides a unified interface for enterprise key management
 * across multiple HSM providers including:
 * - AWS CloudHSM
 * - Azure Dedicated/Managed HSM
 * - Google Cloud HSM
 * - Thales Luna Network HSM
 * - SoftHSM (for development)
 *
 * Features:
 * - Provider abstraction with automatic failover
 * - Key lifecycle management
 * - Multi-party key ceremonies with Shamir's Secret Sharing
 * - Health monitoring and audit logging
 * - Transparent integration with application code
 *
 * @module security/hsm
 */
export { IHSMProvider, HSMProviderConfig, HSMStatus, KeySpec, KeyHandle, KeyType, KeyUsage, ECCurve, EncryptionOptions, EncryptionAlgorithm, SigningAlgorithm, RetryConfig, AuditLogEntry, BaseHSMProvider, HSMError, HSMConnectionError, HSMKeyNotFoundError, HSMOperationError, HSMPermissionError, } from './provider';
export { AWSCloudHSMProvider, AWSCloudHSMConfig, } from './aws-cloudhsm';
export { AzureHSMProvider, AzureHSMConfig, AzureHSMRole, RoleAssignment, } from './azure-hsm';
export { GCPHSMProvider, GCPHSMConfig, GCPKeyAlgorithm, KeyVersionState, CloudKMSRole, IAMBinding, } from './gcp-hsm';
export { ThalesLunaProvider, ThalesLunaConfig, HAGroupMember, PartitionInfo, } from './thales-luna';
export { SoftHSMProvider, SoftHSMConfig, } from './local-softHSM';
export { KeyCeremonyManager, CeremonyConfig, Ceremony, CeremonyType, CeremonyStatus, CeremonyAction, CeremonyAuditEntry, KeyCustodian, CustodianRole, KeyShare, } from './key-ceremony';
export { HSMService, HSMServiceConfig, HSMProviderSelector, createHSMService, } from './hsm-service';
/**
 * Standard key specifications for common use cases
 */
export declare const StandardKeySpecs: {
    /**
     * AES-256 key for data encryption
     */
    DataEncryptionKey: {
        type: "AES";
        size: number;
        usage: ("encrypt" | "decrypt")[];
        extractable: boolean;
    };
    /**
     * AES-256 key for wrapping other keys
     */
    KeyEncryptionKey: {
        type: "AES";
        size: number;
        usage: ("wrap" | "unwrap")[];
        extractable: boolean;
    };
    /**
     * RSA-2048 key pair for signing
     */
    RSASigningKey: {
        type: "RSA";
        size: number;
        usage: ("verify" | "sign")[];
        extractable: boolean;
    };
    /**
     * RSA-2048 key pair for encryption
     */
    RSAEncryptionKey: {
        type: "RSA";
        size: number;
        usage: ("encrypt" | "decrypt")[];
        extractable: boolean;
    };
    /**
     * ECDSA P-256 key pair for signing
     */
    ECDSASigningKey: {
        type: "EC";
        curve: "P-256";
        usage: ("verify" | "sign")[];
        extractable: boolean;
    };
    /**
     * HMAC-SHA256 key for message authentication
     */
    HMACKey: {
        type: "HMAC";
        size: number;
        usage: ("verify" | "sign")[];
        extractable: boolean;
    };
};
/**
 * Environment-based provider recommendations
 */
export declare const ProviderRecommendations: {
    readonly development: readonly ["softhsm"];
    readonly staging: readonly ["softhsm", "aws", "azure", "gcp"];
    readonly production: readonly ["aws", "azure", "gcp", "thales"];
};
import { HSMService } from './hsm-service';
/**
 * Quick start: Create and initialize HSM service for the current environment
 *
 * @example
 * ```typescript
 * const hsm = await quickStart('development');
 * const key = await hsm.generateMasterKey('my-app-key');
 * const encrypted = await hsm.encrypt(key.id, Buffer.from('secret data'));
 * ```
 */
export declare function quickStart(environment?: 'development' | 'staging' | 'production'): Promise<HSMService>;
/**
 * Create a simple encryption service using SoftHSM
 * Useful for development and testing
 *
 * @example
 * ```typescript
 * const crypto = await createSimpleCryptoService();
 * const { keyId, ciphertext } = await crypto.encrypt('my-data', Buffer.from('hello'));
 * const plaintext = await crypto.decrypt(keyId, ciphertext);
 * ```
 */
export declare function createSimpleCryptoService(): Promise<{
    encrypt: (label: string, data: Buffer) => Promise<{
        keyId: string;
        ciphertext: Buffer;
    }>;
    decrypt: (keyId: string, ciphertext: Buffer) => Promise<Buffer>;
    sign: (label: string, data: Buffer) => Promise<{
        keyId: string;
        signature: Buffer;
    }>;
    verify: (keyId: string, data: Buffer, signature: Buffer) => Promise<boolean>;
    destroy: () => Promise<void>;
}>;
//# sourceMappingURL=index.d.ts.map