import { EventEmitter } from 'events';
import type { Card, DeviceEvents, DevicesOptions, Reader } from './types';
/**
 * Check if an error indicates an unresponsive card (SCARD_W_UNRESPONSIVE_CARD).
 * Used to determine if we should fallback to T=0 protocol.
 */
export declare function isUnresponsiveCardError(err: Error): boolean;
/**
 * High-level event-driven API for PC/SC devices
 *
 * Uses native ReaderMonitor for efficient background monitoring
 * with ThreadSafeFunction to emit events from worker thread.
 *
 * Events:
 * - 'reader-attached': Emitted when a reader is attached
 * - 'reader-detached': Emitted when a reader is detached
 * - 'card-inserted': Emitted when a card is inserted
 * - 'card-removed': Emitted when a card is removed
 * - 'error': Emitted on errors
 */
export declare class Devices extends EventEmitter {
    private _monitor;
    private _context;
    private _running;
    private _readers;
    private _eventQueue;
    private _Context;
    private _ReaderMonitor;
    private _SCARD_STATE_PRESENT;
    private _SCARD_SHARE_SHARED;
    private _SCARD_PROTOCOL_T0;
    private _SCARD_PROTOCOL_T1;
    /**
     * Create a new Devices instance
     * @param options Optional dependencies for testing
     */
    constructor(options?: DevicesOptions);
    /**
     * Start monitoring for device changes
     */
    start(): void;
    /**
     * Stop monitoring
     */
    stop(): void;
    /**
     * List currently known readers
     */
    listReaders(): Reader[];
    /**
     * Get all currently connected cards
     * @returns ReadonlyMap of reader name to Card object
     */
    getCards(): ReadonlyMap<string, Card>;
    /**
     * Get the card connected to a specific reader
     * @param readerName The name of the reader
     * @returns The Card object if connected, or null
     */
    getCard(readerName: string): Card | null;
    /**
     * Handle events from native monitor
     * Queues events to prevent race conditions when multiple events arrive concurrently
     */
    private _handleEvent;
    /**
     * Process a single event (called sequentially via queue)
     */
    private _processEvent;
    /**
     * Handle reader attached
     */
    private _handleReaderAttached;
    /**
     * Handle reader detached
     */
    private _handleReaderDetached;
    /**
     * Handle card inserted
     */
    private _handleCardInserted;
    /**
     * Handle card removed
     */
    private _handleCardRemoved;
    on<K extends keyof DeviceEvents>(event: K, listener: DeviceEvents[K]): this;
    once<K extends keyof DeviceEvents>(event: K, listener: DeviceEvents[K]): this;
    off<K extends keyof DeviceEvents>(event: K, listener: DeviceEvents[K]): this;
    addListener<K extends keyof DeviceEvents>(event: K, listener: DeviceEvents[K]): this;
    removeListener<K extends keyof DeviceEvents>(event: K, listener: DeviceEvents[K]): this;
    emit<K extends keyof DeviceEvents>(event: K, ...args: Parameters<DeviceEvents[K]>): boolean;
}
//# sourceMappingURL=devices.d.ts.map