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

package/android/src/main/kotlin/co/zyke/ble/BleNitroBleManager.kt

@@ -57,6 +57,11 @@ class BleNitroBleManager(private val context: ReactApplicationContext) : HybridB
     private var logLevel: LogLevel = LogLevel.None
     private var isScanning = false
     private var scanCallback: ScanCallback? = null
+    
+    // State restoration
+    private var restoreIdentifier: String? = null
+    private var isInitialized = false
+    private var restoredState: BleRestoredState? = null
     private var scanListener: ((NativeBleError?, NativeDevice?) -> Unit)? = null
     private var stateChangeListener: ((State) -> Unit)? = null
     
@@ -100,6 +105,104 @@ class BleNitroBleManager(private val context: ReactApplicationContext) : HybridB
         }
     }
     
+    override fun initialize(options: BleManagerNitroOptions): Promise<Unit> = Promise.resolve {
+        options.restoreStateIdentifier?.let { restoreId ->
+            this.restoreIdentifier = restoreId
+            
+            // Attempt to restore previous state from SharedPreferences
+            restoreConnectionState(restoreId)
+            
+            Log.d(TAG, "BleNitro: Initialized with restore state identifier: $restoreId")
+        }
+        
+        this.isInitialized = true
+        Log.d(TAG, "BleNitro: BLE Manager initialized")
+        Unit
+    }
+    
+    override fun getRestoredState(): Promise<BleRestoredState?> = Promise.resolve {
+        restoredState
+    }
+    
+    private fun restoreConnectionState(restoreId: String) {
+        try {
+            val sharedPrefs = context.getSharedPreferences("BleNitro_$restoreId", Context.MODE_PRIVATE)
+            val connectedDevicesJson = sharedPrefs.getString("connected_devices", null)
+            
+            connectedDevicesJson?.let { json ->
+                // Parse stored device IDs and attempt to reconnect
+                val deviceIds = json.split(",").filter { it.isNotEmpty() }
+                
+                if (deviceIds.isNotEmpty()) {
+                    Log.d(TAG, "BleNitro: Restoring ${deviceIds.size} devices")
+                    
+                    deviceIds.forEach { deviceId ->
+                        // Attempt to reconnect to previously connected devices
+                        restoreDeviceConnection(deviceId)
+                    }
+                    
+                    // Store restored state (initially empty, will be populated as devices reconnect)
+                    val initialDevices = deviceIds.mapNotNull { deviceId ->
+                        bluetoothAdapter?.getRemoteDevice(deviceId)?.let { device ->
+                            createNativeDevice(device, null, -1) // Initial state without GATT
+                        }
+                    }
+                    
+                    if (initialDevices.isNotEmpty()) {
+                        this.restoredState = BleRestoredState(initialDevices)
+                        Log.d(TAG, "BleNitro: Stored restored state with ${initialDevices.size} devices")
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "BleNitro: Error restoring connection state", e)
+        }
+    }
+    
+    private fun restoreDeviceConnection(deviceId: String) {
+        try {
+            val bluetoothDevice = bluetoothAdapter?.getRemoteDevice(deviceId)
+            bluetoothDevice?.let { device ->
+                Log.d(TAG, "BleNitro: Attempting to restore connection to $deviceId")
+                
+                val gatt = device.connectGatt(context, true, object : BluetoothGattCallback() {
+                    override fun onConnectionStateChange(gatt: BluetoothGatt?, status: Int, newState: Int) {
+                        if (newState == BluetoothProfile.STATE_CONNECTED) {
+                            connectedDevices[deviceId] = gatt!!
+                            Log.d(TAG, "BleNitro: Successfully restored connection to $deviceId")
+                        } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
+                            Log.d(TAG, "BleNitro: Failed to restore connection to $deviceId")
+                            gatt?.close()
+                        }
+                    }
+                })
+                
+                if (gatt != null) {
+                    deviceCallbacks[deviceId] = gatt
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "BleNitro: Error restoring device connection for $deviceId", e)
+        }
+    }
+    
+    private fun saveConnectionState() {
+        restoreIdentifier?.let { restoreId ->
+            try {
+                val sharedPrefs = context.getSharedPreferences("BleNitro_$restoreId", Context.MODE_PRIVATE)
+                val deviceIds = connectedDevices.keys.joinToString(",")
+                
+                sharedPrefs.edit()
+                    .putString("connected_devices", deviceIds)
+                    .apply()
+                
+                Log.d(TAG, "BleNitro: Saved connection state for ${connectedDevices.size} devices")
+            } catch (e: Exception) {
+                Log.e(TAG, "BleNitro: Error saving connection state", e)
+            }
+        }
+    }
+    
     override fun setLogLevel(logLevel: LogLevel): Promise<LogLevel> = Promise.resolve {
         this.logLevel = logLevel
         logLevel

package/ios/BleNitroBleManager.swift

@@ -26,12 +26,28 @@ public class BleNitroBleManager: HybridBleManagerSpec, CBCentralManagerDelegate
     private var characteristicMonitors: [String: ((_ error: NativeBleError?, _ characteristic: NativeCharacteristic?) -> Void)] = [:]
     private var pendingOperations: [String: Any] = [:]
     
+    // State restoration
+    private var restoreIdentifier: String?
+    private var isInitialized = false
+    private var restoredState: BleRestoredState?
+    
     // MARK: - Initialization
     public override init() {
         super.init()
+        // Initialize with default options - will be reconfigured in initialize() method
         self.centralManager = CBCentralManager(delegate: self, queue: nil)
     }
     
+    private func reinitializeCentralManager() {
+        // Create CBCentralManager with state restoration if identifier is provided
+        var options: [String: Any] = [:]
+        if let restoreId = restoreIdentifier {
+            options[CBCentralManagerOptionRestoreIdentifierKey] = restoreId
+        }
+        
+        self.centralManager = CBCentralManager(delegate: self, queue: nil, options: options.isEmpty ? nil : options)
+    }
+    
     public override var memorySize: Int {
         return MemorySize.MemorySize_estimate(self)
     }
@@ -51,6 +67,29 @@ public class BleNitroBleManager: HybridBleManagerSpec, CBCentralManagerDelegate
         }
     }
     
+    public func initialize(options: BleManagerNitroOptions) throws -> Promise<Void> {
+        return Promise.resolve(withBlock: {
+            if let restoreId = options.restoreStateIdentifier {
+                // Store the restore identifier
+                self.restoreIdentifier = restoreId
+                
+                // Reinitialize the central manager with state restoration
+                self.reinitializeCentralManager()
+                
+                print("BleNitro: Initialized with restore state identifier: \(restoreId)")
+            }
+            
+            self.isInitialized = true
+            print("BleNitro: BLE Manager initialized")
+        })
+    }
+    
+    public func getRestoredState() throws -> Promise<BleRestoredState?> {
+        return Promise.resolve(withBlock: {
+            return self.restoredState
+        })
+    }
+    
     public func setLogLevel(logLevel: LogLevel) throws -> Promise<LogLevel> {
         return Promise.resolve(withBlock: {
             self.logLevel = logLevel
@@ -491,6 +530,40 @@ extension BleNitroBleManager: CBPeripheralDelegate {
             }
         }
     }
+    
+    // MARK: - CBCentralManagerDelegate State Restoration
+    
+    public func centralManager(_ central: CBCentralManager, willRestoreState dict: [String : Any]) {
+        // Handle state restoration
+        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey] as? [CBPeripheral] {
+            print("BleNitro: Restoring \(peripherals.count) peripherals")
+            
+            // Add restored peripherals to our connected devices
+            for peripheral in peripherals {
+                let deviceId = peripheral.identifier.uuidString
+                connectedDevices[deviceId] = peripheral
+                peripheral.delegate = self
+                
+                print("BleNitro: Restored peripheral: \(deviceId)")
+            }
+            
+            // Store restored state for later retrieval
+            if !peripherals.isEmpty {
+                let restoredDevices = peripherals.map(createNativeDevice)
+                self.restoredState = BleRestoredState(connectedPeripherals: restoredDevices)
+                print("BleNitro: Stored restored state with \(restoredDevices.count) devices")
+            }
+        }
+    }
+    
+    public func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        let newState = convertCBManagerStateToState(central.state)
+        
+        // Notify state change listener if available
+        stateChangeListener?(newState)
+        
+        print("BleNitro: Central manager state changed to: \(central.state.rawValue)")
+    }
 }
 
 /**

package/lib/BleManagerCompatFactory.d.ts

@@ -6,6 +6,7 @@
  */
 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
  */
@@ -13,13 +14,13 @@ export declare class BleManagerCompat {
     private bleManager;
     constructor(options?: BleManagerOptions);
     destroy(): Promise<void>;
-    setLogLevel(logLevel: LogLevel | string): Promise<string>;
-    logLevel(): Promise<string>;
+    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<string>;
-    onStateChange(listener: (newState: string) => void, emitCurrentState?: boolean): Subscription;
+    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>;
@@ -37,7 +38,8 @@ export declare class BleManagerCompat {
     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, transactionId?: TransactionId, subscriptionType?: 'notification' | 'indication'): Subscription;
+    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>;

package/lib/BleManagerCompatFactory.js

@@ -50,7 +50,8 @@ export class BleManagerCompat {
         }, emitCurrentState);
     }
     // Device scanning with compatibility wrappers
-    async startDeviceScan(uuids, options, listener) {
+    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);
         });
@@ -76,7 +77,8 @@ export class BleManagerCompat {
     async isDeviceConnected(deviceIdentifier) {
         return await this.bleManager.isDeviceConnected(deviceIdentifier);
     }
-    onDeviceDisconnected(deviceIdentifier, listener) {
+    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);
         });
@@ -125,7 +127,8 @@ export class BleManagerCompat {
     async writeCharacteristicWithoutResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId) {
         return await this.bleManager.writeCharacteristicWithoutResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId);
     }
-    monitorCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, listener, transactionId, subscriptionType) {
+    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;

package/lib/BleManagerFactory.d.ts

@@ -1,12 +1,30 @@
-import type { BleManager as BleManagerInterface } from './specs/BleManager.nitro';
-import type { BleManagerOptions } from './specs/types';
+import type { BleManager as BleManagerInterface } from './specs/BleManager.nitro.js';
+import type { BleManagerOptions } from './specs/types.js';
 /**
  * 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: any;
+export declare const BleManager: (options?: BleManagerOptions) => BleManagerInterface;

package/lib/BleManagerFactory.js

@@ -1,4 +1,6 @@
 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
@@ -9,10 +11,59 @@ export function createBleManager(options) {
         throw new Error('Failed to create BleManager: Nitro module not found. ' +
             'Make sure react-native-ble-nitro is properly installed and linked.');
     }
-    // If options are provided, we could initialize with them
-    // For now, we return the module directly as Nitro handles the native initialization
+    // 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'

package/lib/compatibility/constants.d.ts

@@ -46,4 +46,4 @@ export declare const ConnectionPriority: {
     readonly High: 1;
     readonly LowPower: 2;
 };
-export { BleErrorCode, BleATTErrorCode, BleIOSErrorCode, BleAndroidErrorCode } from '../specs/types';
+export { BleErrorCode, BleATTErrorCode, BleIOSErrorCode, BleAndroidErrorCode } from '../specs/types.js';

package/lib/compatibility/constants.js

@@ -47,4 +47,4 @@ export const ConnectionPriority = {
     LowPower: 2,
 };
 // Re-export all BLE error codes
-export { BleErrorCode, BleATTErrorCode, BleIOSErrorCode, BleAndroidErrorCode } from '../specs/types';
+export { BleErrorCode, BleATTErrorCode, BleIOSErrorCode, BleAndroidErrorCode } from '../specs/types.js';

package/lib/compatibility/deviceWrapper.d.ts

@@ -3,8 +3,8 @@
  *
  * Wraps Nitro Device objects to provide the original react-native-ble-plx API
  */
-import type { Device as NitroDevice } from '../specs/Device.nitro';
-import type { UUID, Base64, DeviceId, TransactionId, ConnectionPriority, ConnectionOptions, NativeService, NativeCharacteristic, NativeDescriptor, Subscription } from '../specs/types';
+import type { Device as NitroDevice } from '../specs/Device.nitro.js';
+import type { UUID, Base64, DeviceId, TransactionId, ConnectionPriority, ConnectionOptions, NativeService, NativeCharacteristic, NativeDescriptor, Subscription } from '../specs/types.js';
 /**
  * Device wrapper that provides react-native-ble-plx compatibility
  * Maps Nitro device properties to the expected API surface

package/lib/compatibility/deviceWrapper.js

@@ -3,8 +3,8 @@
  *
  * Wraps Nitro Device objects to provide the original react-native-ble-plx API
  */
-import { serviceDataArrayToMap } from './serviceData';
-import { normalizeCharacteristicSubscriptionType } from './enums';
+import { serviceDataArrayToMap } from './serviceData.js';
+import { normalizeCharacteristicSubscriptionType } from './enums.js';
 /**
  * Device wrapper that provides react-native-ble-plx compatibility
  * Maps Nitro device properties to the expected API surface

package/lib/compatibility/enums.d.ts

@@ -1,43 +1,38 @@
 /**
- * Enum compatibility layer
+ * React Native BLE Plx Compatible Enums and Types
  *
- * Provides conversion between Nitro's numeric enums and the original
- * string-based enums from react-native-ble-plx
+ * These match the exact types from react-native-ble-plx for drop-in compatibility.
+ * This module provides conversion between Nitro's numeric enums and react-native-ble-plx types.
  */
-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;
+import { State as NitroState, LogLevel as NitroLogLevel, CharacteristicSubscriptionType as NitroCharacteristicSubscriptionType, RefreshGattMoment as NitroRefreshGattMoment } from '../specs/types.js';
+export declare enum State {
+    Unknown = "Unknown",
+    Resetting = "Resetting",
+    Unsupported = "Unsupported",
+    Unauthorized = "Unauthorized",
+    PoweredOff = "PoweredOff",
+    PoweredOn = "PoweredOn"
+}
+export declare enum LogLevel {
+    None = "None",
+    Verbose = "Verbose",
+    Debug = "Debug",
+    Info = "Info",
+    Warning = "Warning",
+    Error = "Error"
+}
+export type CharacteristicSubscriptionType = 'notification' | 'indication';
+export type RefreshGattMoment = 'OnConnected';
+export declare function stateToString(state: NitroState): State;
+export declare function logLevelToString(logLevel: NitroLogLevel): LogLevel;
+export declare function characteristicSubscriptionTypeToString(type: NitroCharacteristicSubscriptionType): CharacteristicSubscriptionType;
+export declare function refreshGattMomentToString(_moment: NitroRefreshGattMoment): RefreshGattMoment;
+export declare function stringToState(stateString: State | string): NitroState;
+export declare function stringToLogLevel(logLevelString: LogLevel | string): NitroLogLevel;
+export declare function stringToCharacteristicSubscriptionType(typeString: CharacteristicSubscriptionType | string): NitroCharacteristicSubscriptionType;
+export declare function stringToRefreshGattMoment(_momentString: RefreshGattMoment): NitroRefreshGattMoment;
+export declare function normalizeState(state: NitroState | State | string): NitroState;
+export declare function normalizeLogLevel(logLevel: NitroLogLevel | LogLevel | string): NitroLogLevel;
+export declare function normalizeCharacteristicSubscriptionType(type: NitroCharacteristicSubscriptionType | CharacteristicSubscriptionType | string): NitroCharacteristicSubscriptionType;
+export declare function normalizeRefreshGattMoment(_moment: NitroRefreshGattMoment | RefreshGattMoment | string): NitroRefreshGattMoment;
 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;