import { CameraClient } from './CameraClient.js';
import type { BoundCamera, CameraEventStream, CameraManagerEventMap, CameraManagerEventType, CameraManagerOptions, ConnectionMode, ManagedCamera } from './types.js';
type EventCallback<T extends CameraManagerEventType> = (data: CameraManagerEventMap[T]) => void;
interface EventStreamLike {
    connect(): void | Promise<void>;
    on(event: string, callback: (data: unknown) => void): unknown;
    off(event: string, callback?: (data: unknown) => void): unknown;
    once(event: string, callback: (data: unknown) => void): unknown;
    close(): void;
    readonly connected: boolean;
}
type EventStreamConstructor = new (baseUrl: string, cameraId?: string) => EventStreamLike;
export declare class CameraManagerCore {
    private _client;
    private eventStream;
    private cameraStreams;
    private boundCameras;
    private cameras;
    private connectResolvers;
    private listeners;
    private callbackMap;
    private pollTimer;
    private isPolling;
    protected started: boolean;
    protected readonly EventStreamClass: EventStreamConstructor;
    protected baseUrl: string;
    private readonly pollInterval;
    private readonly autoConnect;
    private readonly connectionMode;
    private readonly autoReconnect;
    private readonly maxReconnectAttempts;
    private readonly handleSSEConnected;
    private readonly handleSSEDisconnected;
    private readonly handleSSEError;
    constructor(EventStreamClass: EventStreamConstructor, options?: CameraManagerOptions);
    get client(): CameraClient;
    start(): Promise<void>;
    close(): void;
    getCameras(): ManagedCamera[];
    getCamera(id: string): ManagedCamera | undefined;
    /**
     * Get a per-camera SSE event stream. Lazily created and cached — subsequent
     * calls for the same cameraId return the same stream. Auto-connects on first
     * call. Streams are cleaned up on `close()` and when a camera is lost.
     */
    events(cameraId: string): CameraEventStream;
    /**
     * Get a bound camera object with the ID pre-applied to all methods.
     * Lazily created and cached. Includes `events` accessor.
     */
    camera(cameraId: string): BoundCamera;
    connect(id: string, opts?: {
        mode?: ConnectionMode;
        reconnecting?: 'on' | 'off';
    }): Promise<void>;
    disconnect(id: string): Promise<void>;
    /**
     * Manually trigger camera discovery. Always performs enumeration regardless
     * of connection state. Use this for multi-camera workflows where autoConnect
     * is disabled and you want explicit control over when discovery happens.
     */
    discover(): Promise<ManagedCamera[]>;
    /**
     * Connect all detected (unconnected) cameras in parallel.
     * Each connection awaits SSE confirmation before resolving.
     */
    connectAll(opts?: {
        mode?: ConnectionMode;
        reconnecting?: 'on' | 'off';
    }): Promise<void>;
    on<T extends CameraManagerEventType>(event: T, callback: EventCallback<T>): this;
    off<T extends CameraManagerEventType>(event: T, callback?: EventCallback<T>): this;
    private poll;
    private doPoll;
    private onSSEConnected;
    private onSSEDisconnected;
    private ensureReady;
    private doConnect;
    private waitForSSEConnected;
    private scheduleReconnect;
    private emit;
}
export {};
//# sourceMappingURL=CameraManagerCore.d.ts.map