incyclist-devices 1.5.38 → 2.0.0-beta.1

package/lib/{daum/classic/DaumClassicAdapter.js → serial/daum/classic/adapter.js}

@@ -13,14 +13,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("../../utils");
+const utils_1 = require("../../../utils/utils");
 const DaumAdapter_1 = __importDefault(require("../DaumAdapter"));
-const DaumClassicCyclingMode_1 = __importDefault(require("./DaumClassicCyclingMode"));
+const daum_classic_1 = __importDefault(require("./modes/daum-classic"));
+const comms_1 = __importDefault(require("./comms"));
+const serial_interface_1 = __importDefault(require("../../serial-interface"));
 const PROTOCOL_NAME = "Daum Classic";
+const DEFAULT_GEAR = 10;
+const getBikeProps = (props) => {
+    const { port, interface: ifaceName } = props;
+    let serial;
+    if (ifaceName && typeof ifaceName === 'string') {
+        serial = serial_interface_1.default.getInstance({ ifaceName });
+    }
+    else {
+        serial = props.interface;
+    }
+    if (!serial || !serial.binding)
+        throw new Error(`unknonwn interface: ${ifaceName}`);
+    const path = `${port}`;
+    return { serial, path };
+};
 class DaumClassicAdapter extends DaumAdapter_1.default {
-    constructor(protocol, bike) {
-        super(protocol, bike);
-        this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
+    constructor(settings, props) {
+        super(settings, props);
+        const logger = new gd_eventlog_1.EventLogger('DaumClassic');
+        const commProps = Object.assign(Object.assign({}, getBikeProps(settings)), { logger });
+        this.bike = new comms_1.default(commProps);
+        this.logger = logger;
         this.name = PROTOCOL_NAME;
         this.ignoreHrm = false;
         this.ignorePower = false;
@@ -28,8 +48,6 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         this.paused = undefined;
         this.iv = undefined;
         this.distanceInternal = undefined;
-        this.udid = Date.now();
-        this.logger.logEvent({ message: 'Device created', udid: this.udid, port: this.getPort() });
         this.initData();
     }
     setID(id) {
@@ -47,13 +65,51 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
     getPort() {
         return this.bike.getPort();
     }
+    getProtocolName() {
+        return PROTOCOL_NAME;
+    }
     getSupportedCyclingModes() {
         const supported = super.getSupportedCyclingModes();
-        supported.push(DaumClassicCyclingMode_1.default);
+        supported.push(daum_classic_1.default);
         return supported;
     }
     getDefaultCyclingMode() {
-        return new DaumClassicCyclingMode_1.default(this);
+        return new daum_classic_1.default(this);
+    }
+    check() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var info = {};
+            if (this.isStopped())
+                return false;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.logger.logEvent({ message: "checking device", port: this.getPort() });
+                const iv = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    this.logger.logEvent({ message: "checking device failed", port: this.getPort(), reason: 'timeout' });
+                    resolve(false);
+                }), 5000);
+                try {
+                    const connected = yield this.connect();
+                    if (!connected) {
+                        clearTimeout(iv);
+                        resolve(false);
+                    }
+                    const address = (yield this.bike.getAddress()) || {};
+                    info.bikeNo = address.bike;
+                    const version = (yield this.bike.getVersion()) || {};
+                    info.serialNo = version.serialNo;
+                    info.cockpit = version.cockpit;
+                    this.setName('Daum ' + info.cockpit);
+                    this.setID(info.serialNo);
+                    clearTimeout(iv);
+                    this.logger.logEvent({ message: "checking device success", port: this.getPort(), info });
+                    resolve(true);
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: "checking device failed", port: this.getPort(), reason: err.message || err });
+                    resolve(false);
+                }
+            }));
+        });
     }
     pause() {
         const _super = Object.create(null, {
@@ -75,41 +131,15 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             return resumed;
         });
     }
-    check() {
-        var info = {};
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: "check()", port: this.getPort() });
-            const iv = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                reject(new Error(`timeout`));
-            }), 5000);
-            try {
-                if (!this.bike.isConnected())
-                    yield this.bike.saveConnect();
-                const address = (yield this.bike.getAddress()) || {};
-                info.bikeNo = address.bike;
-                const version = (yield this.bike.getVersion()) || {};
-                info.serialNo = version.serialNo;
-                info.cockpit = version.cockpit;
-                this.setName('Daum ' + info.cockpit);
-                this.setID(info.serialNo);
-                clearTimeout(iv);
-                resolve(info);
-            }
-            catch (err) {
-                clearTimeout(iv);
-                reject(err);
-            }
-        }));
-    }
     startRide(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'relaunch of device', udid: this.udid });
+            this.logger.logEvent({ message: 'relaunch of device' });
             return yield this.launch(props, true);
         });
     }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'initial start of device', udid: this.udid });
+            this.logger.logEvent({ message: 'initial start of device' });
             return yield this.launch(props, false);
         });
     }
@@ -118,38 +148,35 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             try {
                 if (isRelaunch) {
                     yield this.stop();
-                    this.bike.connected = true;
                 }
                 yield this.performStart(props, isRelaunch);
                 if (!isRelaunch) {
                     try {
                         const version = yield this.bike.getVersion();
                         const { serialNo, cockpit } = version || {};
-                        this.logEvent({ message: 'device info', deviceInfo: { serialNo, cockpit }, udid: this.udid });
+                        this.logEvent({ message: 'device info', deviceInfo: { serialNo, cockpit } });
                     }
                     catch (_a) { }
                 }
-                this.logger.logEvent({ message: 'start result: success', udid: this.udid });
+                this.logger.logEvent({ message: 'start result: success' });
                 return true;
             }
             catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message, udid: this.udid });
+                this.logger.logEvent({ message: 'start result: error', error: err.message });
                 throw new Error(`could not start device, reason:${err.message}`);
             }
         });
     }
     performStart(props = {}, isRelaunch = false) {
-        this.stop();
-        const { user, bikeSettings } = props;
-        if (user && user.weight)
-            this.userSettings.weight = user.weight;
-        if (bikeSettings && bikeSettings.weight)
-            this.bikeSettings.weight = bikeSettings.weight;
+        this.stopUpdatePull();
+        this.setBikeProps(props);
+        const user = this.user;
+        const { gear = DEFAULT_GEAR } = props;
         this.initData();
         let startState = {};
         return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
             try {
-                this.logger.logEvent({ message: 'start attempt', udid: this.udid, isRelaunch, isConnected: this.bike.isConnected() });
+                this.logger.logEvent({ message: 'start attempt', isRelaunch, isConnected: this.bike.isConnected() });
                 if (!isRelaunch && !this.bike.isConnected())
                     yield this.bike.saveConnect();
                 yield this.getBike().resetDevice();
@@ -171,7 +198,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                     startState.startProg = true;
                 }
                 if (!startState.setGear) {
-                    yield this.bike.setGear(this.cyclingData.gear || (props.gear || 10));
+                    yield this.bike.setGear(this.cyclingData.gear || gear);
                     startState.setGear = true;
                 }
                 const startRequest = this.getCyclingMode().getBikeInitRequest();
@@ -187,7 +214,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                 return data;
             }
             catch (err) {
-                this.logger.logEvent({ message: 'start attempt failed', udid: this.udid, error: err.message });
+                this.logger.logEvent({ message: 'start attempt failed', error: err.message });
                 if (startState.checkRunData) {
                     startState = {};
                 }

package/lib/{daum/classic/bike.d.ts → serial/daum/classic/comms.d.ts}

@@ -1,8 +1,10 @@
 import { EventLogger } from 'gd-eventlog';
-import { Queue } from '../../utils';
-import { User } from '../../types/user';
-declare type SuccessCallbackFn = (data: any) => void;
-declare type ErrorCallbackFn = (status: number, error: any) => void;
+import { Queue } from '../../../utils/utils';
+import { User } from '../../../types/user';
+import { SerialInterface, SerialPortProvider } from '../..';
+import { SerialCommProps } from '../../comm';
+type SuccessCallbackFn = (data: any) => void;
+type ErrorCallbackFn = (status: number, error: any) => void;
 interface CommandInstructions {
     logStr: string;
     payload: Array<number>;
@@ -14,8 +16,6 @@ interface CommandInstructions {
 export default class Daum8008 {
     logger: EventLogger;
     portName: string;
-    settings: any;
-    bikeData: any;
     sp: any;
     error: Error;
     opening: boolean;
@@ -28,7 +28,10 @@ export default class Daum8008 {
     cmdStart: number;
     cmdCurrent: any;
     isLoggingPaused: boolean;
-    constructor(opts?: any);
+    spp: SerialPortProvider;
+    serial: SerialInterface;
+    _timeoutSend: number;
+    constructor(props: SerialCommProps);
     static setSerialPort(spClass: any): void;
     static getClassName(): string;
     getType(): string;
@@ -37,15 +40,10 @@ export default class Daum8008 {
     pauseLogging(): void;
     resumLogging(): void;
     logEvent(e: any): void;
-    setUser(user: User, callback: any): void;
-    getUserWeight(): number;
-    getBikeWeight(): any;
-    connect(): void;
-    saveConnect(): Promise<unknown>;
-    close(): void;
-    saveClose(): Promise<unknown>;
-    onPortOpen(): void;
-    onPortClose(): void;
+    connect(): Promise<boolean>;
+    close(): Promise<void>;
+    flush(): Promise<void>;
+    onPortClose(): Promise<void>;
     onPortError(err: any): void;
     startWorker(): void;
     stopWorker(): void;

package/lib/{daum/classic/bike.js → serial/daum/classic/comms.js}

@@ -1,24 +1,31 @@
 "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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("./utils");
-const utils_2 = require("../../utils");
+const utils_2 = require("../../../utils/utils");
+const __1 = require("../..");
 const ByteLength = require('@serialport/parser-byte-length');
 const nop = () => { };
 const TIMEOUT_START = 15000;
 const TIMEOUT_CLOSE = 5000;
 const TIMEOUT_SEND = 2000;
-var __SerialPort = undefined;
 class Daum8008 {
-    constructor(opts = {}) {
-        this.logger = opts.logger || new gd_eventlog_1.EventLogger('DaumClassic');
-        this.portName = opts.port || process.env.COM_PORT;
-        this.settings = opts.settings || {};
-        this.bikeData = {
-            userWeight: utils_1.DEFAULT_USER_WEIGHT,
-            bikeWeight: utils_1.DEFAULT_BIKE_WEIGHT,
-            maxPower: 800
-        };
+    constructor(props) {
+        this._timeoutSend = TIMEOUT_SEND;
+        const { logger, serial, path } = props;
+        this.logger = logger || new gd_eventlog_1.EventLogger('DaumClassic');
+        this.portName = path;
+        this.serial = serial;
+        this.spp = (0, __1.useSerialPortProvider)();
         this.sp = undefined;
         this.error = undefined;
         this.opening = false;
@@ -30,7 +37,7 @@ class Daum8008 {
         this.isLoggingPaused = false;
     }
     static setSerialPort(spClass) {
-        __SerialPort = spClass;
+        __1.SerialPortProvider.getInstance().setLegacyClass('serial', spClass);
     }
     static getClassName() {
         return "Daum8008";
@@ -54,161 +61,72 @@ class Daum8008 {
         if (!this.isLoggingPaused)
             this.logger.logEvent(e);
     }
-    setUser(user, callback) {
-        this.logEvent({ message: "setUser()", user });
-        if (user)
-            this.settings.user = user;
-        var cb = callback || nop;
-        cb(200, user);
-    }
-    getUserWeight() {
-        if (this.settings && this.settings.user && this.settings.user.weight)
-            return (0, utils_1.getWeight)(this.settings.user.weight);
-        else
-            return (0, utils_1.getWeight)();
-    }
-    getBikeWeight() {
-        if (this.settings && this.settings.weight) {
-            let m = this.settings.weight;
-            if (m > 0 && m < 20)
-                return m;
-        }
-        return 10;
-    }
     connect() {
-        this.logEvent({ message: "connect()", port: this.getPort(), isConnected: this.connected, sp: (this.sp !== undefined), });
-        if (this.closing || this.opening) {
-            return;
-        }
-        if (this.connected)
-            return;
-        try {
-            if (this.sp === undefined) {
-                const settings = this.settings.port || {};
-                settings.autoOpen = false;
-                this.sp = new __SerialPort(this.portName, settings);
-                this.sp.on('open', () => { this.onPortOpen(); });
-                this.sp.on('close', () => { this.onPortClose(); });
-                this.sp.on('error', (error) => { this.onPortError(error); });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected() && this.sp) {
+                return true;
             }
-            this.cmdBusy = true;
-            this.opening = true;
-            this.closed = undefined;
-            this.sp.open();
-        }
-        catch (err) {
-            this.logEvent({ message: "startTraining:error:", error: err.message });
-        }
-    }
-    saveConnect() {
-        return new Promise((resolve, reject) => {
-            if (this.isConnected()) {
-                this.opening = false;
-                return resolve(true);
-            }
-            this.connect();
-            const timeoutStart = this.settings.timeoutStart || TIMEOUT_START;
-            const tTimeout = Date.now() + timeoutStart;
-            const iv = setInterval(() => {
-                if (this.isConnected()) {
-                    clearInterval(iv);
-                    this.opening = false;
-                    resolve(true);
+            try {
+                const port = yield this.serial.openPort(this.portName);
+                if (port !== null) {
+                    this.connected = true;
+                    this.sp = port;
+                    this.sp.on('close', this.onPortClose.bind(this));
+                    this.sp.on('error', (error) => { this.onPortError(error); });
+                    return true;
                 }
                 else {
-                    if (this.error) {
-                        clearInterval(iv);
-                        this.cmdBusy = false;
-                        reject(this.error);
-                        return;
-                    }
-                    if (Date.now() > tTimeout) {
-                        clearInterval(iv);
-                        this.opening = false;
-                        this.cmdBusy = false;
-                        reject(new Error('timeout'));
-                    }
+                    return false;
                 }
-            }, 100);
+            }
+            catch (_a) {
+                return false;
+            }
         });
     }
     close() {
-        this.logEvent({ message: 'close()', port: this.getPort() });
-        if (this.closing) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.serial)
+                return;
+            this.stopWorker();
+            yield this.flush();
+            yield this.serial.closePort(this.portName);
+            this.connected = false;
+            if (this.sp)
+                this.sp.removeAllListeners();
+            this.sp = null;
+            this.error = undefined;
+            this.closing = false;
+            this.closed = true;
+            this.cmdBusy = false;
             return;
-        }
-        var serialPort = this.sp;
-        this.closing = true;
-        this.stopWorker();
-        let connected = this.connected;
-        if (connected) {
-            if (serialPort) {
-                serialPort.unpipe();
-                serialPort.flush();
-                if (this.cmdBusy) {
-                    serialPort.drain(() => {
-                        serialPort.close();
-                    });
-                }
-                else {
-                    serialPort.close();
-                }
-            }
-        }
-        else {
-            if (serialPort) {
-                serialPort.close();
-            }
-        }
-        this.cmdBusy = false;
+        });
     }
-    saveClose() {
-        return new Promise((resolve, reject) => {
-            this.close();
-            const tTimeout = Date.now() + TIMEOUT_CLOSE;
-            const iv = setInterval(() => {
-                if (!this.closing || this.closed) {
-                    clearInterval(iv);
-                    resolve(true);
-                }
-                else {
-                    if (Date.now() > tTimeout) {
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cmdBusy)
+                return;
+            return new Promise(done => {
+                const iv = setInterval(() => {
+                    if (!this.cmdBusy) {
                         clearInterval(iv);
-                        this.closing = false;
-                        reject(new Error('timeout'));
+                        done();
                     }
-                }
-            }, 100);
+                }, 100);
+            });
         });
     }
-    onPortOpen() {
-        this.logEvent({ message: "port opened", port: this.getPort() });
-        this.error = undefined;
-        this.connected = true;
-        this.opening = false;
-        this.closed = false;
-        if (this.cmdStart !== undefined) {
-            this.cmdStart = Date.now();
-        }
-        this.cmdBusy = false;
-    }
     onPortClose() {
-        this.logEvent({ message: "port closed", port: this.getPort() });
-        this.error = undefined;
-        this.connected = false;
-        this.closing = false;
-        this.closed = true;
-        this.cmdBusy = false;
-        if (this.queue !== undefined)
-            this.queue.clear();
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: "port closed", port: this.getPort() });
+            yield this.close();
+        });
     }
     onPortError(err) {
         if (this.closed && !this.opening)
             return;
         if ((this.closing || this.closed) && (err.message === 'Port is not open' || err.message === 'Writing to COM port (GetOverlappedResult): Operation aborted'))
             return;
-        if (this.opening && (err.message === 'Port is already open' || err.message === 'Port is opening'))
-            return;
         const state = { opening: this.opening, connected: this.connected, closing: this.closing, closed: this.closed, busy: this.cmdBusy };
         this.logEvent({ message: "port error:", port: this.getPort(), error: err.message, stack: err.stack, state });
         this.error = err;
@@ -227,8 +145,6 @@ class Daum8008 {
             clearInterval(this.bikeCmdWorker);
             this.bikeCmdWorker = undefined;
         }
-        if (this.queue !== undefined)
-            this.queue.clear();
     }
     sendDaum8008CommandfromQueue() {
         if (!this.connected || this.closing || !this.sp)
@@ -254,7 +170,7 @@ class Daum8008 {
         if (this.connected && this.cmdBusy) {
             if (this.cmdCurrent !== undefined && this.cmdCurrent.start !== undefined) {
                 const cmdInfo = this.cmdCurrent;
-                const timeout = (cmdInfo.options && cmdInfo.options.timeout) ? cmdInfo.options.timeout : (this.settings.timeoutMessage || TIMEOUT_SEND);
+                const timeout = (cmdInfo.options && cmdInfo.options.timeout) ? cmdInfo.options.timeout : this._timeoutSend;
                 let d = Date.now() - cmdInfo.start;
                 if (d > timeout) {
                     this.logEvent({ message: 'sendCommmand:timeout', port: this.getPort() });
@@ -384,9 +300,9 @@ class Daum8008 {
         const age = user.age !== undefined ? user.age : utils_1.DEFAULT_AGE;
         const gender = (0, utils_1.getGender)(user.sex);
         const length = (0, utils_1.getLength)(user.length);
-        const maxPower = this.settings.maxPower === undefined ? 800 : this.settings.maxPower;
-        const mUser = user.weight || this.getUserWeight();
-        const weight = (0, utils_1.getWeight)(mUser) + this.getBikeWeight();
+        const maxPower = 800;
+        const mUser = user.weight;
+        const weight = (0, utils_1.getWeight)(mUser) + 10;
         var cmd = [0x24, bikeNo, 0];
         cmd.push(age);
         cmd.push(gender);

package/lib/serial/daum/classic/mock.d.ts

@@ -0,0 +1,96 @@
+/// <reference types="node" />
+import { MockBindingInterface, MockPortBinding, CreatePortOptions } from '@serialport/binding-mock';
+import { BindingInterface } from '@serialport/bindings-interface';
+export type MockProps = {
+    interface: string;
+    path: string;
+};
+export interface DaumClassicMockBindingInterface extends BindingInterface<DaumClassicMockBinding> {
+    reset(): void;
+    createPort(path: string, opt?: CreatePortOptions): void;
+}
+export declare const DaumClassicMock: MockBindingInterface;
+export declare class DaumClassicMockImpl {
+    static _instance: DaumClassicMockImpl;
+    static getInstance(): DaumClassicMockImpl;
+    static reset(): void;
+    simulators: Map<string, DaumClassicSimulator>;
+    ports: {
+        path: string;
+        binding: DaumClassicMockBinding;
+    }[];
+    constructor();
+    setSimulator(path: string, simulator: DaumClassicSimulator): void;
+    getSimulator(path: any): DaumClassicSimulator;
+    reset(): void;
+    createPort(path: string, options?: CreatePortOptions): void;
+    list(): Promise<import("@serialport/bindings-interface").PortInfo[]>;
+    open(options: any): Promise<DaumClassicMockBinding>;
+}
+export type DaumClassicUser = {
+    weight: number;
+    length?: number;
+    age?: number;
+    sex?: number;
+    personNo?: number;
+    pctFat?: number;
+    coachingLevel?: number;
+    coachingFrequency?: number;
+    powerLimit?: number;
+    hrLimit?: number;
+    timeLimit?: number;
+    distLimit?: number;
+    kcalLimit?: number;
+};
+interface BikeData {
+    cockpitVersion: number;
+    isPedalling: boolean;
+    bikeType: number;
+    person: DaumClassicUser;
+}
+export declare class DaumClassicSimulator {
+    selectedBike: number;
+    bikes: BikeData[];
+    cadence: number;
+    gear: number;
+    slope: number;
+    progNo: number;
+    heartrate: number;
+    distance: number;
+    isPowerMode: boolean;
+    targetPower: number;
+    currentPower: number;
+    _timeoutResponse: number;
+    _simulateNoReponseCnt: number;
+    _simulateIllegalResponseCnt: number;
+    constructor();
+    reset(): void;
+    simulateTimeout(ms: number): void;
+    simulateNoResponse(cnt?: number): void;
+    simulateIllegalResponse(cnt?: number): void;
+    isPedalling(): 0 | 1;
+}
+export declare class DaumClassicMockBinding extends MockPortBinding {
+    prevCommand: Buffer;
+    simulator: DaumClassicSimulator;
+    handlers: Map<number, (payload: Buffer) => void>;
+    constructor(parent: MockPortBinding);
+    getPath(): string;
+    initHandlers(): void;
+    write(buffer: Buffer): Promise<void>;
+    emitData(data: string | Buffer): void;
+    onCheckCockpit(payload: Buffer): void;
+    onGetAddress(_payload: Buffer): void;
+    onGetVersion(payload: Buffer): void;
+    onResetDevice(payload: Buffer): void;
+    onStartProg(payload: Buffer): void;
+    onStopProg(payload: Buffer): void;
+    onSetProg(payload: Buffer): void;
+    onSetBikeType(payload: Buffer): void;
+    onSetPerson(payload: Buffer): void;
+    onRunData(payload: Buffer): void;
+    onSetGear(payload: Buffer): void;
+    onSetPower(payload: Buffer): void;
+    onSetSlope(payload: Buffer): void;
+}
+export {};