@sfourdrinier/react-native-ble-plx/lib/typescript/src/BleManager.d.ts

React Native Bluetooth Low Energy library

import { Device } from './Device';
import { Service } from './Service';
import { Characteristic } from './Characteristic';
import { Descriptor } from './Descriptor';
import { State, LogLevel, ConnectionPriority } from './TypeDefinition';
import { BleError } from './BleError';
import type { NativeCharacteristic, NativeDescriptor } from './BleModule';
import type { BleErrorCodeMessageMapping, Subscription, DeviceId, Identifier, UUID, TransactionId, CharacteristicSubscriptionType, Base64, ScanOptions, ConnectionOptions, BleManagerOptions, BackgroundModeOptions } from './TypeDefinition';
/**
 *
 * 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
 * `restoreStateFunction` in {@link BleManagerOptions}.
 *
 * @example
 * const manager = new BleManager();
 * // ... work with BLE manager ...
 * manager.destroy();
 */
export declare class BleManager {
    _scanEventSubscription: any | null;
    _eventEmitter: any;
    _uniqueId: number;
    _activePromises: {
        [id: string]: (error: BleError) => void;
    };
    _activeSubscriptions: {
        [id: string]: Subscription;
    };
    _errorCodesToMessagesMapping: BleErrorCodeMessageMapping;
    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>;
    /**
     * 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>;
    /**
     * 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>;
    /**
     * 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 {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(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 {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(serviceIdentifier: Identifier, characteristicUUID: UUID): Promise<Array<Descriptor>>;
    /**
     * List of discovered {@link Descriptor}s for given {@link Characteristic}.
     *
     * @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(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 {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(serviceIdentifier: Identifier, characteristicUUID: UUID, transactionId?: TransactionId): Promise<Characteristic>;
    /**
     * Read {@link Characteristic} value.
     *
     * @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(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 {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(serviceIdentifier: Identifier, characteristicUUID: UUID, base64Value: Base64, transactionId?: TransactionId): Promise<Characteristic>;
    /**
     * Write {@link Characteristic} value with response.
     *
     * @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(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 {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(serviceIdentifier: Identifier, characteristicUUID: UUID, base64Value: Base64, transactionId?: TransactionId): Promise<Characteristic>;
    /**
     * Write {@link Characteristic} value without response.
     *
     * @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(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(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(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 {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(serviceIdentifier: Identifier, characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<Descriptor>;
    /**
     * Read {@link Descriptor} value.
     *
     * @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(characteristicIdentifier: Identifier, descriptorUUID: UUID, transactionId?: TransactionId): Promise<Descriptor>;
    /**
     * Read {@link Descriptor} value.
     *
     * @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(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 {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(serviceIdentifier: Identifier, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<Descriptor>;
    /**
     * Write {@link Descriptor} value.
     *
     * @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(characteristicIdentifier: Identifier, descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<Descriptor>;
    /**
     * Write {@link Descriptor} value.
     *
     * @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(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>;
}
//# sourceMappingURL=BleManager.d.ts.map