import { type CleanupRecord } from '../backend-contract/errors.js';
import { type SerializableRecord } from '../backend-contract/primitives.js';
import type { HostNeutralBackendIdentity } from '../backend-contract/identity.js';
import type { RendererLeaseIdentity } from '../backend-contract/electron.js';
import type { ScanSession, Subscription } from '../manager/ble-manager.js';
import type { ElectronBleIpcEvent } from './protocol.js';
/**
 * `terminalized` means main has terminalized the exact stream or made the
 * exact renderer lease release-required because delivery was impossible.
 */
export type ElectronEventDelivery = 'delivered' | 'terminalized';
export interface ManagedScan {
    readonly scan: ScanSession<string>;
    pump: Promise<void>;
    cleanupRequested: boolean;
    retryHandle: ReturnType<typeof setTimeout> | null;
    terminalPublished: boolean;
}
export interface ManagedSubscription {
    readonly databaseHandle: string;
    readonly subscription: Subscription<string, HostNeutralBackendIdentity<string>>;
    pump: Promise<void>;
    cleanupRequested: boolean;
    retryHandle: ReturnType<typeof setTimeout> | null;
    terminalPublished: boolean;
}
export interface RendererStreamResources {
    readonly scans: Map<string, ManagedScan>;
    readonly subscriptions: Map<string, ManagedSubscription>;
}
export interface ElectronRendererStreamRegistryOptions {
    readonly maximumMessageBytes: number;
    readonly now?: () => number;
    readonly publish: (rendererLeaseId: string, event: ElectronBleIpcEvent) => Promise<ElectronEventDelivery>;
    readonly createEvent: (rendererLease: RendererLeaseIdentity, streamId: string, item: SerializableRecord) => ElectronBleIpcEvent;
}
/**
 * Owns the source side of renderer stream forwarding. A terminal caused by an
 * IPC limit, a source failure, or a frozen renderer always attempts to stop
 * the native producer before the terminal record is emitted.
 */
export declare class ElectronRendererStreamRegistry {
    private readonly options;
    constructor(options: ElectronRendererStreamRegistryOptions);
    registerScan(resources: RendererStreamResources, rendererLease: RendererLeaseIdentity, handle: string, scan: ScanSession<string>): ManagedScan;
    registerSubscription(resources: RendererStreamResources, rendererLease: RendererLeaseIdentity, handle: string, databaseHandle: string, subscription: Subscription<string, HostNeutralBackendIdentity<string>>): ManagedSubscription;
    stopScan(resources: RendererStreamResources, handle: string, resource: ManagedScan, awaitPump: boolean): Promise<CleanupRecord>;
    removeSubscription(resources: RendererStreamResources, handle: string, resource: ManagedSubscription, awaitPump: boolean): Promise<CleanupRecord>;
    terminate(resources: RendererStreamResources, rendererLease: RendererLeaseIdentity, streamId: string, reason: 'renderer-backpressure' | 'renderer-unavailable'): Promise<boolean>;
    private forwardStream;
    private completeTerminalScan;
    private completeTerminalSubscription;
    private terminalizeScan;
    private terminalizeSubscription;
    private scheduleScanRetry;
    private scheduleSubscriptionRetry;
    private clearRetry;
    private publishTerminal;
    private cleanupResource;
}
//# sourceMappingURL=renderer-stream-registry.d.ts.map