react-native-ble-manager 8.8.0 → 9.1.0

package/dist/cjs/types.d.ts

@@ -0,0 +1,311 @@
+/**
+ * android states: https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#EXTRA_STATE
+ * ios states: https://developer.apple.com/documentation/corebluetooth/cbcentralmanagerstate
+ * */
+export declare enum BleState {
+    /**
+     * [iOS only]
+     */
+    Unknown = "unknown",
+    /**
+     * [iOS only]
+     */
+    Resetting = "resetting",
+    Unsupported = "unsupported",
+    /**
+     * [iOS only]
+     */
+    Unauthorized = "unauthorized",
+    On = "on",
+    Off = "off",
+    /**
+     * [android only]
+     */
+    TurningOn = "turning_on",
+    /**
+     * [android only]
+     */
+    TurningOff = "turning_off"
+}
+export interface Peripheral {
+    id: string;
+    rssi: number;
+    name?: string;
+    advertising: AdvertisingData;
+}
+export interface AdvertisingData {
+    isConnectable?: boolean;
+    localName?: string;
+    manufacturerData?: CustomAdvertisingData;
+    serviceData?: CustomAdvertisingData;
+    serviceUUIDs?: string[];
+    txPowerLevel?: number;
+}
+export interface CustomAdvertisingData {
+    CDVType: 'ArrayBuffer';
+    /**
+     * data as an array of numbers (which can be converted back to a Uint8Array (ByteArray),
+     * using something like [Buffer.from()](https://github.com/feross/buffer))
+     */
+    bytes: number[];
+    /**
+     * base64-encoded string of the data
+     */
+    data: string;
+}
+export interface StartOptions {
+    /**
+     * [iOS only]
+     */
+    showAlert?: boolean;
+    /**
+     * [iOS only]
+     */
+    restoreIdentifierKey?: string;
+    /**
+     * [iOS only]
+     */
+    queueIdentifierKey?: string;
+    /**
+     * [android only]
+     */
+    forceLegacy?: boolean;
+}
+/**
+ * [android only]
+ * https://developer.android.com/reference/android/bluetooth/le/ScanSettings
+ */
+export interface ScanOptions {
+    /**
+     * This will only works if a ScanFilter is active. Otherwise, may not retrieve any result.
+     * See https://developer.android.com/reference/android/bluetooth/le/ScanSettings#MATCH_NUM_FEW_ADVERTISEMENT.
+     * */
+    numberOfMatches?: BleScanMatchCount;
+    matchMode?: BleScanMatchMode;
+    /**
+     * This will only works if a ScanFilter is active. Otherwise, may not retrieve any result.
+     * See https://developer.android.com/reference/android/bluetooth/le/ScanSettings#CALLBACK_TYPE_FIRST_MATCH.
+     * Also read [this issue](https://github.com/dariuszseweryn/RxAndroidBle/issues/561#issuecomment-532295346) for a deeper understanding
+     * of the very brittle stability of ScanSettings on android.
+     * */
+    callbackType?: BleScanCallbackType;
+    scanMode?: BleScanMode;
+    /**
+     * This is supposed to push results after a certain delay.
+     * In practice it is tricky, use with caution.
+     * Do not set something below 5000ms as it will wait that long anyway before pushing the first results,
+     * or on some phones it will ignore that setting and behave just like it was set to 0.
+     * Set your minimum scan duration accordingly, otherwise you will not retrieve the batched results.
+     * https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder#setReportDelay(long)
+     */
+    reportDelay?: number;
+    /**
+     * Does not work in conjunction with legacy scans. Setting an unsupported PHY will result in a failure to scan,
+     * use with caution.
+     * https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder#setPhy(int)
+     */
+    phy?: BleScanPhyMode;
+    /**
+     * true by default for compatibility with older apps.
+     * In that mode, scan will only retrieve advertisements data as specified by BLE 4.2 and below.
+     * Change this if you want to benefit from the extended BLE 5 advertisement spec.
+     * https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder#setLegacy(boolean)
+     */
+    legacy?: boolean;
+    /**
+     * an android ScanFilter, used if present to restrict scan results to devices with a specific advertising name.
+     * This is a whole word match, not a partial search.
+     * Use with caution, it's behavior is tricky and seems to be the following:
+     * if `callbackType` is set to `AllMatches`, only the completeLocalName will be used for filtering.
+     * if `callbackType` is set to `FirstMatch`, the shortenedLocalName will be used for filtering.
+     * https://developer.android.com/reference/android/bluetooth/le/ScanFilter.Builder#setDeviceName(java.lang.String)
+     */
+    exactAdvertisingName?: string;
+}
+/**
+ * [android only]
+ */
+export declare enum BleScanMode {
+    Opportunistic = -1,
+    LowPower = 0,
+    Balanced = 1,
+    LowLatency = 2
+}
+/**
+ * [android only]
+ */
+export declare enum BleScanMatchMode {
+    Aggressive = 1,
+    Sticky = 2
+}
+/**
+ * [android only]
+ */
+export declare enum BleScanCallbackType {
+    AllMatches = 1,
+    FirstMatch = 2,
+    MatchLost = 4
+}
+/**
+ * [android only]
+ */
+export declare enum BleScanMatchCount {
+    OneAdvertisement = 1,
+    FewAdvertisements = 2,
+    MaxAdvertisements = 3
+}
+/**
+ * [android only]
+ */
+export declare enum BleScanPhyMode {
+    LE_1M = 1,
+    LE_2M = 2,
+    LE_CODED = 3,
+    ALL_SUPPORTED = 255
+}
+/**
+ * [android only API 21+]
+ */
+export declare enum ConnectionPriority {
+    balanced = 0,
+    high = 1,
+    low = 2
+}
+export interface Service {
+    uuid: string;
+}
+export interface Descriptor {
+    value: string;
+    uuid: string;
+}
+export interface Characteristic {
+    /**
+     * See https://developer.apple.com/documentation/corebluetooth/cbcharacteristicproperties
+     */
+    properties: {
+        Broadcast?: "Broadcast";
+        Read?: "Read";
+        WriteWithoutResponse?: "WriteWithoutResponse";
+        Write?: "Write";
+        Notify?: "Notify";
+        Indicate?: "Indicate";
+        AuthenticatedSignedWrites?: "AuthenticatedSignedWrites";
+        ExtendedProperties?: "ExtendedProperties";
+        NotifyEncryptionRequired?: "NotifyEncryptionRequired";
+        IndicateEncryptionRequired?: "IndicateEncryptionRequired";
+    };
+    characteristic: string;
+    service: string;
+    descriptors?: Descriptor[];
+}
+export interface PeripheralInfo extends Peripheral {
+    serviceUUIDs?: string[];
+    characteristics?: Characteristic[];
+    services?: Service[];
+}
+export declare enum BleEventType {
+    BleManagerDidUpdateState = "BleManagerDidUpdateState",
+    BleManagerStopScan = "BleManagerStopScan",
+    BleManagerDiscoverPeripheral = "BleManagerDiscoverPeripheral",
+    BleManagerDidUpdateValueForCharacteristic = "BleManagerDidUpdateValueForCharacteristic",
+    BleManagerConnectPeripheral = "BleManagerConnectPeripheral",
+    BleManagerDisconnectPeripheral = "BleManagerDisconnectPeripheral",
+    /**
+     * [Android only]
+     */
+    BleManagerPeripheralDidBond = "BleManagerPeripheralDidBond",
+    /**
+     * [iOS only]
+     */
+    BleManagerCentralManagerWillRestoreState = "BleManagerCentralManagerWillRestoreState",
+    /**
+     * [iOS only]
+     */
+    BleManagerDidUpdateNotificationStateFor = "BleManagerDidUpdateNotificationStateFor"
+}
+export interface BleStopScanEvent {
+    /**
+     * [iOS only]
+     */
+    status?: number;
+}
+export interface BleManagerDidUpdateStateEvent {
+    state: BleState;
+}
+export interface BleConnectPeripheralEvent {
+    /**
+     * peripheral id
+     */
+    readonly peripheral: string;
+    /**
+     * [android only]
+     */
+    readonly status?: number;
+}
+export type BleDiscoverPeripheralEvent = Peripheral;
+/**
+ * [Android only]
+ */
+export type BleBondedPeripheralEvent = Peripheral;
+export interface BleDisconnectPeripheralEvent {
+    /**
+     * peripheral id
+     */
+    readonly peripheral: string;
+    /**
+     * [android only] disconnect reason.
+     */
+    readonly status?: number;
+    /**
+     * [iOS only] disconnect error domain.
+     */
+    readonly domain?: string;
+    /**
+     * [iOS only] disconnect error code.
+     */
+    readonly code?: number;
+}
+export interface BleManagerDidUpdateValueForCharacteristicEvent {
+    /**
+     * characteristic UUID
+     */
+    readonly characteristic: string;
+    /**
+     * peripheral id
+     */
+    readonly peripheral: string;
+    /**
+     * service UUID
+     */
+    readonly service: string;
+    /**
+     * data as an array of numbers (which can be converted back to a Uint8Array (ByteArray),
+     * using something like [Buffer.from()](https://github.com/feross/buffer))
+     */
+    readonly value: number[];
+}
+/**
+ * [iOS only]
+ */
+export interface BleManagerDidUpdateNotificationStateForEvent {
+    /**
+     * peripheral id
+     */
+    readonly peripheral: string;
+    /**
+     * characteristic UUID
+     */
+    readonly characteristic: string;
+    /**
+     * is the characteristic notifying or not
+     */
+    readonly isNotifying: boolean;
+    /**
+     * error domain
+     */
+    readonly domain: string;
+    /**
+     * error code
+     */
+    readonly code: number;
+}

package/dist/cjs/types.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleEventType = exports.ConnectionPriority = exports.BleScanPhyMode = exports.BleScanMatchCount = exports.BleScanCallbackType = exports.BleScanMatchMode = exports.BleScanMode = exports.BleState = void 0;
+/**
+ * android states: https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#EXTRA_STATE
+ * ios states: https://developer.apple.com/documentation/corebluetooth/cbcentralmanagerstate
+ * */
+var BleState;
+(function (BleState) {
+    /**
+     * [iOS only]
+     */
+    BleState["Unknown"] = "unknown";
+    /**
+     * [iOS only]
+     */
+    BleState["Resetting"] = "resetting";
+    BleState["Unsupported"] = "unsupported";
+    /**
+     * [iOS only]
+     */
+    BleState["Unauthorized"] = "unauthorized";
+    BleState["On"] = "on";
+    BleState["Off"] = "off";
+    /**
+     * [android only]
+     */
+    BleState["TurningOn"] = "turning_on";
+    /**
+     * [android only]
+     */
+    BleState["TurningOff"] = "turning_off";
+})(BleState = exports.BleState || (exports.BleState = {}));
+/**
+ * [android only]
+ */
+var BleScanMode;
+(function (BleScanMode) {
+    BleScanMode[BleScanMode["Opportunistic"] = -1] = "Opportunistic";
+    BleScanMode[BleScanMode["LowPower"] = 0] = "LowPower";
+    BleScanMode[BleScanMode["Balanced"] = 1] = "Balanced";
+    BleScanMode[BleScanMode["LowLatency"] = 2] = "LowLatency";
+})(BleScanMode = exports.BleScanMode || (exports.BleScanMode = {}));
+/**
+ * [android only]
+ */
+var BleScanMatchMode;
+(function (BleScanMatchMode) {
+    BleScanMatchMode[BleScanMatchMode["Aggressive"] = 1] = "Aggressive";
+    BleScanMatchMode[BleScanMatchMode["Sticky"] = 2] = "Sticky";
+})(BleScanMatchMode = exports.BleScanMatchMode || (exports.BleScanMatchMode = {}));
+/**
+ * [android only]
+ */
+var BleScanCallbackType;
+(function (BleScanCallbackType) {
+    BleScanCallbackType[BleScanCallbackType["AllMatches"] = 1] = "AllMatches";
+    BleScanCallbackType[BleScanCallbackType["FirstMatch"] = 2] = "FirstMatch";
+    BleScanCallbackType[BleScanCallbackType["MatchLost"] = 4] = "MatchLost";
+})(BleScanCallbackType = exports.BleScanCallbackType || (exports.BleScanCallbackType = {}));
+/**
+ * [android only]
+ */
+var BleScanMatchCount;
+(function (BleScanMatchCount) {
+    BleScanMatchCount[BleScanMatchCount["OneAdvertisement"] = 1] = "OneAdvertisement";
+    BleScanMatchCount[BleScanMatchCount["FewAdvertisements"] = 2] = "FewAdvertisements";
+    BleScanMatchCount[BleScanMatchCount["MaxAdvertisements"] = 3] = "MaxAdvertisements";
+})(BleScanMatchCount = exports.BleScanMatchCount || (exports.BleScanMatchCount = {}));
+/**
+ * [android only]
+ */
+var BleScanPhyMode;
+(function (BleScanPhyMode) {
+    BleScanPhyMode[BleScanPhyMode["LE_1M"] = 1] = "LE_1M";
+    BleScanPhyMode[BleScanPhyMode["LE_2M"] = 2] = "LE_2M";
+    BleScanPhyMode[BleScanPhyMode["LE_CODED"] = 3] = "LE_CODED";
+    BleScanPhyMode[BleScanPhyMode["ALL_SUPPORTED"] = 255] = "ALL_SUPPORTED";
+})(BleScanPhyMode = exports.BleScanPhyMode || (exports.BleScanPhyMode = {}));
+/**
+ * [android only API 21+]
+ */
+var ConnectionPriority;
+(function (ConnectionPriority) {
+    ConnectionPriority[ConnectionPriority["balanced"] = 0] = "balanced";
+    ConnectionPriority[ConnectionPriority["high"] = 1] = "high";
+    ConnectionPriority[ConnectionPriority["low"] = 2] = "low";
+})(ConnectionPriority = exports.ConnectionPriority || (exports.ConnectionPriority = {}));
+var BleEventType;
+(function (BleEventType) {
+    BleEventType["BleManagerDidUpdateState"] = "BleManagerDidUpdateState";
+    BleEventType["BleManagerStopScan"] = "BleManagerStopScan";
+    BleEventType["BleManagerDiscoverPeripheral"] = "BleManagerDiscoverPeripheral";
+    BleEventType["BleManagerDidUpdateValueForCharacteristic"] = "BleManagerDidUpdateValueForCharacteristic";
+    BleEventType["BleManagerConnectPeripheral"] = "BleManagerConnectPeripheral";
+    BleEventType["BleManagerDisconnectPeripheral"] = "BleManagerDisconnectPeripheral";
+    /**
+     * [Android only]
+     */
+    BleEventType["BleManagerPeripheralDidBond"] = "BleManagerPeripheralDidBond";
+    /**
+     * [iOS only]
+     */
+    BleEventType["BleManagerCentralManagerWillRestoreState"] = "BleManagerCentralManagerWillRestoreState";
+    /**
+     * [iOS only]
+     */
+    BleEventType["BleManagerDidUpdateNotificationStateFor"] = "BleManagerDidUpdateNotificationStateFor";
+})(BleEventType = exports.BleEventType || (exports.BleEventType = {}));
+//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";;;AAAA;;;KAGK;AACL,IAAY,QAwBX;AAxBD,WAAY,QAAQ;IAClB;;OAEG;IACH,+BAAmB,CAAA;IACnB;;OAEG;IACH,mCAAuB,CAAA;IACvB,uCAA2B,CAAA;IAC3B;;OAEG;IACH,yCAA6B,CAAA;IAC7B,qBAAS,CAAA;IACT,uBAAW,CAAA;IACX;;OAEG;IACH,oCAAwB,CAAA;IACxB;;OAEG;IACH,sCAA0B,CAAA;AAC5B,CAAC,EAxBW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAwBnB;AAsGD;;GAEG;AACH,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,gEAAkB,CAAA;IAClB,qDAAY,CAAA;IACZ,qDAAY,CAAA;IACZ,yDAAc,CAAA;AAChB,CAAC,EALW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAKtB;AAED;;GAEG;AACH,IAAY,gBAGX;AAHD,WAAY,gBAAgB;IAC1B,mEAAc,CAAA;IACd,2DAAU,CAAA;AACZ,CAAC,EAHW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAG3B;AAED;;GAEG;AACH,IAAY,mBAIX;AAJD,WAAY,mBAAmB;IAC7B,yEAAc,CAAA;IACd,yEAAc,CAAA;IACd,uEAAa,CAAA;AACf,CAAC,EAJW,mBAAmB,GAAnB,2BAAmB,KAAnB,2BAAmB,QAI9B;AAED;;GAEG;AACH,IAAY,iBAIX;AAJD,WAAY,iBAAiB;IAC3B,iFAAoB,CAAA;IACpB,mFAAqB,CAAA;IACrB,mFAAqB,CAAA;AACvB,CAAC,EAJW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAI5B;AAED;;GAEG;AACH,IAAY,cAKX;AALD,WAAY,cAAc;IACxB,qDAAS,CAAA;IACT,qDAAS,CAAA;IACT,2DAAY,CAAA;IACZ,uEAAmB,CAAA;AACrB,CAAC,EALW,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAKzB;AAED;;GAEG;AACH,IAAY,kBAIX;AAJD,WAAY,kBAAkB;IAC5B,mEAAY,CAAA;IACZ,2DAAQ,CAAA;IACR,yDAAO,CAAA;AACT,CAAC,EAJW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAI7B;AAuCD,IAAY,YAmBX;AAnBD,WAAY,YAAY;IACtB,qEAAqD,CAAA;IACrD,yDAAyC,CAAA;IACzC,6EAA6D,CAAA;IAC7D,uGAAuF,CAAA;IACvF,2EAA2D,CAAA;IAC3D,iFAAiE,CAAA;IACjE;;OAEG;IACH,2EAA2D,CAAA;IAC3D;;OAEG;IACH,qGAAqF,CAAA;IACrF;;OAEG;IACH,mGAAmF,CAAA;AACrF,CAAC,EAnBW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAmBvB"}

package/dist/esm/index.d.ts

@@ -0,0 +1,156 @@
+import { BleState, ConnectionPriority, Peripheral, PeripheralInfo, ScanOptions, StartOptions } from './types';
+export * from './types';
+declare class BleManager {
+    constructor();
+    /**
+     *
+     * @param peripheralId
+     * @param serviceUUID
+     * @param characteristicUUID
+     * @returns data as an array of numbers (which can be converted back to a Uint8Array (ByteArray) using something like [Buffer.from()](https://github.com/feross/buffer))
+     */
+    read(peripheralId: string, serviceUUID: string, characteristicUUID: string): Promise<number[]>;
+    /**
+     *
+     * @param peripheralId
+     * @param serviceUUID
+     * @param characteristicUUID
+     * @param descriptorUUID
+     * @returns data as an array of numbers (which can be converted back to a Uint8Array (ByteArray) using something like [Buffer.from()](https://github.com/feross/buffer))
+     */
+    readDescriptor(peripheralId: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string): Promise<number[]>;
+    /**
+     *
+     * @param peripheralId
+     * @returns a promise resolving with the updated RSSI (`number`) if it succeeds.
+     */
+    readRSSI(peripheralId: string): Promise<number>;
+    /**
+     * [Android only]
+     * @param peripheralId
+     * @returns a promise that resolves to a boolean indicating if gatt was successfully refreshed or not.
+     */
+    refreshCache(peripheralId: string): Promise<boolean>;
+    /**
+     *
+     * @param peripheralId
+     * @param serviceUUIDs [iOS only] optional filter of services to retrieve.
+     * @returns
+     */
+    retrieveServices(peripheralId: string, serviceUUIDs?: string[]): Promise<PeripheralInfo>;
+    /**
+     *
+     * @param peripheralId
+     * @param serviceUUID
+     * @param characteristicUUID
+     * @param data data to write as an array of numbers (which can be converted from a Uint8Array (ByteArray) using something like [Buffer.toJSON().data](https://github.com/feross/buffer))
+     * @param maxByteSize optional, defaults to 20
+     * @returns
+     */
+    write(peripheralId: string, serviceUUID: string, characteristicUUID: string, data: number[], maxByteSize?: number): Promise<void>;
+    /**
+     *
+     * @param peripheralId
+     * @param serviceUUID
+     * @param characteristicUUID
+     * @param data data to write as an array of numbers (which can be converted from a Uint8Array (ByteArray) using something like [Buffer.toJSON().data](https://github.com/feross/buffer))
+     * @param maxByteSize optional, defaults to 20
+     * @param queueSleepTime optional, defaults to 10. Only useful if data length is greater than maxByteSize.
+     * @returns
+     */
+    writeWithoutResponse(peripheralId: string, serviceUUID: string, characteristicUUID: string, data: number[], maxByteSize?: number, queueSleepTime?: number): Promise<void>;
+    connect(peripheralId: string): Promise<void>;
+    /**
+     * [Android only]
+     * @param peripheralId
+     * @param peripheralPin optional. will be used to auto-bond if possible.
+     * @returns
+     */
+    createBond(peripheralId: string, peripheralPin?: string | null): Promise<void>;
+    /**
+     * [Android only]
+     * @param peripheralId
+     * @returns
+     */
+    removeBond(peripheralId: string): Promise<void>;
+    /**
+     *
+     * @param peripheralId
+     * @param force [Android only] defaults to true.
+     * @returns
+     */
+    disconnect(peripheralId: string, force?: boolean): Promise<void>;
+    startNotification(peripheralId: string, serviceUUID: string, characteristicUUID: string): Promise<void>;
+    /**
+     * [Android only]
+     * @param peripheralId
+     * @param serviceUUID
+     * @param characteristicUUID
+     * @param buffer
+     * @returns
+     */
+    startNotificationUseBuffer(peripheralId: string, serviceUUID: string, characteristicUUID: string, buffer: number): Promise<void>;
+    stopNotification(peripheralId: string, serviceUUID: string, characteristicUUID: string): Promise<void>;
+    checkState(): Promise<BleState>;
+    start(options?: StartOptions): Promise<void>;
+    /**
+     *
+     * @param serviceUUIDs
+     * @param seconds amount of seconds to scan. if set to 0 or less, will scan until you call stopScan() or the OS stops the scan (background etc).
+     * @param allowDuplicates [iOS only]
+     * @param scanningOptions [Android only] optional map of properties to fine-tune scan behavior on android, see README.
+     * @returns
+     */
+    scan(serviceUUIDs: string[], seconds: number, allowDuplicates?: boolean, scanningOptions?: ScanOptions): Promise<void>;
+    stopScan(): Promise<void>;
+    /**
+     * [Android only] triggers an ENABLE_REQUEST intent to the end-user to enable bluetooth.
+     * @returns
+     */
+    enableBluetooth(): Promise<void>;
+    /**
+     *
+     * @param serviceUUIDs [optional] not used on android, optional on ios.
+     * @returns
+     */
+    getConnectedPeripherals(serviceUUIDs?: string[]): Promise<Peripheral[]>;
+    /**
+     * [Android only]
+     * @returns
+     */
+    getBondedPeripherals(): Promise<Peripheral[]>;
+    getDiscoveredPeripherals(): Promise<Peripheral[]>;
+    /**
+     * [Android only]
+     * @param peripheralId
+     * @returns
+     */
+    removePeripheral(peripheralId: string): Promise<void>;
+    /**
+     * @param peripheralId
+     * @param serviceUUIDs [optional] not used on android, optional on ios.
+     * @returns
+     */
+    isPeripheralConnected(peripheralId: string, serviceUUIDs?: string[]): Promise<boolean>;
+    /**
+     * [Android only, API 21+]
+     * @param peripheralId
+     * @param connectionPriority
+     * @returns a promise that resolves with a boolean indicating of the connection priority was changed successfully, or rejects with an error message.
+     */
+    requestConnectionPriority(peripheralId: string, connectionPriority: ConnectionPriority): Promise<boolean>;
+    /**
+     * [Android only, API 21+]
+     * @param peripheralId
+     * @param mtu size to be requested, in bytes.
+     * @returns a promise resolving with the negotiated MTU if it succeeded. Beware that it might not be the one requested due to device's BLE limitations on both side of the negotiation.
+     */
+    requestMTU(peripheralId: string, mtu: number): Promise<number>;
+    /**
+     * [Android only]
+     * @param name
+     */
+    setName(name: string): void;
+}
+declare const _default: BleManager;
+export default _default;