import { type CleanupRecord } from '../backend-contract/errors.js';
import type { BoundedAsyncStream, OverflowPolicy, StreamLimits, StreamTerminalNotice } from '../backend-contract/streams.js';
import { type SerializableRecord } from '../backend-contract/primitives.js';
import type { GattDatabaseChangedEvent } from '../backend-contract/gatt.js';
import { type BleCapabilities } from '../public/capabilities.js';
import type { PortableCurrentCharacteristicPath, PortableCurrentDescriptorPath, PortableDatabasePath, PortableGattDatabaseSnapshot, PortableOperationOptions, PortableSubscriptionOptions, PortableWritePolicy } from '../manager/consumer-handles.js';
import type { AdvertisementObservation } from '../backend-contract/advertisement.js';
import type { PeerReference } from '../backend-contract/peer-reference.js';
import type { ScanPlan } from '../backend-contract/scan-planning.js';
import type { CleanupRecord as PublicCleanupRecord } from '../public/cleanup.js';
import type { IpcCapabilitySnapshotV2, IpcClientTransport } from './protocol.js';
import type { NormalizedScanQuery } from '../backend-contract/scan-query.js';
export { advertisementPassesViewFilter, type AdvertisementViewFilter, type AdvertisementViewRecord } from './advertisement-view-filter.js';
export interface IpcBleManagerCreateOptions {
    readonly now?: () => number;
}
export interface IpcPendingStreamAccounting {
    readonly pendingIdCount: number;
    readonly pendingItemCount: number;
    readonly pendingByteCount: number;
    readonly tombstoneCount: number;
    readonly activeStreamHandles: readonly string[];
}
export declare function inspectIpcPendingStreamAccountingForTests(manager: IpcBleManager): IpcPendingStreamAccounting;
export interface IpcProvisionalAdmissionAccounting {
    readonly unresolvedConnectionCount: number;
    readonly unresolvedEventSubscriptionCount: number;
    readonly unresolvedGattSubscriptionCount: number;
    readonly unresolvedDatabaseCount: number;
}
export declare function inspectIpcProvisionalAdmissionForTests(manager: IpcBleManager): IpcProvisionalAdmissionAccounting;
export interface IpcManagerOperationOptions {
    readonly signal?: AbortSignal;
    readonly timeoutMs?: number;
    readonly deadline?: number | null;
    readonly reason?: Extract<GattDatabaseChangedEvent['reason'], 'service-changed' | 'manual-rediscovery'>;
    readonly deliveryMode?: 'prefer-notification' | 'prefer-indication' | 'require-notification' | 'require-indication';
    readonly stream?: {
        readonly itemCapacity: number;
        readonly byteCapacity: number;
        readonly reservedControlCapacity: number;
        readonly overflowPolicy: OverflowPolicy;
    };
}
export interface IpcScanOptions extends IpcManagerOperationOptions {
    readonly query?: NormalizedScanQuery;
    readonly serviceUuids?: readonly string[];
    readonly manufacturerData?: readonly {
        readonly companyId: number;
        readonly dataPrefix?: Readonly<Uint8Array>;
    }[];
    readonly localNamePrefix?: string | null;
}
export interface IpcWriteOptions extends IpcManagerOperationOptions {
    readonly mode?: 'with-response' | 'without-response';
}
export interface IpcManufacturerData {
    readonly companyId: number;
    readonly data: Uint8Array;
}
export interface IpcServiceData {
    readonly uuid: string;
    readonly data: Uint8Array;
}
export interface IpcAdvertisement {
    readonly peerId: string;
    readonly peerReference?: PeerReference;
    readonly localName: string | null;
    readonly rssi: number | null;
    readonly txPowerLevel: number | null;
    readonly serviceUuids: readonly string[];
    readonly manufacturerData: readonly IpcManufacturerData[];
    readonly serviceData: readonly IpcServiceData[];
}
export type IpcScanObservation = IpcAdvertisement | AdvertisementObservation<string>;
export interface IpcNotificationValue {
    readonly value: Uint8Array;
    readonly delivery: 'notification' | 'indication' | 'unknown';
    readonly observedAtMonotonicMs: number;
    readonly sequence: number;
}
export interface IpcWriteReceipt {
    readonly terminal: {
        readonly correlation: string;
        readonly outcome: 'succeeded' | 'failed';
        readonly cause: string | null;
    };
    readonly mode: 'with-response' | 'without-response';
    readonly commitState: 'confirmed' | 'accepted' | 'unknown' | 'not-started';
    readonly bytesSubmitted: number;
}
interface IpcConnectionEventSubscription {
    readonly events: BoundedAsyncStream<SerializableRecord>;
    unsubscribe(): Promise<CleanupRecord>;
}
export interface IpcCharacteristicRecord extends SerializableRecord {
    readonly handle: string;
    readonly serviceUuid: string;
    readonly serviceOccurrence: string;
    readonly characteristicUuid: string;
    readonly characteristicOccurrence: string;
    readonly properties: readonly string[];
}
export interface IpcServiceRecord extends SerializableRecord {
    readonly uuid: string;
    readonly occurrence: string;
    readonly primary: boolean;
    readonly includedServices: readonly {
        readonly uuid: string;
        readonly occurrence: string;
    }[];
}
export interface IpcDescriptorRecord extends SerializableRecord {
    readonly handle: string;
    readonly characteristicHandle: string;
    readonly uuid: string;
    readonly occurrence: string;
}
/**
 * Framework-neutral manager façade for a trusted desktop webview transport.
 * The native host owns radio resources; this object only owns opaque handles,
 * cancellation, bounded stream projections, and deterministic release.
 */
export declare class IpcBleManager<Attachment extends string = string, Client extends string = string> {
    private readonly client;
    readonly capabilities: BleCapabilities;
    private readonly now;
    private readonly streams;
    private readonly pendingStreams;
    private readonly pendingStreamOverflows;
    private readonly pendingTombstones;
    private aggregatePendingItems;
    private aggregatePendingBytes;
    private readonly eventPump;
    private nextConnectionEventHandle;
    private lifecycle;
    private releaseResult;
    private readonly ownerCleanupLedger;
    private pumpDead;
    private pumpFailure;
    private readonly unresolvedProvisionals;
    private constructor();
    static create<Attachment extends string, Client extends string>(transport: IpcClientTransport<Attachment, Client>, options?: IpcBleManagerCreateOptions): Promise<IpcBleManager<Attachment, Client>>;
    get bootstrap(): import("./protocol.js").IpcClientBootstrap<Attachment, Client>;
    adapterState(options?: IpcManagerOperationOptions): Promise<SerializableRecord>;
    scan(options?: IpcScanOptions): Promise<IpcScanSession>;
    connect(peerId: string, options?: IpcManagerOperationOptions): Promise<IpcConnection>;
    destroy(): Promise<PublicCleanupRecord>;
    private runDestroy;
    route(command: string, payload: SerializableRecord, binaryPayload?: Uint8Array | null, signal?: AbortSignal | null | undefined): Promise<SerializableRecord>;
    hasRegisteredStream(handle: string): boolean;
    registerStream<Value>(handle: string, isValue: (value: unknown) => value is Value, limits?: StreamLimits, overflowPolicy?: OverflowPolicy, onTerminal?: (reason: StreamTerminalNotice['reason']) => void): BoundedAsyncStream<Value>;
    subscribeConnectionEvents(connectionHandle: string, identity: SerializableRecord, signal?: AbortSignal): Promise<IpcConnectionEventSubscription>;
    private admitConnectionEvents;
    closeStream(handle: string, reason?: 'owner-released' | 'source-failed' | 'connection-lost' | 'service-changed'): void;
    private pumpEvents;
    private terminalizeEventPump;
    private captureOwnerCleanup;
    private flushOwnerCleanupLedger;
    private bufferPendingStreamItem;
    private pendingAccounting;
    private expirePendingState;
    private enforceAggregatePendingBudget;
    private oldestPendingStreamId;
    private evictPendingStream;
    private takePendingStream;
    private discardPendingStream;
    private rememberTombstone;
    private recordPendingOverflow;
    private clearPendingAccounting;
    private assertPendingAccounting;
    private assertActive;
    retryUnresolvedAdmissionCleanup(): Promise<{
        readonly error?: unknown;
        readonly cleanup?: CleanupRecord;
    }[]>;
    private provisionalAdmissionAccounting;
    private compensateFailedConnect;
    compensateFailedGattAdmission(kind: 'gatt-subscription' | 'gatt-database', handle: string | null, command: 'gatt.unsubscribe' | 'gatt.database.release', payload: SerializableRecord, admissionError: unknown): Promise<never>;
    private compensateFailedEventAdmission;
    private flushUnresolvedProvisionals;
}
export declare function projectRemoteCapabilities(snapshot: IpcCapabilitySnapshotV2): IpcCapabilitySnapshotV2;
export declare class IpcScanSession {
    private readonly manager;
    readonly handle: string;
    readonly observations: BoundedAsyncStream<IpcScanObservation>;
    readonly plan: ScanPlan | null;
    private stopResult;
    constructor(manager: IpcBleManager, handle: string, observations: BoundedAsyncStream<IpcScanObservation>, plan: ScanPlan | null);
    stop(): Promise<CleanupRecord>;
}
export declare class IpcConnection {
    private readonly manager;
    readonly handle: string;
    readonly peerId: string;
    private readonly lifecycleEvents;
    private lifecycleAdmission;
    private readonly admissionAbort;
    private lifecycleSubscription;
    private readonly databases;
    private readonly _connectionId;
    private readonly _ownerLeaseId;
    private readonly _connectionGeneration;
    private disconnectResult;
    private lifecycleReleased;
    private connectionReleased;
    constructor(manager: IpcBleManager, handle: string, peerId: string, connectionId: string, ownerLeaseId: string, connectionGeneration: string);
    get connectionId(): string;
    get ownerLeaseId(): string;
    get connectionGeneration(): string;
    get attachmentId(): string;
    get events(): BoundedAsyncStream<SerializableRecord>;
    private ensureLifecycleAdmission;
    private pumpLifecycleEvents;
    registerDatabase(database: IpcGattDatabase): void;
    private invalidateDatabases;
    discover(options?: IpcManagerOperationOptions): Promise<IpcGattDatabase>;
    rediscoverGatt(options: IpcManagerOperationOptions, reason: Extract<GattDatabaseChangedEvent['reason'], 'service-changed' | 'manual-rediscovery'>): Promise<IpcGattDatabase>;
    readRssi(options?: IpcManagerOperationOptions): Promise<number>;
    maximumWriteLength(mode?: 'with-response' | 'without-response'): Promise<number>;
    disconnect(): Promise<CleanupRecord>;
    private disconnectInternal;
    release(): Promise<CleanupRecord>;
    private identityPayload;
    private awaitLifecycleAdmission;
}
export declare class IpcGattDatabase {
    readonly manager: IpcBleManager;
    readonly connection: IpcConnection;
    readonly handle: string;
    readonly databaseId: string;
    readonly databaseGeneration: string;
    readonly serviceRecords: readonly IpcServiceRecord[];
    readonly characteristics: readonly IpcCharacteristic[];
    readonly descriptors: readonly IpcDescriptor[];
    private valid;
    private pendingChangedReason;
    private readonly changedStream;
    private readonly subscriptions;
    private constructor();
    static fromPayload(manager: IpcBleManager, connection: IpcConnection, payload: SerializableRecord): IpcGattDatabase;
    route(command: string, payload: SerializableRecord, binaryPayload: Uint8Array | null, signal?: AbortSignal): Promise<SerializableRecord>;
    assertCurrent(): void;
    get changed(): BoundedAsyncStream<GattDatabaseChangedEvent>;
    invalidate(reason?: GattDatabaseChangedEvent['reason'] | null): Promise<CleanupRecord>;
    private terminalizeChanged;
    registerStream<Value>(handle: string, isValue: (value: unknown) => value is Value, limits?: StreamLimits, overflowPolicy?: OverflowPolicy, onTerminal?: (reason: StreamTerminalNotice['reason']) => void): BoundedAsyncStream<Value>;
    hasRegisteredStream(handle: string): boolean;
    closeStream(handle: string, reason?: 'owner-released' | 'source-failed' | 'connection-lost' | 'service-changed'): void;
    registerSubscription(subscription: IpcSubscription): void;
    forgetSubscription(subscription: IpcSubscription): void;
    private connectionIdentityPayload;
    get path(): PortableDatabasePath;
    monotonicNow(): number;
    scheduleDeadline(deadline: number, action: () => void): {
        cancel: () => void;
    };
    snapshot(): Promise<PortableGattDatabaseSnapshot>;
    read(path: PortableCurrentCharacteristicPath, options?: PortableOperationOptions): Promise<Uint8Array>;
    write(path: PortableCurrentCharacteristicPath, bytes: Readonly<Uint8Array>, options: PortableWritePolicy): Promise<IpcWriteReceipt>;
    subscribe(path: PortableCurrentCharacteristicPath, options?: PortableSubscriptionOptions): Promise<IpcSubscription>;
    readDescriptor(path: PortableCurrentDescriptorPath, options?: PortableOperationOptions): Promise<Uint8Array>;
    writeDescriptor(path: PortableCurrentDescriptorPath, bytes: Readonly<Uint8Array>, options: PortableWritePolicy): Promise<IpcWriteReceipt>;
    private characteristicForPath;
    private descriptorForPath;
}
export declare class IpcCharacteristic {
    private readonly database;
    readonly record: IpcCharacteristicRecord;
    constructor(database: IpcGattDatabase, record: IpcCharacteristicRecord);
    get handle(): string;
    read(options?: IpcManagerOperationOptions): Promise<Uint8Array>;
    write(bytes: Readonly<Uint8Array>, options?: IpcWriteOptions): Promise<SerializableRecord>;
    subscribe(options?: IpcManagerOperationOptions): Promise<IpcSubscription>;
}
export declare class IpcDescriptor {
    private readonly database;
    readonly record: IpcDescriptorRecord;
    constructor(database: IpcGattDatabase, record: IpcDescriptorRecord);
    read(options?: IpcManagerOperationOptions): Promise<Uint8Array>;
    write(bytes: Readonly<Uint8Array>, options?: IpcWriteOptions): Promise<IpcWriteReceipt>;
}
export declare class IpcSubscription {
    private readonly database;
    readonly handle: string;
    readonly values: BoundedAsyncStream<IpcNotificationValue>;
    path: PortableCurrentCharacteristicPath | null;
    private removeResult;
    constructor(database: IpcGattDatabase, handle: string, values: BoundedAsyncStream<IpcNotificationValue>);
    get subscriptionId(): string;
    remove(): Promise<CleanupRecord>;
    closeFromDatabase(reason: 'connection-lost' | 'service-changed'): Promise<CleanupRecord>;
}
//# sourceMappingURL=manager.d.ts.map