unified-ble-manager 4.0.0-alpha.0

package/lib/typescript/commonjs/src/BleManager.d.ts

@@ -0,0 +1,844 @@
+import { Device } from './Device';
+import { Service } from './Service';
+import { Characteristic } from './Characteristic';
+import { Descriptor } from './Descriptor';
+import { State, LogLevel, ConnectionPriority } from './TypeDefinition';
+import { EventEmitter } from './BleModule';
+import { BleError } from './BleError';
+import type { NativeCharacteristic, NativeDescriptor } from './BleModule';
+import type { BleErrorCodeMessageMapping, Subscription, DeviceId, Identifier, UUID, TransactionId, CharacteristicSubscriptionType, Base64, ScanOptions, ConnectionOptions, FindAndConnectOptions, BondState, BleManagerOptions, BleRestoredState, BackgroundModeOptions } from './TypeDefinition';
+import { type EventSubscription } from 'react-native';
+import { DeviceOperationQueue } from './DeviceOperationQueue';
+import { type LongWriteOptions, type LongWriteResult } from './longWrite';
+import { type BleCapability } from './supports';
+import { type BluetoothPermissionOptions, type PermissionCheckResult } from './permissions';
+/**
+ * Byte-path characteristic snapshot (parallel to Base64 {@link Characteristic}.value).
+ * Existing Characteristic.value remains Base64-only (3.x compat).
+ */
+export type CharacteristicAsBytes = {
+    deviceID: DeviceId;
+    serviceUUID: UUID;
+    uuid: UUID;
+    value: Uint8Array | null;
+};
+/** Byte-path descriptor snapshot (parallel to Base64 {@link Descriptor}.value). */
+export type DescriptorAsBytes = {
+    deviceID: DeviceId;
+    serviceUUID: UUID;
+    characteristicUUID: UUID;
+    uuid: UUID;
+    value: Uint8Array | null;
+};
+/**
+ *
+ * BleManager is an entry point for react-native-ble-plx library. It provides all means to discover and work with
+ * {@link Device} instances. It should be initialized only once with `new` keyword and method
+ * {@link #blemanagerdestroy|destroy()} should be called on its instance when user wants to deallocate all resources.
+ *
+ * In case you want to properly support Background Mode, you should provide `restoreStateIdentifier` and
+ * optionally `restoreStateFunction` in {@link BleManagerOptions}. Late subscribers can also call
+ * {@link #blemanagergetrestoredstate|getRestoredState()} for the buffered first restore payload.
+ *
+ * @example
+ * const manager = new BleManager();
+ * // ... work with BLE manager ...
+ * manager.destroy();
+ */
+export declare class BleManager {
+    _scanEventSubscription: EventSubscription | null;
+    _eventEmitter: InstanceType<typeof EventEmitter>;
+    _uniqueId: number;
+    _activePromises: {
+        [id: string]: (error: BleError) => void;
+    };
+    _activeSubscriptions: {
+        [id: string]: Subscription;
+    };
+    _errorCodesToMessagesMapping: BleErrorCodeMessageMapping;
+    /**
+     * First RestoreStateEvent payload (undefined = not yet received).
+     * @private
+     */
+    _restoredState: BleRestoredState | null | undefined;
+    /**
+     * Waiters for the first restore event when identifier is configured.
+     * @private
+     */
+    _restoreStateWaiters: Array<(value: BleRestoredState | null) => void>;
+    /**
+     * Per-device GATT serialization (4.0 Phase-2 / GAP-RN-Q).
+     * @private
+     */
+    _deviceQueue: DeviceOperationQueue;
+    /**
+     * When false, device ops are not serialized (tests / escape hatch).
+     * @private
+     */
+    _serializeDeviceOps: boolean;
+    /**
+     * Services-changed listeners (GAP-RN-SC).
+     * @private
+     */
+    _servicesResetListeners: Set<(deviceId: string) => void>;
+    static sharedInstance: BleManager | null;
+    /**
+     * Creates an instance of {@link BleManager}.
+     * It will return already created instance if it was created before.
+     * If you want to create a new instance to for example use different options, you have to call {@link #blemanagerdestroy|destroy()} on the previous one.
+     */
+    constructor(options?: BleManagerOptions);
+    /**
+     * Destroys all promises which are in progress.
+     * @private
+     */
+    _destroyPromises(): void;
+    /**
+     * Destroys all subscriptions.
+     * @private
+     */
+    _destroySubscriptions(): void;
+    /**
+     * Destroys {@link BleManager} instance. A new instance needs to be created to continue working with
+     * this library. All operations which were in progress completes with
+     * @returns {Promise<void>} Promise may return an error when the function cannot be called.
+     * {@link #bleerrorcodebluetoothmanagerdestroyed|BluetoothManagerDestroyed} error code.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Returns the first iOS state restoration payload captured after construction, or `null`
+     * when restoration is not configured, nothing was restored, or the manager was destroyed.
+     *
+     * Late callers receive the same value {@link BleManagerOptions.restoreStateFunction} received
+     * for the first RestoreStateEvent. Subsequent restore emits still invoke the callback but do
+     * not change the buffered value.
+     *
+     * When `restoreStateIdentifier` is set and the event has not arrived yet, the promise waits
+     * until the first event or {@link #blemanagerdestroy|destroy()}.
+     *
+     * @returns {Promise<BleRestoredState|null>}
+     */
+    getRestoredState(): Promise<BleRestoredState | null>;
+    /**
+     * Debug method to check if BLE restoration components are available.
+     * Useful for diagnosing issues with the Restoration subspec installation.
+     *
+     * @returns {Promise<{blePlxRestorationAdapterFound: boolean, bleRestorationRegistryFound: boolean, hasRegisterSelector: boolean, initializeWasCalled: boolean}>}
+     * Status object indicating which restoration components are available in the native binary.
+     */
+    checkRestorationStatus(): Promise<{
+        blePlxRestorationAdapterFound: boolean;
+        bleRestorationRegistryFound: boolean;
+        hasRegisterSelector: boolean;
+        initializeWasCalled: boolean;
+    }>;
+    /**
+     * Generates new unique identifier to be used internally.
+     *
+     * @returns {string} New identifier.
+     * @private
+     */
+    _nextUniqueID(): string;
+    /**
+     * Calls promise and checks if it completed successfully
+     *
+     * @param {Promise<T>} promise Promise to be called
+     * @returns {Promise<T>} Value of called promise.
+     * @private
+     */
+    _callPromise<T>(promise: Promise<T>): Promise<T>;
+    /**
+     * Run a device-scoped GATT op through the per-device queue (GAP-RN-Q).
+     * @private
+     */
+    _runForDevice<T>(deviceId: DeviceId, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Priority disconnect path: bump queue epoch so pending ops fail, then run `fn`
+     * after the current in-flight op settles (GAP-RN-Q cancel preemption).
+     * @private
+     */
+    _runCancelForDevice<T>(deviceId: DeviceId, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Expose the per-device queue for tests and advanced hosts (GAP-RN-Q).
+     */
+    getDeviceOperationQueue(): DeviceOperationQueue;
+    /**
+     * Subscribe to GATT services-changed / cache-reset signals for any device (GAP-RN-SC).
+     * Native: iOS `peripheral(_:didModifyServices:)`, Android API 31+ `onServiceChanged`.
+     * Software: {@link emitServicesReset}.
+     */
+    onServicesReset(listener: (deviceId: string) => void): Subscription;
+    /**
+     * Notify listeners that a device's GATT services may have changed (re-discover required).
+     * Host bridges and tests call this; apps normally only use {@link onServicesReset}.
+     */
+    emitServicesReset(deviceId: string): void;
+    /**
+     * Chunked long-write on the bytes path (GAP-RN-LW). Serialized per device.
+     * Uses direct native writes inside the queue to avoid re-entrant queue deadlock.
+     * Cooperative with {@link cancelDeviceConnection}: queue epoch abort between chunks.
+     *
+     * **Interim (F036 / GAP-GA-PERF):** each chunk is still Base64-encoded for the 3.x
+     * native bridge. A native TurboModule bytes path (ArrayBuffer/Uint8Array) is required
+     * before bytes hot-path latency matches PortBleManager; keep Base64 methods as the
+     * source-compat edge until that lands.
+     */
+    writeLongCharacteristicForDeviceFromBytes(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, value: Uint8Array, options?: LongWriteOptions & {
+        withResponse?: boolean;
+    }): Promise<LongWriteResult>;
+    /** @private */
+    _parseServicesChangedPayload(payload: unknown): string | null;
+    /**
+     * Sets new log level for native module's logging mechanism.
+     * @param {LogLevel} logLevel New log level to be set.
+     * @returns {Promise<LogLevel>} Current log level.
+     */
+    setLogLevel(logLevel: keyof typeof LogLevel): Promise<keyof typeof LogLevel | void>;
+    /**
+     * Get current log level for native module's logging mechanism.
+     * @returns {Promise<LogLevel>} Current log level.
+     */
+    logLevel(): Promise<keyof typeof LogLevel>;
+    /**
+     * Cancels pending transaction.
+     *
+     * Few operations such as monitoring characteristic's value changes can be cancelled by a user. Basically every API
+     * entry which accepts `transactionId` allows to call `cancelTransaction` function. When cancelled operation is a
+     * promise or a callback which registers errors, {@link #bleerror|BleError} with error code
+     * {@link #bleerrorcodeoperationcancelled|OperationCancelled} will be emitted in that case. Cancelling transaction
+     * which doesn't exist is ignored.
+     *
+     * @example
+     * const transactionId = 'monitor_battery';
+     *
+     * // Monitor battery notifications
+     * manager.monitorCharacteristicForDevice(
+     *   device.id, '180F', '2A19',
+     *   (error, characteristic) => {
+     *   // Handle battery level changes...
+     * }, transactionId);
+     *
+     * // Cancel after specified amount of time
+     * setTimeout(() => manager.cancelTransaction(transactionId), 2000);
+     *
+     * @param {TransactionId} transactionId Id of pending transactions.
+     * @returns {Promise<void>}
+     */
+    cancelTransaction(transactionId: TransactionId): Promise<void>;
+    /**
+     * Current, global {@link State} of a {@link BleManager}. All APIs are working only when active state
+     * is "PoweredOn".
+     *
+     * @returns {Promise<State>} Promise which emits current state of BleManager.
+     */
+    state(): Promise<keyof typeof State>;
+    /**
+     * Notifies about {@link State} changes of a {@link BleManager}.
+     *
+     * @example
+     * const subscription = this.manager.onStateChange((state) => {
+     *      if (state === 'PoweredOn') {
+     *          this.scanAndConnect();
+     *          subscription.remove();
+     *      }
+     *  }, true);
+     *
+     * @param {function(newState: State)} listener Callback which emits state changes of BLE Manager.
+     * Look at {@link State} for possible values.
+     * @param {boolean} [emitCurrentState=false] If true, current state will be emitted as well. Defaults to false.
+     *
+     * @returns {Subscription} Subscription on which `remove()` function can be called to unsubscribe.
+     */
+    onStateChange(listener: (newState: keyof typeof State) => void, emitCurrentState?: boolean): Subscription;
+    /**
+     * Starts device scanning. When previous scan is in progress it will be stopped before executing this command.
+     *
+     * @param {?Array<UUID>} UUIDs Array of strings containing {@link UUID}s of {@link Service}s which are registered in
+     * scanned {@link Device}. If `null` is passed, all available {@link Device}s will be scanned.
+     * @param {?ScanOptions} options Optional configuration for scanning operation.
+     * @param {function(error: ?BleError, scannedDevice: ?Device)} listener Function which will be called for every scanned
+     * @returns {Promise<void>} Promise may return an error when the function cannot be called.
+     * {@link Device} (devices may be scanned multiple times). It's first argument is potential {@link Error} which is set
+     * to non `null` value when scanning failed. You have to start scanning process again if that happens. Second argument
+     * is a scanned {@link Device}.
+     * @returns {Promise<void>} the promise may be rejected if the operation is impossible to perform.
+     */
+    startDeviceScan(UUIDs: Array<UUID> | null, options: ScanOptions | null, listener: (error: BleError | null, scannedDevice: Device | null) => void): Promise<void>;
+    /**
+     * Scan until a device matching `predicate` is found, then connect.
+     * Stops the scan before connecting. Times out with {@link BleErrorCode.DeviceNotFound}.
+     */
+    findAndConnect(predicate: (device: Device) => boolean, options?: FindAndConnectOptions): Promise<Device>;
+    /**
+     * Stops {@link Device} scan if in progress.
+     * @returns {Promise<void>} the promise may be rejected if the operation is impossible to perform.
+     */
+    stopDeviceScan(): Promise<void>;
+    /**
+     * Request a connection parameter update. This functions may update connection parameters on Android API level 21 or
+     * above.
+     *
+     * @param {DeviceId} deviceIdentifier Device identifier.
+     * @param {ConnectionPriority} connectionPriority: Connection priority.
+     * @param {?TransactionId} transactionId Transaction handle used to cancel operation.
+     * @returns {Promise<Device>} Connected device.
+     */
+    requestConnectionPriorityForDevice(deviceIdentifier: DeviceId, connectionPriority: ConnectionPriority, transactionId?: TransactionId): Promise<Device>;
+    /**
+     * Reads RSSI for connected device.
+     *
+     * @param {DeviceId} deviceIdentifier Device identifier.
+     * @param {?TransactionId} transactionId Transaction handle used to cancel operation
+     * @returns {Promise<Device>} Connected device with updated RSSI value.
+     */
+    readRSSIForDevice(deviceIdentifier: DeviceId, transactionId?: TransactionId): Promise<Device>;
+    /**
+     * Request new MTU value for this device. This function currently is not doing anything
+     * on iOS platform as MTU exchange is done automatically. Since Android 14,
+     * mtu management has been changed, more information can be found at the link:
+     * https://developer.android.com/about/versions/14/behavior-changes-all#mtu-set-to-517
+     * @param {DeviceId} deviceIdentifier Device identifier.
+     * @param {number} mtu New MTU to negotiate.
+     * @param {?TransactionId} transactionId Transaction handle used to cancel operation
+     * @returns {Promise<Device>} Device with updated MTU size. Default value is 23 (517 since Android 14)..
+     */
+    requestMTUForDevice(deviceIdentifier: DeviceId, mtu: number, transactionId?: TransactionId): Promise<Device>;
+    /**
+     * Returns a list of known devices by their identifiers.
+     * @param {Array<DeviceId>} deviceIdentifiers List of device identifiers.
+     * @returns {Promise<Array<Device>>} List of known devices by their identifiers.
+     */
+    devices(deviceIdentifiers: Array<DeviceId>): Promise<Array<Device>>;
+    /**
+     * Returns a list of the peripherals (containing any of the specified services) currently connected to the system
+     * which have discovered services. Returned devices **may not be connected** to your application. Make sure to check
+     * if that's the case with function {@link #blemanagerisdeviceconnected|isDeviceConnected}.
+     * @param {Array<UUID>} serviceUUIDs List of service UUIDs. Device must contain at least one of them to be listed.
+     * @returns {Promise<Array<Device>>} List of known devices with discovered services as stated in the parameter.
+     */
+    connectedDevices(serviceUUIDs: Array<UUID>): Promise<Array<Device>>;
+    /**
+     * Connects to {@link Device} with provided ID.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @param {?ConnectionOptions} options Platform specific options for connection establishment.
+     * @returns {Promise<Device>} Connected {@link Device} object if successful.
+     */
+    connectToDevice(deviceIdentifier: DeviceId, options?: ConnectionOptions): Promise<Device>;
+    /**
+     * Disconnects from {@link Device} if it's connected or cancels pending connection.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier to be closed.
+     * @returns {Promise<Device>} Returns closed {@link Device} when operation is successful.
+     */
+    cancelDeviceConnection(deviceIdentifier: DeviceId): Promise<Device>;
+    /**
+     * Monitors if {@link Device} was disconnected due to any errors or connection problems.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier to be monitored.
+     * @param {function(error: ?BleError, device: Device)} listener - callback returning error as a reason of disconnection
+     * if available and {@link Device} object. If an error is null, that means the connection was terminated by
+     * {@link #blemanagercanceldeviceconnection|bleManager.cancelDeviceConnection()} call.
+     * @returns {Subscription} Subscription on which `remove()` function can be called to unsubscribe.
+     */
+    onDeviceDisconnected(deviceIdentifier: DeviceId, listener: (error: BleError | null, device: Device) => void): Subscription;
+    /**
+     * Check connection state of a {@link Device}.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @returns {Promise<boolean>} Promise which emits `true` if device is connected, and `false` otherwise.
+     */
+    isDeviceConnected(deviceIdentifier: DeviceId): Promise<boolean>;
+    /**
+     * Discovers all {@link Service}s,  {@link Characteristic}s and {@link Descriptor}s for {@link Device}.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @param {?TransactionId} transactionId Transaction handle used to cancel operation
+     * @returns {Promise<Device>} Promise which emits {@link Device} object if all available services and
+     * characteristics have been discovered.
+     */
+    discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: DeviceId, transactionId?: TransactionId): Promise<Device>;
+    /**
+     * List of discovered {@link Service}s for {@link Device}.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @returns {Promise<Array<Service>>} Promise which emits array of {@link Service} objects which are discovered for a
+     * {@link Device}.
+     */
+    servicesForDevice(deviceIdentifier: DeviceId): Promise<Array<Service>>;
+    /**
+     * List of discovered {@link Characteristic}s for given {@link Device} and {@link Service}.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @param {UUID} serviceUUID {@link Service} UUID.
+     * @returns {Promise<Array<Characteristic>>} Promise which emits array of {@link Characteristic} objects which are
+     * discovered for a {@link Device} in specified {@link Service}.
+     */
+    characteristicsForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID): Promise<Array<Characteristic>>;
+    /**
+     * List of discovered {@link Characteristic}s for unique {@link Service}.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} serviceIdentifier {@link Service} ID.
+     * @returns {Promise<Array<Characteristic>>} Promise which emits array of {@link Characteristic} objects which are
+     * discovered in unique {@link Service}.
+     * @private
+     */
+    _characteristicsForService(deviceIdentifier: DeviceId, serviceIdentifier: Identifier): Promise<Array<Characteristic>>;
+    /**
+     * Common code for handling NativeCharacteristic fetches.
+     *
+     * @param {Promise<Array<NativeCharacteristic>>} characteristicsPromise Native characteristics.
+     * @returns {Promise<Array<Characteristic>>} Promise which emits array of {@link Characteristic} objects which are
+     * discovered in unique {@link Service}.
+     * @private
+     */
+    _handleCharacteristics(characteristicsPromise: Promise<Array<NativeCharacteristic>>): Promise<Array<Characteristic>>;
+    /**
+     * List of discovered {@link Descriptor}s for given {@link Device}, {@link Service} and {@link Characteristic}.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @param {UUID} serviceUUID {@link Service} UUID.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @returns {Promise<Array<Descriptor>>} Promise which emits array of {@link Descriptor} objects which are
+     * discovered for a {@link Device}, {@link Service} in specified {@link Characteristic}.
+     */
+    descriptorsForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID): Promise<Array<Descriptor>>;
+    /**
+     * List of discovered {@link Descriptor}s for given {@link Service} and {@link Characteristic}.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} serviceIdentifier {@link Service} identifier.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @returns {Promise<Array<Descriptor>>} Promise which emits array of {@link Descriptor} objects which are
+     * discovered for a {@link Service} in specified {@link Characteristic}.
+     * @private
+     */
+    _descriptorsForService(deviceIdentifier: DeviceId, serviceIdentifier: Identifier, characteristicUUID: UUID): Promise<Array<Descriptor>>;
+    /**
+     * List of discovered {@link Descriptor}s for given {@link Characteristic}.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} characteristicIdentifier {@link Characteristic} identifier.
+     * @returns {Promise<Array<Descriptor>>} Promise which emits array of {@link Descriptor} objects which are
+     * discovered in specified {@link Characteristic}.
+     * @private
+     */
+    _descriptorsForCharacteristic(deviceIdentifier: DeviceId, characteristicIdentifier: Identifier): Promise<Array<Descriptor>>;
+    /**
+     *  Common code for handling NativeDescriptor fetches.
+     * @param {Promise<Array<NativeDescriptor>>} descriptorsPromise Native descriptors.
+     * @returns {Promise<Array<Descriptor>>} Promise which emits array of {@link Descriptor} objects which are
+     * discovered in unique {@link Characteristic}.
+     * @private
+     */
+    _handleDescriptors(descriptorsPromise: Promise<Array<NativeDescriptor>>): Promise<Array<Descriptor>>;
+    /**
+     * Read {@link Characteristic} value.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @param {UUID} serviceUUID {@link Service} UUID.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified
+     * UUID paths. Latest value of {@link Characteristic} will be stored inside returned object.
+     */
+    readCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, transactionId?: TransactionId): Promise<Characteristic>;
+    /**
+     * Read {@link Characteristic} value.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} serviceIdentifier {@link Service} ID.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified
+     * UUID paths. Latest value of {@link Characteristic} will be stored inside returned object.
+     * @private
+     */
+    _readCharacteristicForService(deviceIdentifier: DeviceId, serviceIdentifier: Identifier, characteristicUUID: UUID, transactionId?: TransactionId): Promise<Characteristic>;
+    /**
+     * Read {@link Characteristic} value.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} characteristicIdentifier {@link Characteristic} ID.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified ID.
+     * Latest value of {@link Characteristic} will be stored inside returned object.
+     * @private
+     */
+    _readCharacteristic(deviceIdentifier: DeviceId, characteristicIdentifier: Identifier, transactionId?: TransactionId): Promise<Characteristic>;
+    /**
+     * Write {@link Characteristic} value with response.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @param {UUID} serviceUUID {@link Service} UUID.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @param {Base64} base64Value Value in Base64 format.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified
+     * UUID paths. Latest value of characteristic may not be stored inside returned object.
+     */
+    writeCharacteristicWithResponseForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, base64Value: Base64, transactionId?: TransactionId): Promise<Characteristic>;
+    /**
+     * Write {@link Characteristic} value with response.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} serviceIdentifier {@link Service} ID.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @param {Base64} base64Value Value in Base64 format.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified
+     * UUID paths. Latest value of characteristic may not be stored inside returned object.
+     * @private
+     */
+    _writeCharacteristicWithResponseForService(deviceIdentifier: DeviceId, serviceIdentifier: Identifier, characteristicUUID: UUID, base64Value: Base64, transactionId?: TransactionId): Promise<Characteristic>;
+    /**
+     * Write {@link Characteristic} value with response.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} characteristicIdentifier {@link Characteristic} ID.
+     * @param {Base64} base64Value Value in Base64 format.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified ID.
+     * Latest value of characteristic may not be stored inside returned object.
+     * @private
+     */
+    _writeCharacteristicWithResponse(deviceIdentifier: DeviceId, characteristicIdentifier: Identifier, base64Value: Base64, transactionId?: TransactionId): Promise<Characteristic>;
+    /**
+     * Write {@link Characteristic} value without response.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @param {UUID} serviceUUID {@link Service} UUID.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @param {Base64} base64Value Value in Base64 format.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified
+     * UUID paths. Latest value of characteristic may not be stored inside returned object.
+     */
+    writeCharacteristicWithoutResponseForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, base64Value: Base64, transactionId?: TransactionId): Promise<Characteristic>;
+    /**
+     * Write {@link Characteristic} value without response.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} serviceIdentifier {@link Service} ID.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @param {Base64} base64Value Value in Base64 format.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified
+     * UUID paths. Latest value of characteristic may not be stored inside returned object.
+     * @private
+     */
+    _writeCharacteristicWithoutResponseForService(deviceIdentifier: DeviceId, serviceIdentifier: Identifier, characteristicUUID: UUID, base64Value: Base64, transactionId?: TransactionId): Promise<Characteristic>;
+    /**
+     * Write {@link Characteristic} value without response.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} characteristicIdentifier {@link Characteristic} UUID.
+     * @param {Base64} base64Value Value in Base64 format.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified ID.
+     * Latest value of characteristic may not be stored inside returned object.
+     * @private
+     */
+    _writeCharacteristicWithoutResponse(deviceIdentifier: DeviceId, characteristicIdentifier: Identifier, base64Value: Base64, transactionId?: TransactionId): Promise<Characteristic>;
+    /**
+     * Monitor value changes of a {@link Characteristic}. If notifications are enabled they will be used
+     * in favour of indications.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @param {UUID} serviceUUID {@link Service} UUID.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @param {function(error: ?BleError, characteristic: ?Characteristic)} listener - callback which emits
+     * {@link Characteristic} objects with modified value for each notification.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Subscription} Subscription on which `remove()` function can be called to unsubscribe.
+     */
+    monitorCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, listener: (error: BleError | null, characteristic: Characteristic | null) => void, transactionId?: TransactionId, subscriptionType?: CharacteristicSubscriptionType | null): Subscription;
+    /**
+     * Monitor value changes of a {@link Characteristic}. If notifications are enabled they will be used
+     * in favour of indications.
+     *
+     * @param {Identifier} serviceIdentifier {@link Service} ID.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @param {function(error: ?BleError, characteristic: ?Characteristic)} listener - callback which emits
+     * {@link Characteristic} objects with modified value for each notification.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Subscription} Subscription on which `remove()` function can be called to unsubscribe.
+     * @private
+     */
+    _monitorCharacteristicForService(deviceIdentifier: DeviceId, serviceIdentifier: Identifier, characteristicUUID: UUID, listener: (error: BleError | null, characteristic: Characteristic | null) => void, transactionId?: TransactionId, subscriptionType?: CharacteristicSubscriptionType | null): Subscription;
+    /**
+     * Monitor value changes of a {@link Characteristic}. If notifications are enabled they will be used
+     * in favour of indications.
+     *
+     * @param {Identifier} characteristicIdentifier - {@link Characteristic} ID.
+     * @param {function(error: ?BleError, characteristic: ?Characteristic)} listener - callback which emits
+     * {@link Characteristic} objects with modified value for each notification.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * @param {?CharacteristicSubscriptionType} subscriptionType [android only] subscription type of the characteristic
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Subscription} Subscription on which `remove()` function can be called to unsubscribe.
+     * @private
+     */
+    _monitorCharacteristic(deviceIdentifier: DeviceId, characteristicIdentifier: Identifier, listener: (error: BleError | null, characteristic: Characteristic | null) => void, transactionId?: TransactionId, subscriptionType?: CharacteristicSubscriptionType | null): Subscription;
+    /**
+     * Common code to handle characteristic monitoring.
+     *
+     * @param {Promise<void>} monitorPromise Characteristic monitoring promise
+     * @param {TransactionId} transactionId TransactionId of passed promise
+     * @param {function(error: ?BleError, characteristic: ?Characteristic)} listener - callback which emits
+     * {@link Characteristic} objects with modified value for each notification.
+     * @returns {Subscription} Subscription on which `remove()` function can be called to unsubscribe.
+     * @private
+     */
+    _handleMonitorCharacteristic(monitorPromise: Promise<void>, transactionId: TransactionId, listener: (error: BleError | null, characteristic: Characteristic | null) => void): Subscription;
+    /**
+     * Read {@link Descriptor} value.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier.
+     * @param {UUID} serviceUUID {@link Service} UUID.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @param {UUID} descriptorUUID {@link Descriptor} UUID.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Descriptor>} Promise which emits first {@link Descriptor} object matching specified
+     * UUID paths. Latest value of {@link Descriptor} will be stored inside returned object.
+     */
+    readDescriptorForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<Descriptor>;
+    /**
+     * Read {@link Descriptor} value.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} serviceIdentifier {@link Service} identifier.
+     * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+     * @param {UUID} descriptorUUID {@link Descriptor} UUID.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Descriptor>} Promise which emits first {@link Descriptor} object matching specified
+     * UUID paths. Latest value of {@link Descriptor} will be stored inside returned object.
+     * @private
+     */
+    _readDescriptorForService(deviceIdentifier: DeviceId, serviceIdentifier: Identifier, characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<Descriptor>;
+    /**
+     * Read {@link Descriptor} value.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} characteristicIdentifier {@link Characteristic} identifier.
+     * @param {UUID} descriptorUUID {@link Descriptor} UUID.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Descriptor>} Promise which emits first {@link Descriptor} object matching specified
+     * UUID paths. Latest value of {@link Descriptor} will be stored inside returned object.
+     * @private
+     */
+    _readDescriptorForCharacteristic(deviceIdentifier: DeviceId, characteristicIdentifier: Identifier, descriptorUUID: UUID, transactionId?: TransactionId): Promise<Descriptor>;
+    /**
+     * Read {@link Descriptor} value.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} descriptorIdentifier {@link Descriptor} identifier.
+     * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+     * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+     * @returns {Promise<Descriptor>} Promise which emits first {@link Descriptor} object matching specified
+     * UUID paths. Latest value of {@link Descriptor} will be stored inside returned object.
+     * @private
+     */
+    _readDescriptor(deviceIdentifier: DeviceId, descriptorIdentifier: Identifier, transactionId?: TransactionId): Promise<Descriptor>;
+    /**
+     * Write {@link Descriptor} value.
+     *
+     * @param {DeviceId} deviceIdentifier Connected device identifier
+     * @param {UUID} serviceUUID Service UUID
+     * @param {UUID} characteristicUUID Characteristic UUID
+     * @param {UUID} descriptorUUID Descriptor UUID
+     * @param {Base64} valueBase64 Value to be set coded in Base64
+     * @param {?TransactionId} transactionId Transaction handle used to cancel operation
+     * @returns {Promise<Descriptor>} Descriptor which saved passed value
+     */
+    writeDescriptorForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<Descriptor>;
+    /**
+     * Write {@link Descriptor} value.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} serviceIdentifier Service identifier
+     * @param {UUID} characteristicUUID Characteristic UUID
+     * @param {UUID} descriptorUUID Descriptor UUID
+     * @param {Base64} valueBase64 Value to be set coded in Base64
+     * @param {?TransactionId} transactionId Transaction handle used to cancel operation
+     * @returns {Promise<Descriptor>} Descriptor which saved passed value
+     * @private
+     */
+    _writeDescriptorForService(deviceIdentifier: DeviceId, serviceIdentifier: Identifier, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<Descriptor>;
+    /**
+     * Write {@link Descriptor} value.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} characteristicIdentifier Characteristic identifier
+     * @param {UUID} descriptorUUID Descriptor UUID
+     * @param {Base64} valueBase64 Value to be set coded in Base64
+     * @param {?TransactionId} transactionId Transaction handle used to cancel operation
+     * @returns {Promise<Descriptor>} Descriptor which saved passed value
+     * @private
+     */
+    _writeDescriptorForCharacteristic(deviceIdentifier: DeviceId, characteristicIdentifier: Identifier, descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<Descriptor>;
+    /**
+     * Write {@link Descriptor} value.
+     *
+     * @param {DeviceId} deviceIdentifier {@link Device} identifier (queue key).
+     * @param {Identifier} descriptorIdentifier Descriptor identifier
+     * @param {Base64} valueBase64 Value to be set coded in Base64
+     * @param {?TransactionId} transactionId Transaction handle used to cancel operation
+     * @returns {Promise<Descriptor>} Descriptor which saved passed value
+     * @private
+     */
+    _writeDescriptor(deviceIdentifier: DeviceId, descriptorIdentifier: Identifier, valueBase64: Base64, transactionId?: TransactionId): Promise<Descriptor>;
+    /**
+     * Enable background mode using Android foreground service. [Android only]
+     *
+     * This starts a foreground service that keeps BLE operations alive when the app
+     * is in the background. A persistent notification will be shown to the user.
+     *
+     * On iOS, background mode is handled through UIBackgroundModes in Info.plist
+     * and state restoration, so this method is a no-op on iOS.
+     *
+     * @example
+     * // Enable background mode with custom notification
+     * await manager.enableBackgroundMode({
+     *   notificationTitle: 'Connected to Heart Rate Monitor',
+     *   notificationText: 'Syncing health data...'
+     * });
+     *
+     * @param {BackgroundModeOptions} options Configuration for the foreground service notification.
+     * @returns {Promise<boolean>} True if background mode was enabled successfully.
+     */
+    enableBackgroundMode(options?: BackgroundModeOptions): Promise<boolean>;
+    /**
+     * Disable background mode and stop the foreground service. [Android only]
+     *
+     * This stops the foreground service and removes the persistent notification.
+     * BLE operations may be terminated by the system when the app goes to background.
+     *
+     * @example
+     * // Disable background mode when done with BLE operations
+     * await manager.disableBackgroundMode();
+     *
+     * @returns {Promise<boolean>} True if background mode was disabled successfully.
+     */
+    disableBackgroundMode(): Promise<boolean>;
+    /**
+     * Update the foreground service notification content. [Android only]
+     *
+     * Use this to update the notification while background mode is active,
+     * for example to show connection status or sync progress.
+     *
+     * @example
+     * // Update notification to show progress
+     * await manager.updateBackgroundNotification({
+     *   notificationTitle: 'Syncing Data',
+     *   notificationText: 'Progress: 75%'
+     * });
+     *
+     * @param {BackgroundModeOptions} options New notification content.
+     * @returns {Promise<boolean>} True if notification was updated successfully.
+     */
+    updateBackgroundNotification(options: BackgroundModeOptions): Promise<boolean>;
+    /**
+     * Check if background mode is currently enabled. [Android only]
+     *
+     * @example
+     * const isEnabled = await manager.isBackgroundModeEnabled();
+     * if (!isEnabled) {
+     *   await manager.enableBackgroundMode();
+     * }
+     *
+     * @returns {Promise<boolean>} True if background mode (foreground service) is running.
+     */
+    isBackgroundModeEnabled(): Promise<boolean>;
+    /**
+     * Honest capability query for the React Native host.
+     * Web/Electron use their own manager.supports() with host-specific matrix.
+     *
+     * OS-gated caps are filtered even though the host matrix marks the RN host as
+     * capable — so callers that branch on supports() do not hit OperationNotSupported
+     * (F025/F095/R2-F027):
+     * - Android-only: bonding, connectionPriority, requestMtu, androidForegroundService
+     * - iOS-only: iosStateRestoration
+     */
+    supports(capability: BleCapability): boolean;
+    /**
+     * Check Android/iOS BLE runtime permissions (no prompt).
+     * Pass `{ neverForLocation: true }` only when the Expo plugin sets neverForLocation.
+     */
+    checkBluetoothPermissions(options?: BluetoothPermissionOptions): Promise<PermissionCheckResult>;
+    /**
+     * Request Android BLE runtime permissions (iOS no-op grant).
+     * Default requests ACCESS_FINE_LOCATION on API 31+ (plugin neverForLocation default false).
+     */
+    requestBluetoothPermissions(options?: BluetoothPermissionOptions): Promise<PermissionCheckResult>;
+    /**
+     * Create a bond (pair) with a device. **Android only.**
+     * iOS pairing is OS-driven when accessing protected characteristics.
+     */
+    createBond(deviceIdentifier: DeviceId): Promise<void>;
+    /**
+     * Remove bond for a device. **Android only** (uses removeBond where available).
+     */
+    removeBond(deviceIdentifier: DeviceId): Promise<void>;
+    /**
+     * Read bond state for a device. **Android only.**
+     */
+    getBondState(deviceIdentifier: DeviceId): Promise<BondState>;
+    /**
+     * List devices currently bonded (paired) with the OS Bluetooth adapter.
+     * **Android only.** iOS has no public bonded list API; Web/Electron return unsupported
+     * unless a Port implements `listBondedDevices` (see {@link PortBleManager#bondedDevices}).
+     */
+    bondedDevices(): Promise<Array<Device>>;
+    /**
+     * Read characteristic value as {@link Uint8Array} (parallel to
+     * {@link #blemanagerreadcharacteristicfordevice|readCharacteristicForDevice}).
+     *
+     * Interim: decodes Base64 from the native bridge (see class bytes-path note).
+     */
+    readCharacteristicForDeviceAsBytes(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, transactionId?: TransactionId): Promise<CharacteristicAsBytes>;
+    /**
+     * Write characteristic with response from {@link Uint8Array} (parallel to
+     * {@link #blemanagerwritecharacteristicwithresponsefordevice|writeCharacteristicWithResponseForDevice}).
+     */
+    writeCharacteristicWithResponseForDeviceFromBytes(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, value: Uint8Array, transactionId?: TransactionId): Promise<CharacteristicAsBytes>;
+    /**
+     * Write characteristic without response from {@link Uint8Array}.
+     */
+    writeCharacteristicWithoutResponseForDeviceFromBytes(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, value: Uint8Array, transactionId?: TransactionId): Promise<CharacteristicAsBytes>;
+    /**
+     * Monitor characteristic as {@link Uint8Array} (parallel to
+     * {@link #blemanagermonitorcharacteristicfordevice|monitorCharacteristicForDevice}).
+     */
+    monitorCharacteristicForDeviceAsBytes(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, listener: (error: BleError | null, characteristic: CharacteristicAsBytes | null) => void, transactionId?: TransactionId, subscriptionType?: CharacteristicSubscriptionType | null): Subscription;
+    /** @private */
+    _characteristicAsBytes(characteristic: Characteristic, prefer?: Uint8Array): CharacteristicAsBytes;
+    /**
+     * Read descriptor value as {@link Uint8Array} (parallel to
+     * {@link #blemanagerreaddescriptorfordevice|readDescriptorForDevice}).
+     */
+    readDescriptorForDeviceAsBytes(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<DescriptorAsBytes>;
+    /**
+     * Write descriptor from {@link Uint8Array} (parallel to
+     * {@link #blemanagerwritedescriptorfordevice|writeDescriptorForDevice}).
+     */
+    writeDescriptorForDeviceFromBytes(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, value: Uint8Array, transactionId?: TransactionId): Promise<DescriptorAsBytes>;
+    /** @private */
+    _descriptorAsBytes(descriptor: Descriptor, prefer?: Uint8Array): DescriptorAsBytes;
+}
+//# sourceMappingURL=BleManager.d.ts.map