import type { AdvertisementObservation, OwnerScanOptions } from './advertisement';
import type { FeatureRegistry } from './capabilities';
import { type AdapterStateSnapshot, type AdapterStateWatch, type AttachmentRecord, type BackendIdentity } from './identity';
import type { CharacteristicPath, ConnectionPath, DatabasePath, DescriptorPath, GattDatabase } from './gatt';
import type { NotificationValue } from './gatt';
import type { BackendOperationDispatch, OperationOptions, OperationTerminalRecord, PublicOperationOptions, ReadRequest, ReadResult, SubscribeRequest, WriteRequest, WriteResult } from './operations';
import type { ConnectionMaximumWriteLengthMeasurement, ConnectionMaximumWriteLengthRequest, ConnectionPhyObservation, ConnectionPhyRequest, ConnectionPriorityRequest, ConnectionWriteReadinessWatch, EffectiveMtuMeasurement, EffectiveMtuRequest, MtuNegotiation, ReadRssiRequest, ReadPhyRequest, RequestPhyRequest, RequestPriorityRequest, RequestMtuRequest, RssiMeasurement } from './connection-controls';
import type { CleanupRecord } from './errors';
import type { AttachmentId, BackendCompatibilityOffer, ClientId, ConnectionId, GenerationId, LeaseId, ManagerId, PeerId, ResourceCount, ScanShareToken, ScanSessionId, SubscriptionId, SerializableRecord } from './primitives';
import type { BoundedAsyncStream } from './streams';
import type { ManagerRestorationCapability } from './restoration';
import type { PeerReference } from './peer-reference';
import type { SecurityBackend } from './security';
import type { DiagnosticTraceDocument } from '../diagnostics/trace-format';
import type { NormalizedScanQuery } from './scan-query';
import type { ScanPlan } from './scan-planning';
export type OwnerMode = 'owning' | 'borrowing';
export type ManagerState = 'new' | 'ready' | 'destroying' | 'destroyed' | 'failed';
export type ConnectionState = 'connecting' | 'connected' | 'disconnecting' | 'disconnected' | 'lost';
export interface ResourceCounters {
    readonly activeScanControllers: ResourceCount;
    readonly scanConsumers: ResourceCount;
    readonly chooserSessions: ResourceCount;
    readonly connectionLeases: ResourceCount;
    readonly physicalLinks: ResourceCount;
    readonly databaseSnapshots: ResourceCount;
    readonly physicalCccdEnablements: ResourceCount;
    readonly subscriptionConsumers: ResourceCount;
    readonly queuedOperations: ResourceCount;
    readonly dispatchedOperations: ResourceCount;
    readonly retainedByteBuffers: ResourceCount;
    readonly restorationRecords: ResourceCount;
    readonly orphanedIpcOwners: ResourceCount;
}
export interface AdapterBackend<Attachment extends string> {
    currentState(): Promise<AdapterStateSnapshot<Attachment>>;
    watchState(): Promise<AdapterStateWatch<Attachment>>;
}
export type PeerSource = 'scan-observed' | 'app-reference' | 'system-connected' | 'system-bonded' | 'origin-authorized' | 'restored' | 'backend-cache';
export interface BlePeerState {
    readonly reachability: 'reachable' | 'unreachable' | 'unknown';
    readonly connection: 'connected' | 'disconnected' | 'unknown';
    readonly bond: 'bonded' | 'not-bonded' | 'unknown' | 'unsupported';
    readonly lastSeenAtMonotonicMs: number | null;
}
export interface BackendPeerQuery extends PublicOperationOptions {
    readonly sources?: readonly PeerSource[];
    readonly services?: readonly string[];
    readonly references?: readonly PeerReference[];
    readonly includeUnavailable?: boolean;
}
export interface BackendPeerRecord<Attachment extends string> {
    readonly reference: PeerReference;
    readonly peerId: PeerId<Attachment>;
    readonly name: string | null;
    readonly rssi: number | null;
    readonly source: PeerSource;
    readonly state: BlePeerState;
    readonly clockScope?: string;
}
export interface PeerDirectoryBackend<Attachment extends string> {
    resolve(reference: PeerReference, options: BackendPeerQuery): Promise<BackendPeerRecord<Attachment> | null>;
    known(options: BackendPeerQuery): Promise<readonly BackendPeerRecord<Attachment>[]>;
    connected(options: BackendPeerQuery): Promise<readonly BackendPeerRecord<Attachment>[]>;
    bonded(options: BackendPeerQuery): Promise<readonly BackendPeerRecord<Attachment>[]>;
    authorized(options: BackendPeerQuery): Promise<readonly BackendPeerRecord<Attachment>[]>;
    restored(options: BackendPeerQuery): Promise<readonly BackendPeerRecord<Attachment>[]>;
}
export interface ScanLease<Attachment extends string, _Lease extends string> {
    readonly scanSessionId: ScanSessionId<Attachment, string>;
    readonly leaseId: LeaseId<Attachment, string>;
    readonly shareToken: ScanShareToken<Attachment, string> | null;
    readonly observations: BoundedAsyncStream<AdvertisementObservation<Attachment>>;
    stop(): Promise<CleanupRecord>;
}
export interface ScannerBackend<Attachment extends string> {
    plan?(query: NormalizedScanQuery): ScanPlan;
    start(options: OwnerScanOptions<Attachment, string>, clientId: ClientId<Attachment, string>): Promise<ScanLease<Attachment, string>>;
    join(sharedLeaseId: LeaseId<Attachment, string>, shareToken: ScanShareToken<Attachment, string>, clientId: ClientId<Attachment, string>): Promise<ScanLease<Attachment, string>>;
}
export interface ConnectionLease<Attachment extends string, _Connection extends string, _Lease extends string> {
    readonly leaseId: LeaseId<Attachment, string>;
    readonly connection: BackendConnection<Attachment, string>;
    release(): Promise<CleanupRecord>;
}
export interface BackendConnection<Attachment extends string, _Connection extends string> {
    readonly attachment: AttachmentRecord<Attachment>;
    readonly attachmentId: AttachmentId<Attachment>;
    readonly peerId: PeerId<Attachment>;
    readonly connectionId: ConnectionId<Attachment, string>;
    readonly connectionGeneration: GenerationId<'connection-generation', string>;
    readonly state: ConnectionState;
    disconnect(): Promise<CleanupRecord>;
}
export type ConnectionIntent = 'direct' | 'when-available';
/**
 * A canonical out-of-band radio address accepted by the optional `peer:address-targeting`
 * capability. Only public/static addresses are expressible; resolvable private addresses
 * must re-enter through a durable `PeerReference`.
 */
export interface PeerAddressDescriptor {
    readonly address: string;
    readonly addressType: 'public' | 'random';
}
export type BlePhy = 'le-1m' | 'le-2m' | 'le-coded';
export interface ConnectionOptions extends PublicOperationOptions {
    readonly intent?: ConnectionIntent;
    readonly transport?: 'le' | 'auto';
    readonly preferredPhy?: readonly BlePhy[];
}
export interface ConnectionBackend<Attachment extends string> {
    connect(peerId: PeerId<Attachment>, clientId: ClientId<Attachment, string>, options: ConnectionOptions): Promise<ConnectionLease<Attachment, string, string>>;
    /**
     * Optional `peer:address-targeting` seam: mints a connectable peer handle for a canonical
     * radio address known out of band, without requiring a prior scan observation. Backends
     * that do not register the capability leave this undefined and callers fail closed.
     */
    peerFromAddress?(descriptor: PeerAddressDescriptor): PeerId<Attachment>;
    readRssi?<Operation extends string>(connection: BackendConnection<Attachment, string>, request: ReadRssiRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, RssiMeasurement<Attachment, Operation>>;
    requestMtu?<Operation extends string>(connection: BackendConnection<Attachment, string>, request: RequestMtuRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, MtuNegotiation<Attachment, Operation>>;
    effectiveMtu?<Operation extends string>(connection: BackendConnection<Attachment, string>, request: EffectiveMtuRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, EffectiveMtuMeasurement<Attachment, Operation>>;
    requestPriority?<Operation extends string>(connection: BackendConnection<Attachment, string>, request: RequestPriorityRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, ConnectionPriorityRequest<Attachment, Operation>>;
    readPhy?<Operation extends string>(connection: BackendConnection<Attachment, string>, request: ReadPhyRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, ConnectionPhyObservation<Attachment, Operation>>;
    requestPhy?<Operation extends string>(connection: BackendConnection<Attachment, string>, request: RequestPhyRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, ConnectionPhyRequest<Attachment, Operation>>;
    writeWithoutResponseReadiness?(connection: BackendConnection<Attachment, string>, options?: PublicOperationOptions): Promise<ConnectionWriteReadinessWatch<Attachment>>;
    maximumWriteLength?<Operation extends string>(connection: BackendConnection<Attachment, string>, request: ConnectionMaximumWriteLengthRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, ConnectionMaximumWriteLengthMeasurement<Attachment, Operation>>;
}
export interface GattBackend<Attachment extends string> {
    discover(connection: BackendConnection<Attachment, string>, options: PublicOperationOptions): Promise<GattDatabase<Attachment, string, string>>;
    read<Connection extends string, Database extends string, Service extends string, Characteristic extends string, Operation extends string>(path: CharacteristicPath<Attachment, Connection, Database, Service, Characteristic, 'current'>, request: ReadRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, ReadResult<Attachment, Operation>>;
    write<Connection extends string, Database extends string, Service extends string, Characteristic extends string, Operation extends string>(path: CharacteristicPath<Attachment, Connection, Database, Service, Characteristic, 'current'>, request: WriteRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, WriteResult<Attachment, Operation>>;
    readDescriptor<Connection extends string, Database extends string, Service extends string, Characteristic extends string, Descriptor extends string, Operation extends string>(path: DescriptorPath<Attachment, Connection, Database, Service, Characteristic, Descriptor, 'current'>, request: ReadRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, ReadResult<Attachment, Operation>>;
    writeDescriptor<Connection extends string, Database extends string, Service extends string, Characteristic extends string, Descriptor extends string, Operation extends string>(path: DescriptorPath<Attachment, Connection, Database, Service, Characteristic, Descriptor, 'current'>, request: WriteRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, WriteResult<Attachment, Operation>>;
    subscribe<Connection extends string, Database extends string, Service extends string, Characteristic extends string, Operation extends string>(path: CharacteristicPath<Attachment, Connection, Database, Service, Characteristic, 'current'>, request: SubscribeRequest<Attachment, Operation>): BackendOperationDispatch<Attachment, BackendSubscription<Attachment, string, string, string, string>>;
    unsubscribe<Connection extends string, Database extends string, Service extends string, Characteristic extends string, Operation extends string>(subscription: BackendSubscription<Attachment, Connection, Database, Service, Characteristic>, operation: OperationOptions<Attachment, Operation>): BackendOperationDispatch<Attachment, OperationTerminalRecord<Attachment, string>>;
}
export interface BackendSubscription<Attachment extends string, Connection extends string, Database extends string, Service extends string, Characteristic extends string> {
    readonly subscriptionId: SubscriptionId<Attachment, string, string, string, string, string>;
    readonly path: CharacteristicPath<Attachment, Connection, Database, Service, Characteristic, 'current'>;
    readonly terminal: OperationTerminalRecord<Attachment, string>;
    readonly notifications: BoundedAsyncStream<NotificationValue>;
}
export interface BackendEventBase<Attachment extends string> {
    readonly attachment: AttachmentRecord<Attachment>;
    readonly attachmentId: AttachmentId<Attachment>;
    readonly ingressOrdinal: number;
}
export interface BackendDatabaseChangedEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'database-changed';
    readonly database: DatabasePath<Attachment, string, string>;
}
/** A loss is scoped to the exact attachment, connection generation, and owner lease. */
export interface BackendConnectionLostEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'connection-lost';
    readonly connection: ConnectionPath<Attachment, string>;
}
export interface BackendGenericEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'adapter-state' | 'backend-restarted' | 'diagnostic';
}
/** Normalized scan delivery, separate from a stream's bounded overflow accounting record. */
export interface BackendScanResultEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'scan-result';
    readonly observation: AdvertisementObservation<Attachment>;
}
export interface BackendScanOverflowEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'scan-overflow';
    readonly scanSessionId: ScanSessionId<Attachment, string>;
    readonly policy: import('./streams').OverflowPolicy;
    readonly droppedItems: ResourceCount;
    readonly droppedBytes: ResourceCount;
    readonly replacedItems: ResourceCount;
}
export type BackendDisconnectReason = 'local' | 'peer' | 'adapter' | 'backend-restart';
export interface BackendConnectionStateChangedEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'connection-state-changed';
    readonly connection: ConnectionPath<Attachment, string>;
    readonly previous: ConnectionState;
    readonly current: ConnectionState;
    readonly reason: BackendDisconnectReason | null;
}
export interface BackendDisconnectedEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'disconnected';
    readonly connection: ConnectionPath<Attachment, string>;
    readonly reason: BackendDisconnectReason;
}
export interface BackendCharacteristicValueChangedEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'characteristic-value-changed';
    readonly path: CharacteristicPath<Attachment, string, string, string, string, 'current'>;
    readonly value: NotificationValue;
}
export interface BackendNotificationOverflowEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'notification-overflow';
    readonly subscriptionId: SubscriptionId<Attachment, string, string, string, string, string>;
    readonly policy: import('./streams').OverflowPolicy;
    readonly droppedItems: ResourceCount;
    readonly droppedBytes: ResourceCount;
    readonly replacedItems: ResourceCount;
}
export interface BackendMtuChangedEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'mtu-changed';
    readonly connection: ConnectionPath<Attachment, string>;
    readonly mtu: number;
    readonly maximumWriteLength: number;
}
export interface BackendBondSecurityEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'bond-security-changed';
    readonly peerId: PeerId<Attachment>;
    readonly bond: 'none' | 'bonding' | 'bonded' | 'failed' | 'unavailable';
    readonly security: 'unencrypted' | 'encrypted' | 'authenticated' | 'unavailable';
}
export interface BackendPhyChangedEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'phy-changed';
    readonly connection: ConnectionPath<Attachment, string>;
    readonly txPhy: '1m' | '2m' | 'coded' | 'unavailable';
    readonly rxPhy: '1m' | '2m' | 'coded' | 'unavailable';
}
export interface BackendPermissionStateChangedEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'permission-state-changed';
    readonly state: AdapterStateSnapshot<Attachment>;
}
export interface BackendRestorationEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'restoration-received';
    readonly record: SerializableRecord;
}
export interface BackendRestartingEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'backend-restarting';
    readonly reason: string;
}
export interface BackendDiagnosticEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: 'diagnostic-warning';
    readonly code: string;
    readonly message: string;
    readonly detail: SerializableRecord;
}
/** Open extension lane: namespaced event kinds retain typed serializable payloads without central-union edits. */
export interface BackendExtensionEvent<Attachment extends string> extends BackendEventBase<Attachment> {
    readonly kind: `extension:${string}`;
    readonly payload: SerializableRecord;
}
export type BackendEvent<Attachment extends string> = BackendDatabaseChangedEvent<Attachment> | BackendConnectionLostEvent<Attachment> | BackendGenericEvent<Attachment> | BackendScanResultEvent<Attachment> | BackendScanOverflowEvent<Attachment> | BackendConnectionStateChangedEvent<Attachment> | BackendDisconnectedEvent<Attachment> | BackendCharacteristicValueChangedEvent<Attachment> | BackendNotificationOverflowEvent<Attachment> | BackendMtuChangedEvent<Attachment> | BackendBondSecurityEvent<Attachment> | BackendPhyChangedEvent<Attachment> | BackendPermissionStateChangedEvent<Attachment> | BackendRestorationEvent<Attachment> | BackendRestartingEvent<Attachment> | BackendDiagnosticEvent<Attachment> | BackendExtensionEvent<Attachment>;
export declare function assertBackendEvent<Attachment extends string>(event: BackendEvent<Attachment>): void;
export interface BleCentralBackend<Attachment extends string, Identity extends BackendIdentity<Attachment>> {
    readonly identity: Identity;
    readonly adapter: AdapterBackend<Attachment>;
    readonly scanner: ScannerBackend<Attachment>;
    readonly connections: ConnectionBackend<Attachment>;
    readonly gatt: GattBackend<Attachment>;
    readonly security?: SecurityBackend;
    readonly peers?: PeerDirectoryBackend<Attachment>;
    readonly features: FeatureRegistry;
    readonly traceDocument?: () => DiagnosticTraceDocument;
    attach(request: BackendAttachmentRequest): Promise<BackendAttachment<Attachment, Identity>>;
    events(): BoundedAsyncStream<BackendEvent<Attachment>>;
    resourceCounters(): ResourceCounters;
    destroy(): Promise<CleanupRecord>;
}
/** Opaque result of the one manager-neutral backend attachment handshake. */
export declare abstract class AttachedBackend<Attachment extends string, Identity extends BackendIdentity<Attachment>> {
    private readonly authenticatedReceiptMarker;
    protected constructor();
    abstract readonly backend: BleCentralBackend<Attachment, Identity>;
    abstract readonly attachment: BackendAttachment<Attachment, Identity>;
    protected hasAuthenticatedReceiptMarker(): boolean;
}
/** Negotiates one backend attachment before logical manager admission. */
export declare function attachBackend<Attachment extends string, Identity extends BackendIdentity<Attachment>>(backend: BleCentralBackend<Attachment, Identity>, coreCompatibility: BackendCompatibilityOffer): Promise<AttachedBackend<Attachment, Identity>>;
/** Rejects mismatched backend/identity tuples before any manager can use the binding. */
export declare function assertAttachedBackend<Attachment extends string, Identity extends BackendIdentity<Attachment>>(attachedBackend: AttachedBackend<Attachment, Identity>): void;
export interface ManagerConstructionBase<Attachment extends string, Identity extends BackendIdentity<Attachment>> {
    readonly attachedBackend: AttachedBackend<Attachment, Identity>;
    readonly clientId: ClientId<Attachment, string>;
    readonly managerId: ManagerId<Attachment, string>;
    /** Present only when this provider owns a bound native restoration authority. */
    readonly restoration?: ManagerRestorationCapability<Attachment>;
}
export interface BackendAttachmentRequest {
    readonly coreCompatibility: BackendCompatibilityOffer;
}
export interface BackendAttachment<Attachment extends string, Identity extends BackendIdentity<Attachment>> {
    readonly attachment: AttachmentRecord<Attachment>;
    readonly identity: Identity;
}
export interface OwningManagerConstruction<Attachment extends string, Identity extends BackendIdentity<Attachment>> extends ManagerConstructionBase<Attachment, Identity> {
    readonly ownerMode: 'owning';
}
export interface BorrowingManagerConstruction<Attachment extends string, Identity extends BackendIdentity<Attachment>> extends ManagerConstructionBase<Attachment, Identity> {
    readonly ownerMode: 'borrowing';
}
export type ManagerConstruction<Attachment extends string, Identity extends BackendIdentity<Attachment>> = OwningManagerConstruction<Attachment, Identity> | BorrowingManagerConstruction<Attachment, Identity>;
//# sourceMappingURL=backend.d.ts.map