incyclist-devices 2.0.0-beta.1 → 2.0.1

package/lib/ble/{ble-comms.js → base/comms.js}

@@ -13,17 +13,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BleComms = void 0;
+const events_1 = __importDefault(require("events"));
 const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("./utils");
-const types_1 = require("./types");
-const ble_interface_1 = __importDefault(require("./ble-interface"));
+const utils_1 = require("../../utils/utils");
+const ble_interface_1 = __importDefault(require("../ble-interface"));
+const utils_2 = require("../utils");
 const CONNECT_WAIT_TIMEOUT = 10000;
 const BLE_TIMEOUT = 1000;
-class BleComms extends types_1.BleDeviceCommsClass {
+class BleComms extends events_1.default {
     constructor(props) {
         super();
         this.characteristics = [];
         this.deviceInfo = {};
+        this.connectState = { isConnecting: false, isConnected: false, isDisconnecting: false };
         this.id = props.id;
         this.address = props.address;
         this.name = props.name;
@@ -35,6 +37,7 @@ class BleComms extends types_1.BleDeviceCommsClass {
         this.writeQueue = [];
         this.workerIv = null;
         this.prevMessages = [];
+        this.paused = false;
         if (props.peripheral) {
             const { id, address, advertisement, state } = props.peripheral;
             this.peripheral = props.peripheral;
@@ -51,16 +54,37 @@ class BleComms extends types_1.BleDeviceCommsClass {
             this.logger = new gd_eventlog_1.EventLogger('BleDevice');
         }
     }
+    getConnectState() {
+        return this.connectState;
+    }
+    isConnected() {
+        return this.connectState.isConnected;
+    }
+    pause() {
+        this.paused = true;
+    }
+    resume() {
+        this.paused = false;
+    }
     getServiceUUids() {
         throw new Error("Method not implemented.");
     }
     getProfile() {
         throw new Error("Method not implemented.");
     }
+    getProtocol() {
+        throw new Error("Method not implemented.");
+    }
+    getSettings() {
+        const { id, address, name } = this;
+        return { id, name, address, interface: 'ble', protocol: this.getProtocol() };
+    }
     getServices() {
         return this.services;
     }
     logEvent(event) {
+        if (this.paused)
+            return;
         if (this.logger) {
             this.logger.logEvent(event);
         }
@@ -74,35 +98,49 @@ class BleComms extends types_1.BleDeviceCommsClass {
     setInterface(ble) {
         this.ble = ble;
     }
-    isMatching(characteristics) {
+    static isMatching(characteristics) {
         return true;
     }
     reset() {
+        if (this.connectState.isConnecting)
+            this.ble.stopConnectSensor();
     }
     cleanupListeners() {
         if (this.characteristics === undefined) {
             this.characteristics = [];
         }
         else {
-            const connector = this.ble.getConnector(this.peripheral);
-            this.characteristics.forEach(c => {
-                connector.removeAllListeners((0, utils_1.uuid)(c.uuid));
-            });
+            if (this.peripheral) {
+                const connector = this.ble.peripheralCache.getConnector(this.peripheral);
+                this.characteristics.forEach(c => {
+                    connector.removeAllListeners((0, utils_2.uuid)(c.uuid));
+                });
+            }
+            else {
+                this.characteristics = [];
+            }
         }
     }
     onDisconnect() {
-        this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
-        this.state = "disconnected";
-        if (!this.connectState.isDisconnecting) {
-            this.peripheral.state = 'disconnected';
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
+            this.state = "disconnected";
+            const wasConnecting = this.connectState.isConnecting;
             this.connectState.isConnecting = false;
             this.connectState.isConnected = false;
-            this.cleanupListeners();
-            this.subscribedCharacteristics = [];
-            this.ble.onDisconnect(this.peripheral);
-            this.connect({ reconnect: true });
-        }
-        this.emit('disconnected');
+            if (!this.connectState.isDisconnecting) {
+                this.peripheral.state = 'disconnected';
+                this.cleanupListeners();
+                this.subscribedCharacteristics = [];
+                this.ble.onDisconnect(this.peripheral);
+                if (wasConnecting) {
+                    this.emit('connection-failed');
+                }
+                else {
+                    this.connect({ reconnect: true });
+                }
+            }
+        });
     }
     waitForConnectFinished(timeout) {
         const waitStart = Date.now();
@@ -120,13 +158,13 @@ class BleComms extends types_1.BleDeviceCommsClass {
                     }
                 }
                 catch (err) {
-                    console.log('~~~ error', err);
+                    this.logEvent({ message: 'error', fn: '', error: err.message, stack: err.stack });
                 }
             }, 100);
         });
     }
     hasService(serviceUuid) {
-        return this.services && this.services.find(s => s === serviceUuid || (0, utils_1.uuid)(serviceUuid)) !== undefined;
+        return this.services && this.services.find(s => s === serviceUuid || (0, utils_2.uuid)(serviceUuid)) !== undefined;
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -145,27 +183,89 @@ class BleComms extends types_1.BleDeviceCommsClass {
     connectPeripheral(peripheral) {
         return __awaiter(this, void 0, void 0, function* () {
             this.connectState.isConnecting = true;
+            let disconnectSignalled = false;
+            return new Promise((done) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const connector = this.ble.peripheralCache.getConnector(peripheral);
+                    const disconnectHandler = () => {
+                        this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
+                        this.state = "disconnected";
+                        disconnectSignalled = true;
+                        this.cleanupListeners();
+                        this.subscribedCharacteristics = [];
+                        this.connectState.isConnecting = false;
+                        this.connectState.isConnected = false;
+                        this.ble.onDisconnect(this.peripheral);
+                        done(false);
+                    };
+                    connector.removeAllListeners('disconnect');
+                    connector.once('disconnect', disconnectHandler);
+                    yield connector.connect();
+                    if (disconnectSignalled)
+                        return;
+                    yield connector.initialize();
+                    if (disconnectSignalled)
+                        return;
+                    yield this.subscribeAll(connector);
+                    if (disconnectSignalled)
+                        return;
+                    this.connectState.isConnected = true;
+                    this.state = "connected";
+                    this.emit('connected');
+                    connector.removeAllListeners('disconnect');
+                    connector.on('disconnect', this.onDisconnect.bind(this));
+                    const success = yield this.init();
+                    done(success);
+                    return;
+                }
+                catch (err) {
+                    this.logEvent({ message: 'Error', fn: 'connectPeripheral()', error: err.message, stack: err.stack });
+                }
+                this.connectState.isConnecting = false;
+                if (disconnectSignalled)
+                    return;
+                done(true);
+            }));
+        });
+    }
+    subscribeMultiple(characteristics, conn) {
+        return new Promise(resolve => {
             try {
-                const connector = this.ble.getConnector(peripheral);
-                connector.on('disconnect', () => { this.onDisconnect(); });
-                yield connector.connect();
-                yield connector.initialize();
-                yield this.subscribeAll(connector);
-                this.connectState.isConnected = true;
-                this.state = "connected";
-                this.emit('connected');
-                yield this.init();
+                const connector = conn || this.ble.peripheralCache.getConnector(this.peripheral);
+                const subscribeSingle = (c) => {
+                    connector.removeAllListeners(c);
+                    connector.on(c, (uuid, data) => {
+                        this.onData(uuid, data);
+                    });
+                    return connector.subscribe(c).then(res => {
+                        this.subscribedCharacteristics.push(c);
+                        return res;
+                    }).catch(err => {
+                        this.logEvent({ message: 'subscription failed', characteristic: c, error: err.message });
+                    });
+                };
+                const promises = characteristics
+                    .filter(c => {
+                    if (this.characteristics) {
+                        const existing = this.characteristics.find(rc => rc.uuid === c || (0, utils_2.uuid)(rc.uuid) === c);
+                        if (!existing)
+                            return false;
+                    }
+                    const isAlreadySubscribed = connector.isSubscribed(c);
+                    return !isAlreadySubscribed;
+                })
+                    .map(c => subscribeSingle(c));
+                Promise.all(promises).then(() => resolve());
             }
             catch (err) {
-                this.logEvent({ message: 'Error', fn: 'connectPeripheral()', error: err.message, stack: err.stack });
+                this.logEvent({ message: 'Error', fn: 'subscribeMultiple()', error: err.message, stack: err.stack });
             }
-            this.connectState.isConnecting = false;
         });
     }
     subscribeAll(conn) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const connector = conn || this.ble.getConnector(this.peripheral);
+                const connector = conn || this.ble.peripheralCache.getConnector(this.peripheral);
                 const subscribed = yield connector.subscribeAll((uuid, data) => { this.onData(uuid, data); });
                 subscribed.forEach(c => this.subscribedCharacteristics.push(c));
             }
@@ -174,11 +274,28 @@ class BleComms extends types_1.BleDeviceCommsClass {
             }
         });
     }
+    unsubscribeAll(conn) {
+        const connector = conn || this.ble.peripheralCache.getConnector(this.peripheral);
+        connector.unsubscribeAll();
+    }
     connect(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.ble.isConnected()) {
+                try {
+                    yield this.ble.connect();
+                    if (!this.ble.isConnected())
+                        return false;
+                }
+                catch (err) {
+                    return false;
+                }
+            }
+            yield (0, utils_1.sleep)(Math.random() * 100);
+            yield this.ble.waitForSensorConnectionFinish();
+            this.ble.startConnectSensor();
             const { reconnect } = props || {};
             try {
-                this.logEvent({ message: reconnect ? 'reconnect' : 'connect', address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
+                this.logEvent({ message: reconnect ? 'reconnect' : 'connect', name: this.name, id: this.id, address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
                 if (!reconnect && this.connectState.isConnecting) {
                     yield this.waitForConnectFinished(CONNECT_WAIT_TIMEOUT);
                 }
@@ -189,27 +306,32 @@ class BleComms extends types_1.BleDeviceCommsClass {
                     }
                     catch (err) {
                         this.logEvent({ message: 'cannot reconnect', error: err.message || err });
+                        this.ble.stopConnectSensor();
                         return false;
                     }
+                    this.ble.stopConnectSensor();
                     return true;
                 }
                 this.connectState.isConnecting = true;
                 if (!this.peripheral) {
                     const { id, name, address } = this;
                     try {
-                        this.peripheral = this.ble.findPeripheral({ id, name, address });
+                        this.peripheral = this.ble.peripheralCache.getPeripheral({ id, name, address });
                     }
                     catch (err) {
-                        console.log('~~~ error', err);
+                        this.logEvent({ message: 'error', fn: 'connect()', error: err.message, stack: err.stack });
                     }
                 }
                 if (this.peripheral) {
                     const { id, address, advertisement } = this.peripheral;
                     const name = advertisement === null || advertisement === void 0 ? void 0 : advertisement.localName;
                     this.logEvent({ message: 'connect requested', mode: 'peripheral', device: { id, name, address: address } });
-                    yield this.connectPeripheral(this.peripheral);
-                    this.logEvent({ message: 'connect result: success', mode: 'peripheral', device: { id, name, address } });
-                    return true;
+                    const connected = yield this.connectPeripheral(this.peripheral);
+                    this.logEvent({ message: 'connect result: ', connected, mode: 'peripheral', device: { id, name, address } });
+                    this.connectState.isConnecting = false;
+                    this.connectState.isConnected = connected;
+                    this.ble.stopConnectSensor();
+                    return connected;
                 }
                 else {
                     const { id, name, address } = this;
@@ -220,24 +342,26 @@ class BleComms extends types_1.BleDeviceCommsClass {
                             if (this.ble.isScanning()) {
                                 yield this.ble.stopScan();
                             }
-                            const devices = yield this.ble.scan({ requested: this });
-                            if (devices && devices.length > 0) {
-                                this.peripheral = devices[0].peripheral;
-                                yield this.connectPeripheral(this.peripheral);
-                                this.logEvent({ message: 'connect result: success', mode: 'device', device: { id, name, address } });
+                            const peripheral = yield this.ble.scanForDevice(this, {}).catch(() => null);
+                            if (peripheral) {
+                                this.peripheral = peripheral;
+                                const connected = yield this.connectPeripheral(this.peripheral);
+                                this.logEvent({ message: 'connect result: ', connected, mode: 'device', device: { id, name, address } });
                                 this.connectState.isConnecting = false;
-                                this.connectState.isConnected = true;
-                                return true;
+                                this.connectState.isConnected = connected;
+                                this.ble.stopConnectSensor();
+                                return connected;
                             }
                         }
                         catch (err) {
-                            console.log('~~~ error', err);
+                            console.log('~~~ ERROR', err);
                             error = err;
                         }
                     }
                     this.logEvent({ message: 'connect result: failure', mode: 'device', device: { id, name, address }, error: error.message, stack: error.stack });
                     this.connectState.isConnecting = false;
                     this.connectState.isConnected = false;
+                    this.ble.stopConnectSensor();
                     return false;
                 }
             }
@@ -245,6 +369,7 @@ class BleComms extends types_1.BleDeviceCommsClass {
                 this.connectState.isConnecting = false;
                 this.connectState.isConnected = false;
                 this.logEvent({ message: 'connect result: error', error: err.message });
+                this.ble.stopConnectSensor();
                 return false;
             }
         });
@@ -273,8 +398,8 @@ class BleComms extends types_1.BleDeviceCommsClass {
                 return true;
             }
             if (this.connectState.isConnected) {
-                this.ble.removeConnectedDevice(this);
                 this.cleanupListeners();
+                this.unsubscribeAll();
                 this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
                 this.connectState.isDisconnecting = false;
                 this.connectState.isConnecting = false;
@@ -308,7 +433,7 @@ class BleComms extends types_1.BleDeviceCommsClass {
         }
         this.logEvent({ message: 'got data', characteristic, data: data.toString('hex'), writeQueue: this.writeQueue.length });
         if (this.writeQueue.length > 0) {
-            const writeIdx = this.writeQueue.findIndex(i => (0, utils_1.matches)(i.uuid, characteristic));
+            const writeIdx = this.writeQueue.findIndex(i => (0, utils_2.matches)(i.uuid, characteristic));
             if (writeIdx !== -1) {
                 const writeItem = this.writeQueue[writeIdx];
                 this.writeQueue.splice(writeIdx, 1);
@@ -354,13 +479,13 @@ class BleComms extends types_1.BleDeviceCommsClass {
                 throw new Error('not connected');
             try {
                 const { withoutResponse, timeout } = props || {};
-                const connector = this.ble.getConnector(this.peripheral);
+                const connector = this.ble.peripheralCache.getConnector(this.peripheral);
                 const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
                 if (!withoutResponse && !this.workerIv) {
                     this.startWorker();
                 }
                 if (!withoutResponse && !isAlreadySubscribed) {
-                    const connector = this.ble.getConnector(this.peripheral);
+                    const connector = this.ble.peripheralCache.getConnector(this.peripheral);
                     connector.removeAllListeners(characteristicUuid);
                     connector.on(characteristicUuid, (uuid, data) => {
                         this.onData(uuid, data);
@@ -370,7 +495,7 @@ class BleComms extends types_1.BleDeviceCommsClass {
                     this.subscribedCharacteristics.push(characteristicUuid);
                 }
                 return new Promise((resolve, reject) => {
-                    const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, utils_1.uuid)(c.uuid) === characteristicUuid);
+                    const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, utils_2.uuid)(c.uuid) === characteristicUuid);
                     if (!characteristic) {
                         reject(new Error('Characteristic not found'));
                         return;
@@ -414,7 +539,7 @@ class BleComms extends types_1.BleDeviceCommsClass {
         return new Promise((resolve, reject) => {
             if (!this.isConnected())
                 return reject(new Error('not connected'));
-            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, utils_1.uuid)(c.uuid) === characteristicUuid);
+            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, utils_2.uuid)(c.uuid) === characteristicUuid);
             if (!characteristic) {
                 reject(new Error('Characteristic not found'));
                 return;
@@ -454,3 +579,4 @@ class BleComms extends types_1.BleDeviceCommsClass {
     }
 }
 exports.BleComms = BleComms;
+BleComms.services = [];

package/lib/ble/bindings/index.d.ts

@@ -0,0 +1,2 @@
+import MockBinding from './mock';
+export { MockBinding };

package/lib/ble/bindings/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBinding = void 0;
+const mock_1 = __importDefault(require("./mock"));
+exports.MockBinding = mock_1.default;

package/lib/ble/bindings/linux.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { BleBinding, BleInterfaceState } from '../types';
+export declare class BleLinuxBinding extends EventEmitter implements BleBinding {
+    static _instance: any;
+    _bindings: any;
+    state: BleInterfaceState;
+    constructor();
+    static getInstance(): any;
+    startScanning(serviceUUIDs?: string[] | undefined, allowDuplicates?: boolean | undefined, callback?: ((error?: Error | undefined) => void) | undefined): void;
+    stopScanning(callback?: (() => void) | undefined): void;
+    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+}
+declare const Binding: any;
+export default Binding;

package/lib/ble/bindings/linux.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleLinuxBinding = void 0;
+const events_1 = __importDefault(require("events"));
+class BleLinuxBinding extends events_1.default {
+    constructor() {
+        super();
+        this.state = 'unknown';
+        this._bindings = this;
+    }
+    static getInstance() {
+        if (!BleLinuxBinding._instance) {
+            BleLinuxBinding._instance = new BleLinuxBinding();
+        }
+        return BleLinuxBinding._instance;
+    }
+    startScanning(serviceUUIDs, allowDuplicates, callback) {
+        throw new Error('Method not implemented.');
+    }
+    stopScanning(callback) {
+        throw new Error('Method not implemented.');
+    }
+    on(eventName, listener) {
+        super.addListener(eventName, listener);
+        if (eventName === 'stateChange') {
+            setTimeout(() => {
+                this.state = 'poweredOn';
+                this.emit('stateChange', this.state);
+            }, 100);
+        }
+        return this;
+    }
+}
+exports.BleLinuxBinding = BleLinuxBinding;
+const Binding = BleLinuxBinding.getInstance();
+exports.default = Binding;

package/lib/ble/bindings/mock.d.ts

@@ -0,0 +1,9 @@
+import { PrimaryService } from './types';
+export type BleMockPeripheral = {
+    services: PrimaryService[];
+    id: string;
+    name: string;
+    address: string;
+};
+declare const mock: any;
+export default mock;

package/lib/ble/bindings/mock.js

@@ -0,0 +1,108 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+const utils_1 = require("../../utils/utils");
+class Binding extends events_1.default {
+    constructor() {
+        super();
+        this._bindings = this;
+        this.state = 'unknown';
+        this.channelState = 'IDLE';
+        this.peripherals = [];
+    }
+    static getInstance() {
+        if (!Binding._instance) {
+            Binding._instance = new Binding();
+        }
+        return Binding._instance;
+    }
+    init() { }
+    addMock(peripheral) {
+        this.peripherals.push(peripheral);
+    }
+    reset() {
+        this.peripherals = [];
+        this.state = 'unknown';
+        this.channelState = 'IDLE';
+    }
+    on(eventName, listener) {
+        super.addListener(eventName, listener);
+        if (eventName === 'stateChange') {
+            setTimeout(() => {
+                this.state = 'poweredOn';
+                this.emit('stateChange', this.state);
+            }, 100);
+        }
+        return this;
+    }
+    startScanning(serviceUUIDs, allowDuplicates, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.channelState = 'SCANNING';
+            if (callback)
+                callback();
+            yield (0, utils_1.sleep)(50);
+            this.peripherals.forEach(p => {
+                this.emit('discover', new MockPeripheral(p));
+            });
+        });
+    }
+    stopScanning(callback) {
+        this.channelState = 'IDLE';
+        if (callback)
+            callback();
+    }
+}
+class MockPeripheral extends events_1.default {
+    constructor(p) {
+        super();
+        this.id = p.id;
+        this.name = p.name;
+        this.address = p.address;
+        this.advertisement = {
+            localName: p.name,
+            serviceUuids: p.services.map(s => s.uuid)
+        };
+        this.services = p.services;
+    }
+    connectAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    disconnect(cb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.removeAllListeners();
+        });
+    }
+    discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs, characteristicUUIDs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const characteristics = [];
+            this.services.forEach(s => {
+                if (serviceUUIDs && serviceUUIDs.length > 0 && !serviceUUIDs.includes(s.uuid))
+                    return;
+                s.characteristics.forEach(c => {
+                    var _a, _b;
+                    if (characteristicUUIDs && characteristicUUIDs.length > 0 && !characteristicUUIDs.includes(c.uuid))
+                        return;
+                    c._serviceUuid = s.uuid;
+                    c.name = (_b = (_a = c.descriptors) === null || _a === void 0 ? void 0 : _a.find(d => d.uuid === '2901')) === null || _b === void 0 ? void 0 : _b.value;
+                    characteristics.push(c);
+                });
+            });
+            return { services: this.services, characteristics };
+        });
+    }
+}
+const mock = Binding.getInstance();
+exports.default = mock;

package/lib/ble/bindings/types.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import EventEmitter from "events";
+import { BleCharacteristic } from "../types";
+export type Property = 'read' | 'write' | 'notify' | 'indicate';
+export type Descriptor = {
+    uuid: string;
+    value: string | Buffer;
+};
+export type Characteristic = {
+    uuid: string;
+    properties: Property[];
+    secure?: boolean;
+    value: Buffer;
+    descriptors: Descriptor[];
+};
+export declare const RESULT_SUCCESS = 0;
+export declare const RESULT_INVALID_OFFSET = 7;
+export declare const RESULT_ATTR_NOT_LONG = 11;
+export declare const RESULT_INVALID_ATTRIBUTE_LENGTH = 13;
+export declare const RESULT_UNLIKELY_ERROR = 14;
+export declare class MockCharacteristic extends EventEmitter implements BleCharacteristic {
+    uuid: string;
+    properties: Property[];
+    secure?: boolean | undefined;
+    value: Buffer;
+    descriptors: Descriptor[];
+    subscribe(callback: (err: Error | undefined) => void): void;
+    unsubscribe(callback: (err: Error | undefined) => void): void;
+    read(callback: (err: Error | undefined, data: Buffer) => void): void;
+    write(data: Buffer, withoutResponse: boolean, callback?: ((err: Error | undefined) => void) | undefined): void;
+}
+export declare class StaticReadCharacteristic extends MockCharacteristic {
+    constructor(uuid: string, description: string, value: any);
+    read(callback: (err: Error | undefined, data: Buffer) => void): void;
+}
+export declare class StaticWriteCharacteristic extends MockCharacteristic {
+    size: number;
+    constructor(uuid: string, description: string, size: number);
+    write(data: Buffer, withoutResponse: boolean, callback?: (err?: Error) => void): void;
+}
+export declare abstract class StaticNotifyCharacteristic extends MockCharacteristic {
+    cntSubscriptions: number;
+    iv: NodeJS.Timer;
+    notifyFrequency: number;
+    constructor(uuid: string, description: string);
+    subscribe(callback: (err: Error | undefined) => void): void;
+    unsubscribe(callback: (err: Error | undefined) => void): void;
+    abstract notify(): void;
+    startNotify(): void;
+    stopNotify(): void;
+}
+export type PrimaryService = {
+    uuid: string;
+    characteristics: Characteristic[];
+};