react-native-ble-nitro 1.0.0-alpha.1

package/lib/compatibility/enums.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Enum compatibility layer
+ *
+ * Provides conversion between Nitro's numeric enums and the original
+ * string-based enums from react-native-ble-plx
+ */
+import { State, LogLevel, CharacteristicSubscriptionType, RefreshGattMoment } from '../specs/types';
+export declare const StateString: {
+    readonly 0: "Unknown";
+    readonly 1: "Resetting";
+    readonly 2: "Unsupported";
+    readonly 3: "Unauthorized";
+    readonly 4: "PoweredOff";
+    readonly 5: "PoweredOn";
+};
+export declare const LogLevelString: {
+    readonly 0: "None";
+    readonly 1: "Verbose";
+    readonly 2: "Debug";
+    readonly 3: "Info";
+    readonly 4: "Warning";
+    readonly 5: "Error";
+};
+export declare const CharacteristicSubscriptionTypeString: {
+    readonly 0: "notification";
+    readonly 1: "indication";
+};
+export declare const RefreshGattMomentString: {
+    readonly 0: "OnConnected";
+};
+export declare function stateToString(state: State): string;
+export declare function stringToState(stateString: string): State;
+export declare function logLevelToString(logLevel: LogLevel): string;
+export declare function stringToLogLevel(logLevelString: string): LogLevel;
+export declare function characteristicSubscriptionTypeToString(type: CharacteristicSubscriptionType): string;
+export declare function stringToCharacteristicSubscriptionType(typeString: string): CharacteristicSubscriptionType;
+export declare function refreshGattMomentToString(moment: RefreshGattMoment): 'OnConnected';
+export declare function stringToRefreshGattMoment(momentString: 'OnConnected'): RefreshGattMoment;
+export declare function isStringEnumValue(value: any): boolean;
+export declare function normalizeState(state: State | string): State;
+export declare function normalizeLogLevel(logLevel: LogLevel | string): LogLevel;
+export declare function normalizeCharacteristicSubscriptionType(type: CharacteristicSubscriptionType | 'notification' | 'indication'): CharacteristicSubscriptionType;
+export declare function normalizeRefreshGattMoment(moment: RefreshGattMoment | 'OnConnected'): RefreshGattMoment;

package/lib/compatibility/enums.js

@@ -0,0 +1,124 @@
+/**
+ * Enum compatibility layer
+ *
+ * Provides conversion between Nitro's numeric enums and the original
+ * string-based enums from react-native-ble-plx
+ */
+import { State, LogLevel, CharacteristicSubscriptionType, RefreshGattMoment, } from '../specs/types';
+// String mappings for backward compatibility
+export const StateString = {
+    [State.Unknown]: 'Unknown',
+    [State.Resetting]: 'Resetting',
+    [State.Unsupported]: 'Unsupported',
+    [State.Unauthorized]: 'Unauthorized',
+    [State.PoweredOff]: 'PoweredOff',
+    [State.PoweredOn]: 'PoweredOn',
+};
+export const LogLevelString = {
+    [LogLevel.None]: 'None',
+    [LogLevel.Verbose]: 'Verbose',
+    [LogLevel.Debug]: 'Debug',
+    [LogLevel.Info]: 'Info',
+    [LogLevel.Warning]: 'Warning',
+    [LogLevel.Error]: 'Error',
+};
+export const CharacteristicSubscriptionTypeString = {
+    [CharacteristicSubscriptionType.Notification]: 'notification',
+    [CharacteristicSubscriptionType.Indication]: 'indication',
+};
+export const RefreshGattMomentString = {
+    [RefreshGattMoment.OnConnected]: 'OnConnected',
+};
+// Reverse mappings for converting strings back to numeric enums
+const StringToState = {};
+const StringToLogLevel = {};
+const StringToCharacteristicSubscriptionType = {};
+const StringToRefreshGattMoment = {};
+// Build reverse mappings
+Object.entries(StateString).forEach(([num, str]) => {
+    StringToState[str] = parseInt(num);
+});
+Object.entries(LogLevelString).forEach(([num, str]) => {
+    StringToLogLevel[str] = parseInt(num);
+});
+Object.entries(CharacteristicSubscriptionTypeString).forEach(([num, str]) => {
+    StringToCharacteristicSubscriptionType[str] = parseInt(num);
+});
+Object.entries(RefreshGattMomentString).forEach(([num, str]) => {
+    StringToRefreshGattMoment[str] = parseInt(num);
+});
+// Conversion functions
+export function stateToString(state) {
+    return StateString[state] ?? 'Unknown';
+}
+export function stringToState(stateString) {
+    // Handle case insensitive lookup
+    const lowerString = stateString.toLowerCase();
+    for (const [key, value] of Object.entries(StringToState)) {
+        if (key.toLowerCase() === lowerString) {
+            return value;
+        }
+    }
+    return State.Unknown;
+}
+export function logLevelToString(logLevel) {
+    return LogLevelString[logLevel] ?? 'None';
+}
+export function stringToLogLevel(logLevelString) {
+    // Handle case insensitive lookup
+    const lowerString = logLevelString.toLowerCase();
+    for (const [key, value] of Object.entries(StringToLogLevel)) {
+        if (key.toLowerCase() === lowerString) {
+            return value;
+        }
+    }
+    return LogLevel.None;
+}
+export function characteristicSubscriptionTypeToString(type) {
+    return CharacteristicSubscriptionTypeString[type] ?? 'notification';
+}
+export function stringToCharacteristicSubscriptionType(typeString) {
+    // Handle case insensitive lookup
+    const lowerString = typeString.toLowerCase();
+    for (const [key, value] of Object.entries(StringToCharacteristicSubscriptionType)) {
+        if (key.toLowerCase() === lowerString) {
+            return value;
+        }
+    }
+    return CharacteristicSubscriptionType.Notification;
+}
+export function refreshGattMomentToString(moment) {
+    return RefreshGattMomentString[moment];
+}
+export function stringToRefreshGattMoment(momentString) {
+    return StringToRefreshGattMoment[momentString] ?? RefreshGattMoment.OnConnected;
+}
+// Helper function to detect if a value is a string enum vs numeric enum
+export function isStringEnumValue(value) {
+    return typeof value === 'string';
+}
+// Generic converter that handles both string and numeric enum values
+export function normalizeState(state) {
+    if (typeof state === 'string') {
+        return stringToState(state);
+    }
+    return state;
+}
+export function normalizeLogLevel(logLevel) {
+    if (typeof logLevel === 'string') {
+        return stringToLogLevel(logLevel);
+    }
+    return logLevel;
+}
+export function normalizeCharacteristicSubscriptionType(type) {
+    if (typeof type === 'string') {
+        return stringToCharacteristicSubscriptionType(type);
+    }
+    return type;
+}
+export function normalizeRefreshGattMoment(moment) {
+    if (typeof moment === 'string') {
+        return stringToRefreshGattMoment(moment);
+    }
+    return moment;
+}

package/lib/compatibility/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Compatibility layer for react-native-ble-nitro
+ *
+ * This module provides compatibility shims and converters to maintain
+ * 100% API compatibility with react-native-ble-plx while working with
+ * Nitro's type system constraints.
+ */
+export * from './serviceData';
+export * from './deviceWrapper';
+export * from './constants';
+export { stateToString, stringToState, logLevelToString, stringToLogLevel, characteristicSubscriptionTypeToString, stringToCharacteristicSubscriptionType, normalizeState, normalizeLogLevel, normalizeCharacteristicSubscriptionType, } from './enums';

package/lib/compatibility/index.js

@@ -0,0 +1,12 @@
+/**
+ * Compatibility layer for react-native-ble-nitro
+ *
+ * This module provides compatibility shims and converters to maintain
+ * 100% API compatibility with react-native-ble-plx while working with
+ * Nitro's type system constraints.
+ */
+export * from './serviceData';
+export * from './deviceWrapper';
+export * from './constants';
+// Explicitly export enum utilities to avoid conflicts
+export { stateToString, stringToState, logLevelToString, stringToLogLevel, characteristicSubscriptionTypeToString, stringToCharacteristicSubscriptionType, normalizeState, normalizeLogLevel, normalizeCharacteristicSubscriptionType, } from './enums';

package/lib/compatibility/serviceData.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Service Data compatibility layer
+ *
+ * Provides conversion between Nitro's structured ServiceDataEntry[] format
+ * and the original { [uuid: string]: Base64 } format from react-native-ble-plx
+ */
+import type { ServiceDataEntry, UUID, Base64 } from '../specs/types';
+/**
+ * Convert ServiceDataEntry array to the original index signature format
+ */
+export declare function serviceDataArrayToMap(entries: ServiceDataEntry[] | null): {
+    [uuid: string]: Base64;
+} | null;
+/**
+ * Convert the original index signature format to ServiceDataEntry array
+ */
+export declare function serviceDataMapToArray(map: {
+    [uuid: string]: Base64;
+} | null): ServiceDataEntry[] | null;
+/**
+ * Merge two service data maps (used in device updates)
+ */
+export declare function mergeServiceDataMaps(existing: {
+    [uuid: string]: Base64;
+} | null, updates: {
+    [uuid: string]: Base64;
+} | null): {
+    [uuid: string]: Base64;
+} | null;
+/**
+ * Merge two service data arrays (used in native updates)
+ */
+export declare function mergeServiceDataArrays(existing: ServiceDataEntry[] | null, updates: ServiceDataEntry[] | null): ServiceDataEntry[] | null;
+/**
+ * Check if service data contains a specific service UUID
+ */
+export declare function hasServiceUUID(serviceData: {
+    [uuid: string]: Base64;
+} | null, uuid: UUID): boolean;
+/**
+ * Get service data for a specific UUID
+ */
+export declare function getServiceData(serviceData: {
+    [uuid: string]: Base64;
+} | null, uuid: UUID): Base64 | null;
+/**
+ * Get all service UUIDs from service data
+ */
+export declare function getServiceUUIDs(serviceData: {
+    [uuid: string]: Base64;
+} | null): UUID[];

package/lib/compatibility/serviceData.js

@@ -0,0 +1,70 @@
+/**
+ * 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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,120 @@
+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/index.d.ts

@@ -0,0 +1,7 @@
+export * from './compatibility/constants';
+export * from './utils';
+export { BleManagerCompat as BleManager, createBleManagerCompat as createBleManager } from './BleManagerCompatFactory';
+export * from './errors/BleError';
+export { DeviceWrapper as Device } from './compatibility/deviceWrapper';
+export type { BleManagerOptions, ScanOptions, ConnectionOptions, NativeBleError, NativeDevice, NativeService, NativeCharacteristic, NativeDescriptor, Subscription } from './specs/types';
+export { fullUUID } from './utils/uuid';

package/lib/index.js

@@ -0,0 +1,12 @@
+// Export compatibility layer types and constants
+export * from './compatibility/constants';
+// Export utility functions
+export * from './utils';
+// Export the main BleManager instance with compatibility wrapper
+export { BleManagerCompat as BleManager, createBleManagerCompat as createBleManager } from './BleManagerCompatFactory';
+// Export error handling utilities
+export * from './errors/BleError';
+// Export device wrapper for compatibility
+export { DeviceWrapper as Device } from './compatibility/deviceWrapper';
+// Re-export react-native-ble-plx compatible API
+export { fullUUID } from './utils/uuid';

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

@@ -0,0 +1,36 @@
+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 BleManager extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    destroy(): Promise<void>;
+    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

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

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

@@ -0,0 +1,26 @@
+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

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

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

@@ -0,0 +1,17 @@
+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

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

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

@@ -0,0 +1,37 @@
+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

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