import type { AdapterStateSnapshot, BackendIdentity, BackendProvider, ManagerConstruction, OwnerMode } from '../backend-contract/index.js';
import type { AdvertisementObservation, ScanOptions } from '../backend-contract/advertisement.js';
import type { NormalizedScanQuery } from '../backend-contract/scan-query.js';
import type { ScanPlan } from '../backend-contract/scan-planning.js';
import type { CleanupRecord } from '../backend-contract/errors.js';
import type { CharacteristicPath, GattDatabaseChangedEvent, GattDatabaseSnapshot } from '../backend-contract/gatt.js';
import type { AdapterSelection } from '../backend-contract/identity.js';
import type { CapabilityDescriptor, FeatureId } from '../backend-contract/capabilities.js';
import type { WriteMode } from '../backend-contract/operations.js';
import type { AttachmentId, BackendCompatibilityOffer, PeerId } from '../backend-contract/primitives.js';
import type { AttachedBackend, BleCentralBackend, ConnectionOptions, OwningManagerConstruction } from '../backend-contract/backend.js';
import type { BoundedAsyncStream } from '../backend-contract/streams.js';
import type { RestorationAdoptionRequest, RestorationAdoptionResult } from '../backend-contract/restoration.js';
import type { SecurityBackend } from '../backend-contract/security.js';
import type { ConnectionPhyObservation, ConnectionPhyRequest, ConnectionPriority, ConnectionWriteReadinessWatch, PhyPreference } from '../backend-contract/connection-controls.js';
import type { DiagnosticTraceDocument } from '../diagnostics/trace-format.js';
import { UnifiedBleCore } from '../core/unified-ble-core.js';
import type { CoreDeadlineHandle, CoreScanSession, UnifiedBleCoreOptions } from '../core/unified-ble-core.js';
import { CoreConnection, CoreGattDatabase } from '../core/core-gatt-handles.js';
import { CoreSubscription } from '../core/subscription-registry.js';
import { type BleConnectionHandle, type BleManagerLifetime, type DeadlineHandle, type DiscoveredGattDatabaseHandle, type PortableCurrentCharacteristicPath, type PortableCurrentDescriptorPath, type PortableOperationOptions, type PortableSubscriptionOptions, type PortableWritePolicy, type SubscriptionHandle } from './consumer-handles.js';
import { ManagerOwnershipAuthority, type OwnershipRoleTransitionCapability, type OwnershipTransferGrant } from './manager-ownership-authority.js';
/** Internal non-enrolling bridge used by the authority to verify actual BleManager construction. */
export declare function isConstructedBleManagerOwnershipParticipant(participant: object): boolean;
export interface BleManagerOptions {
    readonly now: () => number;
    readonly timer?: UnifiedBleCoreOptions['timer'];
    readonly maximumValueBytes: UnifiedBleCoreOptions['maximumValueBytes'];
    readonly maximumAggregateRetainedBytes: number;
    readonly traceMaximumRecords: number;
    readonly traceMaximumBytes: number;
}
export interface ProviderBleManagerConstruction<Attachment extends string, Identity extends BackendIdentity<Attachment>> {
    readonly provider: BackendProvider<Attachment, Identity>;
    readonly selection: AdapterSelection<Attachment>;
    readonly coreCompatibility: BackendCompatibilityOffer;
    readonly manager: Omit<OwningManagerConstruction<Attachment, Identity>, 'attachedBackend'>;
}
export interface BackendBleManagerConstruction<Attachment extends string, Identity extends BackendIdentity<Attachment>> {
    readonly coreCompatibility: BackendCompatibilityOffer;
    readonly manager: Omit<OwningManagerConstruction<Attachment, Identity>, 'attachedBackend'>;
}
/**
 * Host-neutral public manager. Construction is explicit and delegates all
 * shared policy to UnifiedBleCore; it neither detects a host nor creates a
 * singleton or physical adapter owner on import.
 */
export declare class BleManager<Attachment extends string, Identity extends BackendIdentity<Attachment>> implements BleManagerLifetime {
    private readonly core;
    private readonly ownershipAuthority;
    private resourceReleaseResult;
    private destroyResult;
    private ownershipMode;
    private constructor();
    get state(): UnifiedBleCore<Attachment, Identity>['state'];
    get identity(): Identity;
    get attachmentId(): AttachmentId<Attachment>;
    get managerId(): ManagerConstruction<Attachment, Identity>['managerId'];
    get clientId(): ManagerConstruction<Attachment, Identity>['clientId'];
    get ownerMode(): OwnerMode;
    get attachedBackend(): AttachedBackend<Attachment, Identity>;
    get features(): import("../backend-contract/index.js").FeatureRegistry;
    securityBackend(): SecurityBackend | undefined;
    /** True only where the instantiated backend/core registry exposes an invocable feature implementation. */
    supports(id: FeatureId): boolean;
    /** Returns one immutable capability descriptor, or null when no registration exists. */
    capability(id: FeatureId): CapabilityDescriptor | null;
    /** Returns the immutable capability projection derived from negotiated registrations. */
    capabilities(): readonly CapabilityDescriptor[];
    /** Explicitly consumes the active provider's bounded native restoration journal. */
    adoptRestoration(request: RestorationAdoptionRequest<Attachment>): Promise<RestorationAdoptionResult<Attachment>>;
    static create<Attachment extends string, Identity extends BackendIdentity<Attachment>>(construction: ManagerConstruction<Attachment, Identity>, ownershipAuthority: ManagerOwnershipAuthority<Attachment, Identity>, options: BleManagerOptions): Promise<BleManager<Attachment, Identity>>;
    scan(options: ScanOptions<Attachment, string>): Promise<ScanSession<Attachment>>;
    planScan(query: NormalizedScanQuery): ScanPlan | null;
    connect(peerId: PeerId<Attachment>, options: ConnectionOptions): Promise<Connection<Attachment, Identity>>;
    destroy(): Promise<CleanupRecord>;
    traces(): readonly import("../core/index.js").CoreTraceRecord[];
    traceDocument(): DiagnosticTraceDocument;
    monotonicNow(): number;
    scheduleDeadline(deadlineAt: number, action: () => void): CoreDeadlineHandle;
    localResourceCounters(): import("../backend-contract/index.js").ResourceCounters;
    adapterState(): Promise<AdapterStateSnapshot<Attachment>>;
    adapterStates(options?: {
        readonly signal?: AbortSignal | null;
    }): Promise<{
        readonly initial: AdapterStateSnapshot<Attachment>;
        readonly values: BoundedAsyncStream<AdapterStateSnapshot<Attachment>>;
        stop(): Promise<CleanupRecord>;
    }>;
    /** Called only by the explicit authority during settled owner revocation. */
    revokeForOwnerDestroy(): Promise<CleanupRecord>;
    /** Settles this owner's resources, then atomically hands backend authority to an accepted borrower. */
    transferOwnership(grant: OwnershipTransferGrant<Attachment>): Promise<CleanupRecord>;
    acceptsOwnershipTransfer(): boolean;
    becomeOwnershipTransferDestination(capability: OwnershipRoleTransitionCapability): void;
    relinquishOwnershipTransferSource(capability: OwnershipRoleTransitionCapability): void;
    private releaseOwnedResources;
    private destroyBorrowingManager;
    private destroyOwningManager;
}
/** Explicitly creates a manager from a selected provider adapter. */
export declare function createBleManagerFromProvider<Attachment extends string, Identity extends BackendIdentity<Attachment>>(construction: ProviderBleManagerConstruction<Attachment, Identity>, options: BleManagerOptions): Promise<BleManager<Attachment, Identity>>;
/** Creates an owning manager for a host backend that has already been selected. */
export declare function createBleManagerFromBackend<Attachment extends string, Identity extends BackendIdentity<Attachment>>(backend: BleCentralBackend<Attachment, Identity>, construction: BackendBleManagerConstruction<Attachment, Identity>, options: BleManagerOptions, expectedAdapterId?: AdapterSelection<Attachment>['selectedAdapterId']): Promise<BleManager<Attachment, Identity>>;
/** Performs the one manager-neutral attachment handshake for a selected backend. */
export declare function attachBleBackend<Attachment extends string, Identity extends BackendIdentity<Attachment>>(backend: AttachedBackend<Attachment, Identity>['backend'], coreCompatibility: BackendCompatibilityOffer): Promise<AttachedBackend<Attachment, Identity>>;
/** Creates the explicit per-attachment authority shared by logical managers. */
export declare function createManagerOwnershipAuthority<Attachment extends string, Identity extends BackendIdentity<Attachment>>(attachedBackend: AttachedBackend<Attachment, Identity>): ManagerOwnershipAuthority<Attachment, Identity>;
/** Explicitly creates a manager from a backend that has already been selected by its host/provider. */
export declare function createBleManager<Attachment extends string, Identity extends BackendIdentity<Attachment>>(construction: ManagerConstruction<Attachment, Identity>, ownershipAuthority: ManagerOwnershipAuthority<Attachment, Identity>, options: BleManagerOptions): Promise<BleManager<Attachment, Identity>>;
export declare class ScanSession<Attachment extends string> {
    private readonly session;
    constructor(session: CoreScanSession<Attachment>);
    get scanSessionId(): CoreScanSession<Attachment>['scanSessionId'];
    get leaseId(): CoreScanSession<Attachment>['leaseId'];
    get shareToken(): CoreScanSession<Attachment>['shareToken'];
    get observations(): BoundedAsyncStream<AdvertisementObservation<Attachment>>;
    stop(): Promise<CleanupRecord>;
}
export declare class Connection<Attachment extends string, Identity extends BackendIdentity<Attachment>> implements BleConnectionHandle {
    private readonly connection;
    constructor(connection: CoreConnection<Attachment, Identity>);
    get peerId(): PeerId<Attachment>;
    get connectionId(): import("../backend-contract/index.js").ConnectionId<Attachment, string>;
    get ownerLeaseId(): import("../backend-contract/index.js").LeaseId<Attachment, string>;
    get connectionGeneration(): import("../backend-contract/index.js").GenerationId<"connection-generation", string>;
    get events(): BoundedAsyncStream<import("../backend-contract/index.js").ConnectionLifecycleEvent<Attachment>>;
    discover(options: PortableOperationOptions): Promise<DiscoveredGattDatabase<Attachment, Identity>>;
    rediscoverGatt(options: PortableOperationOptions, reason: Extract<GattDatabaseChangedEvent['reason'], 'service-changed' | 'manual-rediscovery'>): Promise<DiscoveredGattDatabase<Attachment, Identity>>;
    release(): Promise<CleanupRecord>;
    disconnect(): Promise<CleanupRecord>;
    readRssi(options: PortableOperationOptions): Promise<import("../backend-contract/connection-controls.js").RssiMeasurement<Attachment, string>>;
    requestMtu(requestedMtu: number, options: PortableOperationOptions): Promise<import("../backend-contract/connection-controls.js").MtuNegotiation<Attachment, string>>;
    effectiveMtu(): Promise<import("../backend-contract/connection-controls.js").EffectiveMtuMeasurement<Attachment, string>>;
    requestPriority(priority: ConnectionPriority, options: PortableOperationOptions): Promise<import("../backend-contract/connection-controls.js").ConnectionPriorityRequest<Attachment, string>>;
    readPhy(options: PortableOperationOptions): Promise<ConnectionPhyObservation<Attachment, string>>;
    requestPhy(preference: PhyPreference, options: PortableOperationOptions): Promise<ConnectionPhyRequest<Attachment, string>>;
    maximumWriteLength(mode: WriteMode, options: PortableOperationOptions): Promise<import("../backend-contract/connection-controls.js").ConnectionMaximumWriteLengthMeasurement<Attachment, string>>;
    writeWithoutResponseReadiness(options?: PortableOperationOptions): Promise<ConnectionWriteReadinessWatch<Attachment>>;
}
export declare class DiscoveredGattDatabase<Attachment extends string, Identity extends BackendIdentity<Attachment>> implements DiscoveredGattDatabaseHandle {
    private readonly database;
    private readonly discoverySnapshot;
    constructor(database: CoreGattDatabase<Attachment, Identity>, discoverySnapshot: GattDatabaseSnapshot<Attachment, string, string>);
    get path(): import("../backend-contract/index.js").DatabasePath<Attachment, string, string>;
    monotonicNow(): number;
    assertCurrent(): void;
    get changed(): BoundedAsyncStream<GattDatabaseChangedEvent>;
    scheduleDeadline(deadlineAt: number, action: () => void): DeadlineHandle;
    snapshot(): Promise<GattDatabaseSnapshot<Attachment, string, string>>;
    read(path: PortableCurrentCharacteristicPath, options: PortableOperationOptions): Promise<import("../backend-contract/index.js").OwnedBytes>;
    write(path: PortableCurrentCharacteristicPath, bytes: Readonly<Uint8Array>, options: PortableWritePolicy): Promise<import("../backend-contract/index.js").WriteReceipt<Attachment, string>>;
    writeWhenReady(path: PortableCurrentCharacteristicPath, bytes: Readonly<Uint8Array>, options: PortableWritePolicy): Promise<import("../backend-contract/index.js").WriteReceipt<Attachment, string>>;
    maximumWriteLength(path: PortableCurrentCharacteristicPath, mode: WriteMode): Promise<import("../backend-contract/index.js").MaximumWriteLengthObservation<Attachment>>;
    writeLong(path: PortableCurrentCharacteristicPath, bytes: Readonly<Uint8Array>, options: PortableWritePolicy): Promise<import("../backend-contract/index.js").LongWriteReceipt<Attachment, string>>;
    readDescriptor(path: PortableCurrentDescriptorPath, options: PortableOperationOptions): Promise<import("../backend-contract/index.js").OwnedBytes>;
    writeDescriptor(path: PortableCurrentDescriptorPath, bytes: Readonly<Uint8Array>, options: PortableWritePolicy): Promise<import("../backend-contract/index.js").WriteReceipt<Attachment, string>>;
    subscribe(path: PortableCurrentCharacteristicPath, options: PortableSubscriptionOptions): Promise<Subscription<Attachment, Identity>>;
    private resolveCharacteristicPath;
    private resolveDescriptorPath;
}
export declare class Subscription<Attachment extends string, Identity extends BackendIdentity<Attachment>> implements SubscriptionHandle {
    private readonly subscription;
    constructor(subscription: CoreSubscription<Attachment, Identity>);
    get subscriptionId(): import("../backend-contract/index.js").SubscriptionId<Attachment, string, string, string, string, string>;
    get path(): CharacteristicPath<Attachment, string, string, string, string, "current">;
    get values(): BoundedAsyncStream<import("../backend-contract/index.js").NotificationValue>;
    remove(): Promise<CleanupRecord>;
}
export declare const DEFAULT_BLE_MANAGER_OPTIONS: BleManagerOptions;
//# sourceMappingURL=ble-manager.d.ts.map