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

package/ios/BleNitro.podspec

@@ -1,44 +0,0 @@
-require "json"
-
-package = JSON.parse(File.read(File.join(__dir__, "..", "package.json")))
-
-Pod::Spec.new do |s|
-  s.name         = "BleNitro"
-  s.version      = package["version"]
-  s.summary      = package["description"]
-  s.homepage     = package["homepage"]
-  s.license      = package["license"]
-  s.authors      = package["author"]
-
-  s.platforms    = { :ios => "15.1" }
-  s.source       = { :git => "https://github.com/zykeco/react-native-ble-nitro.git", :tag => "#{s.version}" }
-
-  s.source_files = "**/*.{h,m,mm,swift}"
-  s.swift_version = "5.0"
-
-  # Nitro dependencies
-  s.dependency "React-Core"
-  s.dependency "NitroModules", "0.26.4"
-  
-  # iOS frameworks
-  s.frameworks = "CoreBluetooth"
-  
-  # Apply Nitro autolinking
-  load '../nitrogen/generated/ios/BleNitro+autolinking.rb'
-  add_nitrogen_files(s)
-  
-  # Base build settings (will be merged with autolinking settings)
-  base_xcconfig = {
-    'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) FOLLY_NO_CONFIG FOLLY_MOBILE=1 FOLLY_USE_LIBCPP=1',
-    'CLANG_CXX_LIBRARY' => 'libc++',
-    'OTHER_CPLUSPLUSFLAGS' => '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1'
-  }
-  
-  # Merge with existing pod_target_xcconfig from autolinking
-  current_xcconfig = s.pod_target_xcconfig || {}
-  s.pod_target_xcconfig = base_xcconfig.merge(current_xcconfig)
-  
-  s.user_target_xcconfig = {
-    'OTHER_LDFLAGS' => '-lc++'
-  }
-end

package/ios/BleNitroModule.swift

@@ -1,24 +0,0 @@
-///
-/// BleNitroModule.swift  
-/// React Native BLE Nitro - iOS Module Registration
-/// Copyright © 2025 Zyke (https://zyke.co)
-///
-
-import Foundation
-import NitroModules
-
-@objc(BleNitroModule)
-public class BleNitroModule: NSObject {
-    
-    @objc
-    public static func requiresMainQueueSetup() -> Bool {
-        return false
-    }
-    
-    @objc
-    public func constantsToExport() -> [String: Any] {
-        return [:]
-    }
-    
-    // Autolinking handles the Nitro registration automatically
-}

package/lib/BleManagerCompatFactory.d.ts

@@ -1,55 +0,0 @@
-/**
- * BleManager Compatibility Factory
- *
- * Creates BleManager instances with full react-native-ble-plx compatibility
- * by wrapping the Nitro implementation with compatibility shims
- */
-import type { BleManagerOptions, UUID, DeviceId, TransactionId, ConnectionPriority, ConnectionOptions, ScanOptions, NativeService, NativeCharacteristic, NativeDescriptor, LogLevel, Subscription } from './specs/types';
-import { DeviceWrapper } from './compatibility/deviceWrapper';
-import { State as PlxState, LogLevel as PlxLogLevel } from './compatibility/enums';
-/**
- * BleManager wrapper that provides react-native-ble-plx compatibility
- */
-export declare class BleManagerCompat {
-    private bleManager;
-    constructor(options?: BleManagerOptions);
-    destroy(): Promise<void>;
-    setLogLevel(logLevel: LogLevel | string): Promise<PlxLogLevel>;
-    logLevel(): Promise<PlxLogLevel>;
-    cancelTransaction(transactionId: TransactionId): Promise<void>;
-    enable(transactionId?: TransactionId): Promise<BleManagerCompat>;
-    disable(transactionId?: TransactionId): Promise<BleManagerCompat>;
-    state(): Promise<PlxState>;
-    onStateChange(listener: (newState: PlxState) => void, emitCurrentState?: boolean): Subscription;
-    startDeviceScan(uuids: UUID[] | null, options: ScanOptions | null, listener: (error: any | null, scannedDevice: DeviceWrapper | null) => void): Promise<void>;
-    stopDeviceScan(): Promise<void>;
-    connectToDevice(deviceIdentifier: DeviceId, options?: Partial<ConnectionOptions>): Promise<DeviceWrapper>;
-    cancelDeviceConnection(deviceIdentifier: DeviceId): Promise<DeviceWrapper>;
-    isDeviceConnected(deviceIdentifier: DeviceId): Promise<boolean>;
-    onDeviceDisconnected(deviceIdentifier: DeviceId, listener: (error: any | null, device: DeviceWrapper | null) => void): Subscription;
-    devices(deviceIdentifiers: DeviceId[]): Promise<DeviceWrapper[]>;
-    connectedDevices(serviceUUIDs: UUID[]): Promise<DeviceWrapper[]>;
-    readRSSIForDevice(deviceIdentifier: DeviceId, transactionId?: TransactionId): Promise<DeviceWrapper>;
-    requestMTUForDevice(deviceIdentifier: DeviceId, mtu: number, transactionId?: TransactionId): Promise<DeviceWrapper>;
-    requestConnectionPriorityForDevice(deviceIdentifier: DeviceId, connectionPriority: ConnectionPriority, transactionId?: TransactionId): Promise<DeviceWrapper>;
-    discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: DeviceId, transactionId?: TransactionId): Promise<DeviceWrapper>;
-    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: string, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    writeCharacteristicWithoutResponseForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, base64Value: string, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    monitorCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, listener: (error: any | null, characteristic: NativeCharacteristic | null) => void, // TODO: COMPAT! use proper error type like in react-native-ble-plx
-    transactionId?: TransactionId, subscriptionType?: 'notification' | 'indication'): 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: string, transactionId?: TransactionId): Promise<NativeDescriptor>;
-    /**
-     * Helper method to create a Device wrapper from NativeDevice data
-     * This is a temporary method until we have proper Device Nitro objects
-     */
-    private createDeviceFromNative;
-}
-/**
- * Factory function to create a compatibility BleManager
- */
-export declare function createBleManagerCompat(options?: BleManagerOptions): BleManagerCompat;

package/lib/BleManagerCompatFactory.js

@@ -1,194 +0,0 @@
-/**
- * BleManager Compatibility Factory
- *
- * Creates BleManager instances with full react-native-ble-plx compatibility
- * by wrapping the Nitro implementation with compatibility shims
- */
-import { createBleManager } from './BleManagerFactory';
-import { DeviceWrapper } from './compatibility/deviceWrapper';
-import { stateToString, logLevelToString, normalizeLogLevel, normalizeCharacteristicSubscriptionType } from './compatibility/enums';
-/**
- * BleManager wrapper that provides react-native-ble-plx compatibility
- */
-export class BleManagerCompat {
-    constructor(options) {
-        this.bleManager = createBleManager(options);
-    }
-    // Lifecycle
-    async destroy() {
-        return await this.bleManager.destroy();
-    }
-    // Common operations with compatibility
-    async setLogLevel(logLevel) {
-        const normalizedLogLevel = normalizeLogLevel(logLevel);
-        const result = await this.bleManager.setLogLevel(normalizedLogLevel);
-        return logLevelToString(result);
-    }
-    async logLevel() {
-        const result = await this.bleManager.logLevel();
-        return logLevelToString(result);
-    }
-    async cancelTransaction(transactionId) {
-        return await this.bleManager.cancelTransaction(transactionId);
-    }
-    // State management with string conversion
-    async enable(transactionId) {
-        await this.bleManager.enable(transactionId);
-        return this;
-    }
-    async disable(transactionId) {
-        await this.bleManager.disable(transactionId);
-        return this;
-    }
-    async state() {
-        const result = await this.bleManager.state();
-        return stateToString(result);
-    }
-    onStateChange(listener, emitCurrentState) {
-        return this.bleManager.onStateChange((state) => {
-            listener(stateToString(state));
-        }, emitCurrentState);
-    }
-    // Device scanning with compatibility wrappers
-    async startDeviceScan(uuids, options, listener // TODO: COMPAT! remove any and move to BleError as react-native-ble-plx uses this type as well!
-    ) {
-        return await this.bleManager.startDeviceScan(uuids, options, (error, device) => {
-            listener(error, device ? new DeviceWrapper(this.createDeviceFromNative(device)) : null);
-        });
-    }
-    async stopDeviceScan() {
-        return await this.bleManager.stopDeviceScan();
-    }
-    // Connection management
-    async connectToDevice(deviceIdentifier, options) {
-        // Provide defaults for Nitro's required fields
-        const connectionOptions = {
-            autoConnect: options?.autoConnect ?? false,
-            requestMTU: options?.requestMTU ?? 23,
-            timeout: options?.timeout ?? 0,
-        };
-        const result = await this.bleManager.connectToDevice(deviceIdentifier, connectionOptions);
-        return new DeviceWrapper(this.createDeviceFromNative(result));
-    }
-    async cancelDeviceConnection(deviceIdentifier) {
-        const result = await this.bleManager.cancelDeviceConnection(deviceIdentifier);
-        return new DeviceWrapper(this.createDeviceFromNative(result));
-    }
-    async isDeviceConnected(deviceIdentifier) {
-        return await this.bleManager.isDeviceConnected(deviceIdentifier);
-    }
-    onDeviceDisconnected(deviceIdentifier, listener // TODO: COMPAT! use propper error type like in react-native-ble-plx!!!
-    ) {
-        return this.bleManager.onDeviceDisconnected(deviceIdentifier, (error, device) => {
-            listener(error, device ? new DeviceWrapper(this.createDeviceFromNative(device)) : null);
-        });
-    }
-    // Device discovery
-    async devices(deviceIdentifiers) {
-        const result = await this.bleManager.devices(deviceIdentifiers);
-        return result.map(device => new DeviceWrapper(this.createDeviceFromNative(device)));
-    }
-    async connectedDevices(serviceUUIDs) {
-        const result = await this.bleManager.connectedDevices(serviceUUIDs);
-        return result.map(device => new DeviceWrapper(this.createDeviceFromNative(device)));
-    }
-    // RSSI and MTU operations
-    async readRSSIForDevice(deviceIdentifier, transactionId) {
-        const result = await this.bleManager.readRSSIForDevice(deviceIdentifier, transactionId);
-        return new DeviceWrapper(this.createDeviceFromNative(result));
-    }
-    async requestMTUForDevice(deviceIdentifier, mtu, transactionId) {
-        const result = await this.bleManager.requestMTUForDevice(deviceIdentifier, mtu, transactionId);
-        return new DeviceWrapper(this.createDeviceFromNative(result));
-    }
-    async requestConnectionPriorityForDevice(deviceIdentifier, connectionPriority, transactionId) {
-        const result = await this.bleManager.requestConnectionPriorityForDevice(deviceIdentifier, connectionPriority, transactionId);
-        return new DeviceWrapper(this.createDeviceFromNative(result));
-    }
-    // Service discovery
-    async discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier, transactionId) {
-        const result = await this.bleManager.discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier, transactionId);
-        return new DeviceWrapper(this.createDeviceFromNative(result));
-    }
-    // Service operations
-    async servicesForDevice(deviceIdentifier) {
-        return await this.bleManager.servicesForDevice(deviceIdentifier);
-    }
-    // Characteristic operations
-    async characteristicsForDevice(deviceIdentifier, serviceUUID) {
-        return await this.bleManager.characteristicsForDevice(deviceIdentifier, serviceUUID);
-    }
-    async readCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, transactionId) {
-        return await this.bleManager.readCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, transactionId);
-    }
-    async writeCharacteristicWithResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId) {
-        return await this.bleManager.writeCharacteristicWithResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId);
-    }
-    async writeCharacteristicWithoutResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId) {
-        return await this.bleManager.writeCharacteristicWithoutResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId);
-    }
-    monitorCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, listener, // TODO: COMPAT! use proper error type like in react-native-ble-plx
-    transactionId, subscriptionType) {
-        const nitroSubscriptionType = subscriptionType
-            ? normalizeCharacteristicSubscriptionType(subscriptionType)
-            : undefined;
-        return this.bleManager.monitorCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, listener, transactionId, nitroSubscriptionType);
-    }
-    // Descriptor operations
-    async descriptorsForDevice(deviceIdentifier, serviceUUID, characteristicUUID) {
-        return await this.bleManager.descriptorsForDevice(deviceIdentifier, serviceUUID, characteristicUUID);
-    }
-    async readDescriptorForDevice(deviceIdentifier, serviceUUID, characteristicUUID, descriptorUUID, transactionId) {
-        return await this.bleManager.readDescriptorForDevice(deviceIdentifier, serviceUUID, characteristicUUID, descriptorUUID, transactionId);
-    }
-    async writeDescriptorForDevice(deviceIdentifier, serviceUUID, characteristicUUID, descriptorUUID, valueBase64, transactionId) {
-        return await this.bleManager.writeDescriptorForDevice(deviceIdentifier, serviceUUID, characteristicUUID, descriptorUUID, valueBase64, transactionId);
-    }
-    /**
-     * Helper method to create a Device wrapper from NativeDevice data
-     * This is a temporary method until we have proper Device Nitro objects
-     */
-    createDeviceFromNative(nativeDevice) {
-        // This is a placeholder - in the actual implementation, we'd need to create
-        // proper Nitro Device objects, but for now we'll work with the native data
-        return {
-            id: nativeDevice.id,
-            deviceName: nativeDevice.name,
-            rssi: nativeDevice.rssi,
-            mtu: nativeDevice.mtu,
-            manufacturerData: nativeDevice.manufacturerData,
-            rawScanRecord: nativeDevice.rawScanRecord,
-            serviceData: nativeDevice.serviceData,
-            serviceUUIDs: nativeDevice.serviceUUIDs,
-            localName: nativeDevice.localName,
-            txPowerLevel: nativeDevice.txPowerLevel,
-            solicitedServiceUUIDs: nativeDevice.solicitedServiceUUIDs,
-            isConnectable: nativeDevice.isConnectable,
-            overflowServiceUUIDs: nativeDevice.overflowServiceUUIDs,
-            // Add placeholder methods - these would be implemented in the actual Device class
-            requestConnectionPriority: async () => this.createDeviceFromNative(nativeDevice),
-            readRSSI: async () => this.createDeviceFromNative(nativeDevice),
-            requestMTU: async () => this.createDeviceFromNative(nativeDevice),
-            connect: async () => this.createDeviceFromNative(nativeDevice),
-            cancelConnection: async () => this.createDeviceFromNative(nativeDevice),
-            isConnected: async () => false,
-            onDisconnected: () => ({ remove: () => { } }),
-            discoverAllServicesAndCharacteristics: async () => this.createDeviceFromNative(nativeDevice),
-            services: async () => [],
-            characteristicsForService: async () => [],
-            readCharacteristicForService: async () => ({}),
-            writeCharacteristicWithResponseForService: async () => ({}),
-            writeCharacteristicWithoutResponseForService: async () => ({}),
-            monitorCharacteristicForService: () => ({ remove: () => { } }),
-            descriptorsForService: async () => [],
-            readDescriptorForService: async () => ({}),
-            writeDescriptorForService: async () => ({}),
-        };
-    }
-}
-/**
- * Factory function to create a compatibility BleManager
- */
-export function createBleManagerCompat(options) {
-    return new BleManagerCompat(options);
-}

package/lib/BleManagerFactory.d.ts

@@ -1,30 +0,0 @@
-import type { BleManager as BleManagerInterface } from './specs/BleManager.nitro';
-import type { BleManagerOptions } from './specs/types';
-/**
- * Creates a BleManager instance using Nitro Modules
- * This function maintains compatibility with react-native-ble-plx's BleManager constructor
- */
-export declare function createBleManager(options?: BleManagerOptions): BleManagerInterface;
-/**
- * Helper function to retrieve stored callbacks for a BleManager instance
- * This is used internally when callbacks need to be invoked
- */
-export declare function getStoredCallbacks(manager: BleManagerInterface): {
-    restoreStateFunction?: (restoredState: any) => void;
-    errorCodesToMessagesMapping?: {
-        [key: number]: string;
-    };
-} | undefined;
-/**
- * Helper function to get custom error message if available
- * @param manager The BleManager instance
- * @param errorCode The BLE error code
- * @param defaultMessage Default error message
- * @returns Custom message if available, otherwise default message
- */
-export declare function getCustomErrorMessage(manager: BleManagerInterface, errorCode: number, defaultMessage: string): string;
-/**
- * Legacy compatibility: Export a BleManager constructor function
- * This maintains compatibility with code that imports { BleManager } from 'react-native-ble-plx'
- */
-export declare const BleManager: (options?: BleManagerOptions) => BleManagerInterface;

package/lib/BleManagerFactory.js

@@ -1,73 +0,0 @@
-import { NitroModules } from 'react-native-nitro-modules';
-// Store callbacks that can't be passed to Nitro
-const storedCallbacks = new WeakMap();
-/**
- * Creates a BleManager instance using Nitro Modules
- * This function maintains compatibility with react-native-ble-plx's BleManager constructor
- */
-export function createBleManager(options) {
-    const BleManagerModule = NitroModules.createHybridObject('BleManager');
-    if (!BleManagerModule) {
-        throw new Error('Failed to create BleManager: Nitro module not found. ' +
-            'Make sure react-native-ble-nitro is properly installed and linked.');
-    }
-    // Initialize with options if provided
-    if (options) {
-        // Extract Nitro-compatible options
-        const nitroOptions = {
-            restoreStateIdentifier: options.restoreStateIdentifier,
-        };
-        // Store callbacks and mappings that can't be passed to Nitro
-        if (options.restoreStateFunction || options.errorCodesToMessagesMapping) {
-            storedCallbacks.set(BleManagerModule, {
-                restoreStateFunction: options.restoreStateFunction,
-                errorCodesToMessagesMapping: options.errorCodesToMessagesMapping,
-            });
-        }
-        // Note: initialize() is async but we need to maintain sync compatibility with react-native-ble-plx
-        // The initialization will happen asynchronously in the background
-        BleManagerModule.initialize(nitroOptions).then(async () => {
-            // Check for restored state and call the callback if available
-            if (options.restoreStateFunction) {
-                try {
-                    const restoredState = await BleManagerModule.getRestoredState();
-                    if (restoredState) {
-                        options.restoreStateFunction(restoredState);
-                    }
-                }
-                catch (error) {
-                    console.warn('BleManager restore state callback failed:', error);
-                }
-            }
-        }).catch(error => {
-            console.warn('BleManager initialization failed:', error);
-        });
-    }
-    return BleManagerModule;
-}
-/**
- * Helper function to retrieve stored callbacks for a BleManager instance
- * This is used internally when callbacks need to be invoked
- */
-export function getStoredCallbacks(manager) {
-    return storedCallbacks.get(manager);
-}
-/**
- * Helper function to get custom error message if available
- * @param manager The BleManager instance
- * @param errorCode The BLE error code
- * @param defaultMessage Default error message
- * @returns Custom message if available, otherwise default message
- */
-export function getCustomErrorMessage(manager, errorCode, defaultMessage) {
-    const callbacks = storedCallbacks.get(manager);
-    const customMessage = callbacks?.errorCodesToMessagesMapping?.[errorCode];
-    return customMessage || defaultMessage;
-}
-/**
- * Legacy compatibility: Export a BleManager constructor function
- * This maintains compatibility with code that imports { BleManager } from 'react-native-ble-plx'
- */
-export const BleManager = function (options) {
-    return createBleManager(options);
-};

package/lib/commonjs/BleManagerCompatFactory.d.ts

@@ -1,56 +0,0 @@
-/**
- * BleManager Compatibility Factory
- *
- * Creates BleManager instances with full react-native-ble-plx compatibility
- * by wrapping the Nitro implementation with compatibility shims
- */
-import type { BleManagerOptions, UUID, DeviceId, TransactionId, ConnectionPriority, ConnectionOptions, ScanOptions, NativeService, NativeCharacteristic, NativeDescriptor, LogLevel, Subscription } from './specs/types';
-import { DeviceWrapper } from './compatibility/deviceWrapper';
-import { State as PlxState, LogLevel as PlxLogLevel } from './compatibility/enums';
-/**
- * BleManager wrapper that provides react-native-ble-plx compatibility
- */
-export declare class BleManagerCompat {
-    private bleManager;
-    constructor(options?: BleManagerOptions);
-    destroy(): Promise<void>;
-    setLogLevel(logLevel: LogLevel | string): Promise<PlxLogLevel>;
-    logLevel(): Promise<PlxLogLevel>;
-    cancelTransaction(transactionId: TransactionId): Promise<void>;
-    enable(transactionId?: TransactionId): Promise<BleManagerCompat>;
-    disable(transactionId?: TransactionId): Promise<BleManagerCompat>;
-    state(): Promise<PlxState>;
-    onStateChange(listener: (newState: PlxState) => void, emitCurrentState?: boolean): Subscription;
-    startDeviceScan(uuids: UUID[] | null, options: ScanOptions | null, listener: (error: any | null, scannedDevice: DeviceWrapper | null) => void): Promise<void>;
-    stopDeviceScan(): Promise<void>;
-    connectToDevice(deviceIdentifier: DeviceId, options?: Partial<ConnectionOptions>): Promise<DeviceWrapper>;
-    cancelDeviceConnection(deviceIdentifier: DeviceId): Promise<DeviceWrapper>;
-    isDeviceConnected(deviceIdentifier: DeviceId): Promise<boolean>;
-    onDeviceDisconnected(deviceIdentifier: DeviceId, listener: (error: any | null, device: DeviceWrapper | null) => void): Subscription;
-    devices(deviceIdentifiers: DeviceId[]): Promise<DeviceWrapper[]>;
-    connectedDevices(serviceUUIDs: UUID[]): Promise<DeviceWrapper[]>;
-    readRSSIForDevice(deviceIdentifier: DeviceId, transactionId?: TransactionId): Promise<DeviceWrapper>;
-    requestMTUForDevice(deviceIdentifier: DeviceId, mtu: number, transactionId?: TransactionId): Promise<DeviceWrapper>;
-    requestConnectionPriorityForDevice(deviceIdentifier: DeviceId, connectionPriority: ConnectionPriority, transactionId?: TransactionId): Promise<DeviceWrapper>;
-    discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: DeviceId, transactionId?: TransactionId): Promise<DeviceWrapper>;
-    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: string, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    writeCharacteristicWithoutResponseForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, base64Value: string, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    monitorCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, listener: (error: any | null, characteristic: NativeCharacteristic | null) => void, // TODO: COMPAT! use proper error type like in react-native-ble-plx
-    transactionId?: TransactionId, subscriptionType?: 'notification' | 'indication'): 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: string, transactionId?: TransactionId): Promise<NativeDescriptor>;
-    /**
-     * Helper method to create a Device wrapper from NativeDevice data
-     * This is a temporary method until we have proper Device Nitro objects
-     */
-    private createDeviceFromNative;
-}
-/**
- * Factory function to create a compatibility BleManager
- */
-export declare function createBleManagerCompat(options?: BleManagerOptions): BleManagerCompat;
-//# sourceMappingURL=BleManagerCompatFactory.d.ts.map

package/lib/commonjs/BleManagerCompatFactory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BleManagerCompatFactory.d.ts","sourceRoot":"","sources":["../../src/BleManagerCompatFactory.ts"],"names":[],"mappings":"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"}