import type { BackendAttachment, BackendConnection, BackendEvent, BleCentralBackend, GattBackend, PeerDirectoryBackend, ResourceCounters } from '../backend-contract/backend.js';
import { BackendContractError } from '../backend-contract/errors.js';
import type { BleErrorCode, CleanupRecord } from '../backend-contract/errors.js';
import type { AdapterDescriptor, AttachmentRecord, BackendProvider, HostNeutralBackendIdentity, ProviderDescriptor } from '../backend-contract/identity.js';
import type { CharacteristicPath, DescriptorPath } from '../backend-contract/gatt.js';
import type { PublicOperationOptions, SubscriptionOptions, WritePolicy, WriteReceipt } from '../backend-contract/operations.js';
import type { AdapterId, BackendCompatibilityOffer, Deadline, OwnedBytes, PeerId } from '../backend-contract/primitives.js';
import type { BoundedAsyncStream } from '../backend-contract/streams.js';
import type { ChooserRequest, ChooserSelection, WebChooser } from '../backend-contract/host/web.js';
import type { WebBluetoothBoundary } from './web-bluetooth-boundary.js';
import { WebBackendConnection, WebGattDatabase } from './web-bluetooth-handles.js';
import type { WebConnectionRecord } from './web-bluetooth-handles.js';
interface AbortableOperation {
    readonly signal: AbortSignal | null;
    readonly deadline: Deadline | null;
}
interface WebProviderOptions {
    readonly boundary: WebBluetoothBoundary;
}
/** Explicit Web Bluetooth provider. Importing this module never reads DOM globals. */
export declare class WebBluetoothProvider implements BackendProvider<string, HostNeutralBackendIdentity<string>> {
    private readonly options;
    readonly descriptor: ProviderDescriptor;
    constructor(options: WebProviderOptions);
    listAdapters(): Promise<readonly AdapterDescriptor<string>[]>;
    create(selection: {
        readonly selectedAdapterId: AdapterId<string>;
    }): Promise<WebBluetoothBackend>;
}
export declare function createWebBluetoothProvider(boundary: WebBluetoothBoundary): WebBluetoothProvider;
export interface WebAuthorizedPeer {
    readonly peerId: PeerId<string>;
    readonly browserDeviceId: string;
    readonly connected: boolean;
}
/** Contract-v1 Web Bluetooth backend with chooser-limited discovery semantics. */
export declare class WebBluetoothBackend implements BleCentralBackend<string, HostNeutralBackendIdentity<string>>, WebChooser<string> {
    private readonly boundary;
    readonly features: import("../backend-contract/index.js").FeatureRegistry;
    readonly adapter: BleCentralBackend<string, HostNeutralBackendIdentity<string>>['adapter'];
    readonly scanner: BleCentralBackend<string, HostNeutralBackendIdentity<string>>['scanner'];
    readonly connections: BleCentralBackend<string, HostNeutralBackendIdentity<string>>['connections'];
    readonly gatt: GattBackend<string>;
    readonly peers: PeerDirectoryBackend<string>;
    private readonly backendInstance;
    private attachmentRecord;
    private attachmentGeneration;
    private negotiatedVersions;
    private attached;
    private destroyed;
    private chooserBusy;
    private nextPeer;
    private nextConnection;
    private ingressOrdinal;
    private destroyResult;
    private readonly selectedDevices;
    private readonly peerByBrowserDeviceId;
    private readonly connectionsByPeer;
    private readonly retainedConnections;
    private readonly pendingConnectionsByPeer;
    private readonly eventStreams;
    private readonly adapterStreams;
    private readonly destroyWaiters;
    private readonly gattRuntime;
    private removePageLifecycleListener;
    private removeAvailabilityChangeListener;
    private availabilityPollTimer;
    private availabilityEventSilenceTimer;
    private availabilityChangeObserved;
    private availabilitySampleGeneration;
    private appliedAvailabilitySampleGeneration;
    constructor(boundary: WebBluetoothBoundary, initialAvailability?: boolean);
    get identity(): HostNeutralBackendIdentity<string>;
    get attachment(): AttachmentRecord<string>;
    attach(request: {
        readonly coreCompatibility: BackendCompatibilityOffer;
    }): Promise<BackendAttachment<string, HostNeutralBackendIdentity<string>>>;
    choose(request: ChooserRequest, options: PublicOperationOptions): Promise<ChooserSelection<string>>;
    authorizedPeers(options?: PublicOperationOptions): Promise<readonly WebAuthorizedPeer[]>;
    private peerRecords;
    private resolveAuthorizedPeer;
    private toBackendPeerRecord;
    peerReferenceFor(peerId: string): {
        readonly backendId: string;
        readonly browserDeviceId: string;
    } | null;
    events(): BoundedAsyncStream<BackendEvent<string>>;
    resourceCounters(): ResourceCounters;
    destroy(): Promise<CleanupRecord>;
    disconnectConnection(connection: WebBackendConnection): Promise<CleanupRecord>;
    disconnectRecord(record: WebConnectionRecord, reason?: 'connection-lost' | 'owner-released'): Promise<CleanupRecord>;
    private runDisconnectRecord;
    staleGattError(operation: string): BackendContractError;
    readDirect(database: WebGattDatabase, path: CharacteristicPath<string, string, string, string, string, 'current'>, options: PublicOperationOptions): Promise<OwnedBytes>;
    writeDirect(database: WebGattDatabase, path: CharacteristicPath<string, string, string, string, string, 'current'>, value: Readonly<Uint8Array>, options: WritePolicy): Promise<WriteReceipt<string, string>>;
    readDescriptorDirect(database: WebGattDatabase, path: DescriptorPath<string, string, string, string, string, string, 'current'>, options: PublicOperationOptions): Promise<OwnedBytes>;
    writeDescriptorDirect(database: WebGattDatabase, path: DescriptorPath<string, string, string, string, string, string, 'current'>, value: Readonly<Uint8Array>, options: WritePolicy): Promise<WriteReceipt<string, string>>;
    subscribeDirect(database: WebGattDatabase, path: CharacteristicPath<string, string, string, string, string, 'current'>, options: SubscriptionOptions): Promise<import('../backend-contract/gatt.js').Subscription<string, string, string, string, string, string>>;
    private currentAdapterState;
    private assertBluetoothAvailable;
    private beginAvailabilitySample;
    private applyAvailabilitySample;
    private refreshAttachmentAvailability;
    private invalidateUnavailableSession;
    private releaseRetainedSessionResources;
    private createAttachmentRecord;
    private watchAdapterState;
    private ensureAvailabilityObservation;
    private releaseAvailabilityObservationIfIdle;
    private stopAvailabilityObservation;
    private scheduleAvailabilityEventSilenceFallback;
    private clearAvailabilityEventSilenceTimer;
    private scheduleAvailabilityPoll;
    private pollWatchedAvailability;
    private reconcileWatchedAvailability;
    private chooseDevice;
    private rememberSelection;
    private connect;
    private compensatePendingConnection;
    private deletePendingConnectionIfOwned;
    private invalidateConnectionGenerations;
    private unbindConnectionRecord;
    requireConnection(connection: BackendConnection<string, string>, operation: string): WebConnectionRecord;
    requireDatabase(path: CharacteristicPath<string, string, string, string, string> | DescriptorPath<string, string, string, string, string, string>, operation: string): WebGattDatabase;
    runAbortable<Result>(record: WebConnectionRecord | null, operation: AbortableOperation, start: () => Promise<Result>, fallbackCode: BleErrorCode, domain: 'chooser' | 'connection' | 'gatt', operationName: string, onLateSuccess?: ((result: Result) => Promise<void> | void) | null): Promise<Result>;
    private assertAbortableAdmission;
    private cancelInFlightOperations;
    private emitBackendEvent;
    identifiers(): import("../backend-contract/primitives.js").AttachmentBoundIdFactory<string>;
    private assertAttached;
    private assertUsable;
    private destroyAllResources;
}
export declare const WEB_BLUETOOTH_ADAPTER_ID: import("../backend-contract/primitives.js").OpaqueId<"adapter", "web-bluetooth">;
export {};
//# sourceMappingURL=web-bluetooth-backend.d.ts.map