react-native-ble-nitro 1.0.0-beta.9 → 1.0.0

package/lib/compatibility/serviceData.js

@@ -1,70 +0,0 @@
-/**
- * Service Data compatibility layer
- *
- * Provides conversion between Nitro's structured ServiceDataEntry[] format
- * and the original { [uuid: string]: Base64 } format from react-native-ble-plx
- */
-/**
- * Convert ServiceDataEntry array to the original index signature format
- */
-export function serviceDataArrayToMap(entries) {
-    if (!entries || entries.length === 0) {
-        return null;
-    }
-    const result = {};
-    entries.forEach(entry => {
-        result[entry.uuid] = entry.data;
-    });
-    return result;
-}
-/**
- * Convert the original index signature format to ServiceDataEntry array
- */
-export function serviceDataMapToArray(map) {
-    if (!map || Object.keys(map).length === 0) {
-        return null;
-    }
-    return Object.entries(map).map(([uuid, data]) => ({
-        uuid: uuid,
-        data,
-    }));
-}
-/**
- * Merge two service data maps (used in device updates)
- */
-export function mergeServiceDataMaps(existing, updates) {
-    if (!existing && !updates)
-        return null;
-    if (!existing)
-        return updates;
-    if (!updates)
-        return existing;
-    return { ...existing, ...updates };
-}
-/**
- * Merge two service data arrays (used in native updates)
- */
-export function mergeServiceDataArrays(existing, updates) {
-    const existingMap = serviceDataArrayToMap(existing);
-    const updatesMap = serviceDataArrayToMap(updates);
-    const mergedMap = mergeServiceDataMaps(existingMap, updatesMap);
-    return serviceDataMapToArray(mergedMap);
-}
-/**
- * Check if service data contains a specific service UUID
- */
-export function hasServiceUUID(serviceData, uuid) {
-    return serviceData ? uuid in serviceData : false;
-}
-/**
- * Get service data for a specific UUID
- */
-export function getServiceData(serviceData, uuid) {
-    return serviceData?.[uuid] || null;
-}
-/**
- * Get all service UUIDs from service data
- */
-export function getServiceUUIDs(serviceData) {
-    return serviceData ? Object.keys(serviceData) : [];
-}

package/lib/errors/BleError.d.ts

@@ -1,59 +0,0 @@
-import { BleErrorCode, BleATTErrorCode, BleIOSErrorCode, BleAndroidErrorCode } from '../specs/types';
-import type { NativeBleError, BleErrorCodeMessageMapping } from '../specs/types';
-/**
- * Default error messages for BLE error codes
- * Maintains compatibility with react-native-ble-plx error messages
- */
-declare const BleErrorCodeMessage: BleErrorCodeMessageMapping;
-/**
- * BleError class that maintains 100% compatibility with react-native-ble-plx
- * Contains additional properties for platform-independent error handling
- */
-export declare class BleError extends Error {
-    /**
-     * Platform independent error code
-     */
-    readonly errorCode: BleErrorCode;
-    /**
-     * Platform independent error code related to ATT errors
-     */
-    readonly attErrorCode: BleATTErrorCode | null;
-    /**
-     * iOS specific error code (if not an ATT error)
-     */
-    readonly iosErrorCode: BleIOSErrorCode | null;
-    /**
-     * Android specific error code (if not an ATT error)
-     */
-    readonly androidErrorCode: BleAndroidErrorCode | null;
-    /**
-     * Platform specific error message
-     */
-    readonly reason: string | null;
-    /**
-     * Device ID associated with error (if applicable)
-     */
-    readonly deviceID?: string;
-    /**
-     * Service UUID associated with error (if applicable)
-     */
-    readonly serviceUUID?: string;
-    /**
-     * Characteristic UUID associated with error (if applicable)
-     */
-    readonly characteristicUUID?: string;
-    /**
-     * Descriptor UUID associated with error (if applicable)
-     */
-    readonly descriptorUUID?: string;
-    /**
-     * Internal error message for debugging
-     */
-    readonly internalMessage?: string;
-    constructor(nativeBleError: NativeBleError | string, errorMessageMapping?: BleErrorCodeMessageMapping);
-    /**
-     * Returns a string representation of the error with all relevant information
-     */
-    toString(): string;
-}
-export { BleErrorCodeMessage };

package/lib/errors/BleError.js

@@ -1,120 +0,0 @@
-import { BleErrorCode } from '../specs/types';
-/**
- * Default error messages for BLE error codes
- * Maintains compatibility with react-native-ble-plx error messages
- */
-const BleErrorCodeMessage = {
-    [BleErrorCode.UnknownError]: 'Unknown error occurred',
-    [BleErrorCode.BluetoothManagerDestroyed]: 'BLE Manager was destroyed',
-    [BleErrorCode.OperationCancelled]: 'Operation was cancelled',
-    [BleErrorCode.OperationTimedOut]: 'Operation timed out',
-    [BleErrorCode.OperationStartFailed]: 'Operation could not be started',
-    [BleErrorCode.InvalidIdentifiers]: 'Invalid identifiers provided',
-    [BleErrorCode.BluetoothUnsupported]: 'Bluetooth is not supported on this device',
-    [BleErrorCode.BluetoothUnauthorized]: 'App is not authorized to use Bluetooth',
-    [BleErrorCode.BluetoothPoweredOff]: 'Bluetooth is powered off',
-    [BleErrorCode.BluetoothInUnknownState]: 'Bluetooth is in unknown state',
-    [BleErrorCode.BluetoothResetting]: 'Bluetooth is resetting',
-    [BleErrorCode.BluetoothStateChangeFailed]: 'Bluetooth state change failed',
-    [BleErrorCode.DeviceConnectionFailed]: 'Device connection failed',
-    [BleErrorCode.DeviceDisconnected]: 'Device was disconnected',
-    [BleErrorCode.DeviceRSSIReadFailed]: 'Failed to read RSSI',
-    [BleErrorCode.DeviceAlreadyConnected]: 'Device is already connected',
-    [BleErrorCode.DeviceNotFound]: 'Device not found',
-    [BleErrorCode.DeviceNotConnected]: 'Device is not connected',
-    [BleErrorCode.DeviceMTUChangeFailed]: 'Failed to change MTU',
-    [BleErrorCode.ServicesDiscoveryFailed]: 'Services discovery failed',
-    [BleErrorCode.IncludedServicesDiscoveryFailed]: 'Included services discovery failed',
-    [BleErrorCode.ServiceNotFound]: 'Service not found',
-    [BleErrorCode.ServicesNotDiscovered]: 'Services not discovered',
-    [BleErrorCode.CharacteristicsDiscoveryFailed]: 'Characteristics discovery failed',
-    [BleErrorCode.CharacteristicWriteFailed]: 'Characteristic write failed',
-    [BleErrorCode.CharacteristicReadFailed]: 'Characteristic read failed',
-    [BleErrorCode.CharacteristicNotifyChangeFailed]: 'Failed to change characteristic notification state',
-    [BleErrorCode.CharacteristicNotFound]: 'Characteristic not found',
-    [BleErrorCode.CharacteristicsNotDiscovered]: 'Characteristics not discovered',
-    [BleErrorCode.CharacteristicInvalidDataFormat]: 'Invalid characteristic data format',
-    [BleErrorCode.DescriptorsDiscoveryFailed]: 'Descriptors discovery failed',
-    [BleErrorCode.DescriptorWriteFailed]: 'Descriptor write failed',
-    [BleErrorCode.DescriptorReadFailed]: 'Descriptor read failed',
-    [BleErrorCode.DescriptorNotFound]: 'Descriptor not found',
-    [BleErrorCode.DescriptorsNotDiscovered]: 'Descriptors not discovered',
-    [BleErrorCode.DescriptorInvalidDataFormat]: 'Invalid descriptor data format',
-    [BleErrorCode.DescriptorWriteNotAllowed]: 'Descriptor write not allowed',
-    [BleErrorCode.ScanStartFailed]: 'Failed to start scan',
-    [BleErrorCode.LocationServicesDisabled]: 'Location services are disabled'
-};
-/**
- * BleError class that maintains 100% compatibility with react-native-ble-plx
- * Contains additional properties for platform-independent error handling
- */
-export class BleError extends Error {
-    constructor(nativeBleError, errorMessageMapping = BleErrorCodeMessage) {
-        if (typeof nativeBleError === 'string') {
-            // Simple string error case
-            super(nativeBleError);
-            this.errorCode = BleErrorCode.UnknownError;
-            this.attErrorCode = null;
-            this.iosErrorCode = null;
-            this.androidErrorCode = null;
-            this.reason = nativeBleError;
-            return;
-        }
-        // Native BLE error case
-        const errorMessage = errorMessageMapping[nativeBleError.errorCode] || 'Unknown BLE error';
-        super(errorMessage);
-        this.errorCode = nativeBleError.errorCode;
-        this.attErrorCode = nativeBleError.attErrorCode;
-        this.iosErrorCode = nativeBleError.iosErrorCode;
-        this.androidErrorCode = nativeBleError.androidErrorCode;
-        this.reason = nativeBleError.reason;
-        if (nativeBleError.deviceID !== undefined)
-            this.deviceID = nativeBleError.deviceID;
-        if (nativeBleError.serviceUUID !== undefined)
-            this.serviceUUID = nativeBleError.serviceUUID;
-        if (nativeBleError.characteristicUUID !== undefined)
-            this.characteristicUUID = nativeBleError.characteristicUUID;
-        if (nativeBleError.descriptorUUID !== undefined)
-            this.descriptorUUID = nativeBleError.descriptorUUID;
-        if (nativeBleError.internalMessage !== undefined)
-            this.internalMessage = nativeBleError.internalMessage;
-        // Set proper prototype chain
-        Object.setPrototypeOf(this, BleError.prototype);
-        this.name = 'BleError';
-    }
-    /**
-     * Returns a string representation of the error with all relevant information
-     */
-    toString() {
-        const parts = [
-            `BleError: ${this.message}`,
-            `Error code: ${this.errorCode}`
-        ];
-        if (this.attErrorCode !== null) {
-            parts.push(`ATT error code: ${this.attErrorCode}`);
-        }
-        if (this.iosErrorCode !== null) {
-            parts.push(`iOS error code: ${this.iosErrorCode}`);
-        }
-        if (this.androidErrorCode !== null) {
-            parts.push(`Android error code: ${this.androidErrorCode}`);
-        }
-        if (this.reason) {
-            parts.push(`Reason: ${this.reason}`);
-        }
-        if (this.deviceID) {
-            parts.push(`Device ID: ${this.deviceID}`);
-        }
-        if (this.serviceUUID) {
-            parts.push(`Service UUID: ${this.serviceUUID}`);
-        }
-        if (this.characteristicUUID) {
-            parts.push(`Characteristic UUID: ${this.characteristicUUID}`);
-        }
-        if (this.descriptorUUID) {
-            parts.push(`Descriptor UUID: ${this.descriptorUUID}`);
-        }
-        return parts.join(', ');
-    }
-}
-export { BleErrorCodeMessage };

package/lib/specs/BleManager.nitro.d.ts

@@ -1,44 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-import type { State, LogLevel, UUID, DeviceId, TransactionId, ConnectionPriority, ScanOptions, ConnectionOptions, StateListener, DeviceScanListener, DeviceDisconnectedListener, CharacteristicMonitorListener, CharacteristicSubscriptionType, NativeDevice, NativeService, NativeCharacteristic, NativeDescriptor, Base64, Subscription } from './types';
-export interface BleManagerNitroOptions {
-    restoreStateIdentifier?: string;
-}
-export interface BleRestoredState {
-    connectedPeripherals: NativeDevice[];
-}
-export interface BleManager extends HybridObject<{
-    ios: 'swift';
-    android: 'kotlin';
-}> {
-    destroy(): Promise<void>;
-    initialize(options: BleManagerNitroOptions): Promise<void>;
-    getRestoredState(): Promise<BleRestoredState | null>;
-    setLogLevel(logLevel: LogLevel): Promise<LogLevel>;
-    logLevel(): Promise<LogLevel>;
-    cancelTransaction(transactionId: TransactionId): Promise<void>;
-    enable(transactionId?: TransactionId): Promise<void>;
-    disable(transactionId?: TransactionId): Promise<void>;
-    state(): Promise<State>;
-    onStateChange(listener: StateListener, emitCurrentState?: boolean): Subscription;
-    startDeviceScan(uuids: UUID[] | null, options: ScanOptions | null, listener: DeviceScanListener): Promise<void>;
-    stopDeviceScan(): Promise<void>;
-    requestConnectionPriorityForDevice(deviceIdentifier: DeviceId, connectionPriority: ConnectionPriority, transactionId?: TransactionId): Promise<NativeDevice>;
-    readRSSIForDevice(deviceIdentifier: DeviceId, transactionId?: TransactionId): Promise<NativeDevice>;
-    requestMTUForDevice(deviceIdentifier: DeviceId, mtu: number, transactionId?: TransactionId): Promise<NativeDevice>;
-    devices(deviceIdentifiers: DeviceId[]): Promise<NativeDevice[]>;
-    connectedDevices(serviceUUIDs: UUID[]): Promise<NativeDevice[]>;
-    connectToDevice(deviceIdentifier: DeviceId, options?: ConnectionOptions): Promise<NativeDevice>;
-    cancelDeviceConnection(deviceIdentifier: DeviceId): Promise<NativeDevice>;
-    onDeviceDisconnected(deviceIdentifier: DeviceId, listener: DeviceDisconnectedListener): Subscription;
-    isDeviceConnected(deviceIdentifier: DeviceId): Promise<boolean>;
-    discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: DeviceId, transactionId?: TransactionId): Promise<NativeDevice>;
-    servicesForDevice(deviceIdentifier: DeviceId): Promise<NativeService[]>;
-    characteristicsForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID): Promise<NativeCharacteristic[]>;
-    readCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    writeCharacteristicWithResponseForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, base64Value: Base64, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    writeCharacteristicWithoutResponseForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, base64Value: Base64, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    monitorCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, listener: CharacteristicMonitorListener, transactionId?: TransactionId, subscriptionType?: CharacteristicSubscriptionType): Subscription;
-    descriptorsForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID): Promise<NativeDescriptor[]>;
-    readDescriptorForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<NativeDescriptor>;
-    writeDescriptorForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<NativeDescriptor>;
-}

package/lib/specs/BleManager.nitro.js

@@ -1 +0,0 @@
-export {};

package/lib/specs/Characteristic.nitro.d.ts

@@ -1,26 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-import type { Identifier, UUID, DeviceId, Base64, TransactionId, CharacteristicSubscriptionType, NativeDescriptor, CharacteristicMonitorListener, Subscription } from './types';
-export interface Characteristic extends HybridObject<{
-    ios: 'swift';
-    android: 'kotlin';
-}> {
-    readonly id: Identifier;
-    readonly uuid: UUID;
-    readonly serviceID: Identifier;
-    readonly serviceUUID: UUID;
-    readonly deviceID: DeviceId;
-    readonly isReadable: boolean;
-    readonly isWritableWithResponse: boolean;
-    readonly isWritableWithoutResponse: boolean;
-    readonly isNotifiable: boolean;
-    readonly isNotifying: boolean;
-    readonly isIndicatable: boolean;
-    readonly value: Base64 | null;
-    read(transactionId?: TransactionId): Promise<Characteristic>;
-    writeWithResponse(valueBase64: Base64, transactionId?: TransactionId): Promise<Characteristic>;
-    writeWithoutResponse(valueBase64: Base64, transactionId?: TransactionId): Promise<Characteristic>;
-    monitor(listener: CharacteristicMonitorListener, transactionId?: TransactionId, subscriptionType?: CharacteristicSubscriptionType): Subscription;
-    descriptors(): Promise<NativeDescriptor[]>;
-    readDescriptor(descriptorUUID: UUID, transactionId?: TransactionId): Promise<NativeDescriptor>;
-    writeDescriptor(descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<NativeDescriptor>;
-}

package/lib/specs/Characteristic.nitro.js

@@ -1 +0,0 @@
-export {};

package/lib/specs/Descriptor.nitro.d.ts

@@ -1,17 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-import type { Identifier, UUID, DeviceId, Base64, TransactionId } from './types';
-export interface Descriptor extends HybridObject<{
-    ios: 'swift';
-    android: 'kotlin';
-}> {
-    readonly id: Identifier;
-    readonly uuid: UUID;
-    readonly characteristicID: Identifier;
-    readonly characteristicUUID: UUID;
-    readonly serviceID: Identifier;
-    readonly serviceUUID: UUID;
-    readonly deviceID: DeviceId;
-    readonly value: Base64 | null;
-    read(transactionId?: TransactionId): Promise<Descriptor>;
-    write(valueBase64: Base64, transactionId?: TransactionId): Promise<Descriptor>;
-}

package/lib/specs/Descriptor.nitro.js

@@ -1 +0,0 @@
-export {};

package/lib/specs/Device.nitro.d.ts

@@ -1,37 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-import type { DeviceId, UUID, Base64, TransactionId, ConnectionPriority, ConnectionOptions, CharacteristicSubscriptionType, ServiceDataEntry, NativeDevice, NativeService, NativeCharacteristic, NativeDescriptor, DeviceDisconnectedListener, CharacteristicMonitorListener, Subscription } from './types';
-export interface Device extends HybridObject<{
-    ios: 'swift';
-    android: 'kotlin';
-}> {
-    readonly id: DeviceId;
-    readonly deviceName?: string | null;
-    readonly rssi?: number | null;
-    readonly mtu: number;
-    readonly manufacturerData?: Base64 | null;
-    readonly rawScanRecord: Base64;
-    readonly serviceData?: ServiceDataEntry[] | null;
-    readonly serviceUUIDs?: UUID[] | null;
-    readonly localName?: string | null;
-    readonly txPowerLevel?: number | null;
-    readonly solicitedServiceUUIDs?: UUID[] | null;
-    readonly isConnectable?: boolean | null;
-    readonly overflowServiceUUIDs?: UUID[] | null;
-    requestConnectionPriority(connectionPriority: ConnectionPriority, transactionId?: TransactionId): Promise<NativeDevice>;
-    readRSSI(transactionId?: TransactionId): Promise<NativeDevice>;
-    requestMTU(mtu: number, transactionId?: TransactionId): Promise<NativeDevice>;
-    connect(options?: ConnectionOptions): Promise<NativeDevice>;
-    cancelConnection(): Promise<NativeDevice>;
-    isConnected(): Promise<boolean>;
-    onDisconnected(listener: DeviceDisconnectedListener): Subscription;
-    discoverAllServicesAndCharacteristics(transactionId?: TransactionId): Promise<NativeDevice>;
-    services(): Promise<NativeService[]>;
-    characteristicsForService(serviceUUID: UUID): Promise<NativeCharacteristic[]>;
-    readCharacteristicForService(serviceUUID: UUID, characteristicUUID: UUID, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    writeCharacteristicWithResponseForService(serviceUUID: UUID, characteristicUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    writeCharacteristicWithoutResponseForService(serviceUUID: UUID, characteristicUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    monitorCharacteristicForService(serviceUUID: UUID, characteristicUUID: UUID, listener: CharacteristicMonitorListener, transactionId?: TransactionId, subscriptionType?: CharacteristicSubscriptionType): Subscription;
-    descriptorsForService(serviceUUID: UUID, characteristicUUID: UUID): Promise<NativeDescriptor[]>;
-    readDescriptorForService(serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<NativeDescriptor>;
-    writeDescriptorForService(serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<NativeDescriptor>;
-}

package/lib/specs/Device.nitro.js

@@ -1 +0,0 @@
-export {};

package/lib/specs/Service.nitro.d.ts

@@ -1,19 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-import type { Identifier, UUID, DeviceId, Base64, TransactionId, CharacteristicSubscriptionType, NativeCharacteristic, NativeDescriptor, CharacteristicMonitorListener, Subscription } from './types';
-export interface Service extends HybridObject<{
-    ios: 'swift';
-    android: 'kotlin';
-}> {
-    readonly id: Identifier;
-    readonly uuid: UUID;
-    readonly deviceID: DeviceId;
-    readonly isPrimary: boolean;
-    characteristics(): Promise<NativeCharacteristic[]>;
-    readCharacteristic(characteristicUUID: UUID, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    writeCharacteristicWithResponse(characteristicUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    writeCharacteristicWithoutResponse(characteristicUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    monitorCharacteristic(characteristicUUID: UUID, listener: CharacteristicMonitorListener, transactionId?: TransactionId, subscriptionType?: CharacteristicSubscriptionType): Subscription;
-    descriptorsForCharacteristic(characteristicUUID: UUID): Promise<NativeDescriptor[]>;
-    readDescriptorForCharacteristic(characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<NativeDescriptor>;
-    writeDescriptorForCharacteristic(characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<NativeDescriptor>;
-}

package/lib/specs/Service.nitro.js

@@ -1 +0,0 @@
-export {};

package/lib/specs/types.d.ts

@@ -1,228 +0,0 @@
-export type Base64 = string;
-export type UUID = string;
-export type Identifier = number;
-export type DeviceId = string;
-export type TransactionId = string;
-export declare enum RefreshGattMoment {
-    OnConnected = 0
-}
-export declare enum CharacteristicSubscriptionType {
-    Notification = 0,
-    Indication = 1
-}
-export interface ServiceDataEntry {
-    uuid: UUID;
-    data: Base64;
-}
-export declare enum State {
-    Unknown = 0,
-    Resetting = 1,
-    Unsupported = 2,
-    Unauthorized = 3,
-    PoweredOff = 4,
-    PoweredOn = 5
-}
-export declare enum LogLevel {
-    None = 0,
-    Verbose = 1,
-    Debug = 2,
-    Info = 3,
-    Warning = 4,
-    Error = 5
-}
-export declare enum ScanMode {
-    Opportunistic = -1,
-    LowPower = 0,
-    Balanced = 1,
-    LowLatency = 2
-}
-export declare enum ScanCallbackType {
-    AllMatches = 1,
-    FirstMatch = 2,
-    MatchLost = 4
-}
-export declare enum ConnectionPriority {
-    Balanced = 0,
-    High = 1,
-    LowPower = 2
-}
-export declare enum BleErrorCode {
-    UnknownError = 0,
-    BluetoothManagerDestroyed = 1,
-    OperationCancelled = 2,
-    OperationTimedOut = 3,
-    OperationStartFailed = 4,
-    InvalidIdentifiers = 5,
-    BluetoothUnsupported = 100,
-    BluetoothUnauthorized = 101,
-    BluetoothPoweredOff = 102,
-    BluetoothInUnknownState = 103,
-    BluetoothResetting = 104,
-    BluetoothStateChangeFailed = 105,
-    DeviceConnectionFailed = 200,
-    DeviceDisconnected = 201,
-    DeviceRSSIReadFailed = 202,
-    DeviceAlreadyConnected = 203,
-    DeviceNotFound = 204,
-    DeviceNotConnected = 205,
-    DeviceMTUChangeFailed = 206,
-    ServicesDiscoveryFailed = 300,
-    IncludedServicesDiscoveryFailed = 301,
-    ServiceNotFound = 302,
-    ServicesNotDiscovered = 303,
-    CharacteristicsDiscoveryFailed = 400,
-    CharacteristicWriteFailed = 401,
-    CharacteristicReadFailed = 402,
-    CharacteristicNotifyChangeFailed = 403,
-    CharacteristicNotFound = 404,
-    CharacteristicsNotDiscovered = 405,
-    CharacteristicInvalidDataFormat = 406,
-    DescriptorsDiscoveryFailed = 500,
-    DescriptorWriteFailed = 501,
-    DescriptorReadFailed = 502,
-    DescriptorNotFound = 503,
-    DescriptorsNotDiscovered = 504,
-    DescriptorInvalidDataFormat = 505,
-    DescriptorWriteNotAllowed = 506,
-    ScanStartFailed = 600,
-    LocationServicesDisabled = 601
-}
-export declare enum BleATTErrorCode {
-    Success = 0,
-    InvalidHandle = 1,
-    ReadNotPermitted = 2,
-    WriteNotPermitted = 3,
-    InvalidPdu = 4,
-    InsufficientAuthentication = 5,
-    RequestNotSupported = 6,
-    InvalidOffset = 7,
-    InsufficientAuthorization = 8,
-    PrepareQueueFull = 9,
-    AttributeNotFound = 10,
-    AttributeNotLong = 11,
-    InsufficientEncryptionKeySize = 12,
-    InvalidAttributeValueLength = 13,
-    UnlikelyError = 14,
-    InsufficientEncryption = 15,
-    UnsupportedGroupType = 16,
-    InsufficientResources = 17
-}
-export declare enum BleIOSErrorCode {
-    Unknown = 0,
-    InvalidParameters = 1,
-    InvalidHandle = 2,
-    NotConnected = 3,
-    OutOfSpace = 4,
-    OperationCancelled = 5,
-    ConnectionTimeout = 6,
-    PeripheralDisconnected = 7,
-    UuidNotAllowed = 8,
-    AlreadyAdvertising = 9,
-    ConnectionFailed = 10,
-    ConnectionLimitReached = 11,
-    UnknownDevice = 12
-}
-export declare enum BleAndroidErrorCode {
-    NoResources = 128,
-    InternalError = 129,
-    WrongState = 130,
-    DbFull = 131,
-    Busy = 132,
-    Error = 133,
-    CmdStarted = 134,
-    IllegalParameter = 135,
-    Pending = 136,
-    AuthFail = 137,
-    More = 138,
-    InvalidCfg = 139,
-    ServiceStarted = 140,
-    EncrypedNoMitm = 141,
-    NotEncrypted = 142,
-    Congested = 143
-}
-export interface ScanOptions {
-    allowDuplicates?: boolean;
-    scanMode?: ScanMode;
-    callbackType?: ScanCallbackType;
-    legacyScan?: boolean;
-}
-export interface ConnectionOptions {
-    autoConnect: boolean;
-    requestMTU: number;
-    timeout: number;
-}
-export interface BleManagerOptions {
-    restoreStateIdentifier?: string;
-    restoreStateFunction?: (restoredState: BleRestoredState | null) => void;
-    errorCodesToMessagesMapping?: BleErrorCodeMessageMapping;
-}
-export interface BleRestoredState {
-    connectedPeripherals: NativeDevice[];
-}
-export type BleErrorCodeMessageMapping = {
-    [key in BleErrorCode]: string;
-};
-export interface NativeDevice {
-    id: DeviceId;
-    name: string | null;
-    rssi: number | null;
-    mtu: number;
-    manufacturerData: Base64 | null;
-    rawScanRecord: Base64;
-    serviceData: ServiceDataEntry[] | null;
-    serviceUUIDs: UUID[] | null;
-    localName: string | null;
-    txPowerLevel: number | null;
-    solicitedServiceUUIDs: UUID[] | null;
-    isConnectable: boolean | null;
-    overflowServiceUUIDs: UUID[] | null;
-}
-export interface NativeService {
-    id: Identifier;
-    uuid: UUID;
-    deviceID: DeviceId;
-    isPrimary: boolean;
-}
-export interface NativeCharacteristic {
-    id: Identifier;
-    uuid: UUID;
-    serviceID: Identifier;
-    serviceUUID: UUID;
-    deviceID: DeviceId;
-    isReadable: boolean;
-    isWritableWithResponse: boolean;
-    isWritableWithoutResponse: boolean;
-    isNotifiable: boolean;
-    isNotifying: boolean;
-    isIndicatable: boolean;
-    value: Base64 | null;
-}
-export interface NativeDescriptor {
-    id: Identifier;
-    uuid: UUID;
-    characteristicID: Identifier;
-    characteristicUUID: UUID;
-    serviceID: Identifier;
-    serviceUUID: UUID;
-    deviceID: DeviceId;
-    value: Base64 | null;
-}
-export interface NativeBleError {
-    errorCode: BleErrorCode;
-    attErrorCode: BleATTErrorCode | null;
-    iosErrorCode: BleIOSErrorCode | null;
-    androidErrorCode: BleAndroidErrorCode | null;
-    reason: string | null;
-    deviceID?: string;
-    serviceUUID?: string;
-    characteristicUUID?: string;
-    descriptorUUID?: string;
-    internalMessage?: string;
-}
-export interface Subscription {
-    remove(): void;
-}
-export type StateListener = (newState: State) => void;
-export type DeviceScanListener = (error: NativeBleError | null, scannedDevice: NativeDevice | null) => void;
-export type DeviceDisconnectedListener = (error: NativeBleError | null, device: NativeDevice | null) => void;
-export type CharacteristicMonitorListener = (error: NativeBleError | null, characteristic: NativeCharacteristic | null) => void;