@makeitnow/jumpitnow 0.0.0-stage → 0.1.0-alpha.3

package/dist/cjs/internal/link.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserLink = void 0;
+exports.getSupport = getSupport;
+const errors_js_1 = require("./errors.js");
+const provider = () => globalThis.navigator?.serial;
+function getSupport() {
+    const secureContext = globalThis.isSecureContext === true;
+    const webSerial = !!provider();
+    return { supported: secureContext && webSerial, secureContext, webSerial,
+        reason: !secureContext ? 'INSECURE_CONTEXT' : !webSerial ? 'UNSUPPORTED_BROWSER' : null };
+}
+class BrowserLink {
+    #port = null;
+    #reader = null;
+    #writer = null;
+    #reading = null;
+    #closing = false;
+    #openedByUs = false;
+    async open(line, lost) {
+        const support = getSupport();
+        if (!support.supported)
+            throw new errors_js_1.SDKError(support.reason);
+        this.#closing = false;
+        try {
+            this.#port = await provider().requestPort();
+        }
+        catch (e) {
+            throw new errors_js_1.SDKError(e?.name === 'NotFoundError' ? 'USER_CANCELLED' : 'PORT_UNAVAILABLE');
+        }
+        try {
+            await this.#port.open({ baudRate: 115200 });
+            this.#openedByUs = true;
+            if (!this.#port.readable || !this.#port.writable)
+                throw new errors_js_1.SDKError('PORT_UNAVAILABLE');
+            this.#reader = this.#port.readable.getReader();
+            this.#writer = this.#port.writable.getWriter();
+            this.#reading = this.#read(line, lost);
+        }
+        catch {
+            await this.close().catch(() => { });
+            throw new errors_js_1.SDKError('PORT_UNAVAILABLE');
+        }
+    }
+    async #read(line, lost) {
+        const reader = this.#reader;
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let discarding = false;
+        try {
+            while (!this.#closing) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                const text = decoder.decode(value, { stream: true });
+                for (const ch of text) {
+                    if (ch === '\n') {
+                        if (!discarding)
+                            line(buffer.replace(/\r$/, ''));
+                        buffer = '';
+                        discarding = false;
+                    }
+                    else if (!discarding) {
+                        buffer += ch;
+                        if (buffer.length > 4096) {
+                            buffer = '';
+                            discarding = true;
+                        }
+                    }
+                }
+            }
+        }
+        catch { /* The public error deliberately omits OS and raw device details. */ }
+        finally {
+            reader.releaseLock();
+            this.#reader = null;
+            if (!this.#closing)
+                lost();
+        }
+    }
+    async write(command) {
+        if (!this.#writer || this.#closing)
+            throw new errors_js_1.SDKError('CONNECTION_LOST');
+        try {
+            await this.#writer.write(new TextEncoder().encode(`${command}\n`));
+        }
+        catch {
+            throw new errors_js_1.SDKError('CONNECTION_LOST');
+        }
+    }
+    async close() {
+        this.#closing = true;
+        try {
+            await this.#reader?.cancel().catch(() => { });
+            await this.#reading;
+            if (this.#writer) {
+                await this.#writer.abort().catch(() => { });
+                this.#writer.releaseLock();
+                this.#writer = null;
+            }
+            if (this.#port && this.#openedByUs)
+                await this.#port.close();
+            this.#port = null;
+            this.#openedByUs = false;
+        }
+        catch (error) {
+            throw (0, errors_js_1.asError)(error, 'PORT_UNAVAILABLE');
+        }
+    }
+}
+exports.BrowserLink = BrowserLink;

package/dist/cjs/internal/protocol.d.ts

@@ -0,0 +1,29 @@
+export type Frame = {
+    kind: 'help';
+    text: string;
+} | {
+    kind: 'list';
+    phase: 'BEGIN' | 'END';
+} | {
+    kind: 'device';
+    number: number;
+    endpoint: string;
+    battery: number;
+    version: string;
+} | {
+    kind: 'tx';
+    target: string;
+    endpoint: string;
+    bytes: number[];
+    ok: boolean;
+} | {
+    kind: 'rx';
+    number: number;
+    endpoint: string;
+    bytes: number[];
+} | {
+    kind: 'error';
+};
+export declare function bytes(hex: string): number[] | null;
+export declare function parse(line: string): Frame | null;
+export declare const u16: (data: number[], offset: number) => number;

package/dist/cjs/internal/protocol.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u16 = void 0;
+exports.bytes = bytes;
+exports.parse = parse;
+function bytes(hex) {
+    if (!/^(?:[0-9a-f]{2}){1,48}$/i.test(hex))
+        return null;
+    return hex.match(/../g).map(v => Number.parseInt(v, 16));
+}
+const number = (s, max = 255) => s !== undefined && /^\d+$/.test(s) && Number(s) <= max ? Number(s) : null;
+const endpoint = (s) => !!s && /^[a-z0-9:.%-]{1,63}$/i.test(s);
+function parse(line) {
+    const p = line.trim().split(',');
+    if (line.startsWith('HELP'))
+        return { kind: 'help', text: line };
+    if (p[0] === 'LIST' && (p[1] === 'BEGIN' || p[1] === 'END'))
+        return { kind: 'list', phase: p[1] };
+    if (p[0] === 'DEVICE' && p.length === 10 && number(p[1], 40) !== null && number(p[2]) !== null && endpoint(p[3]) && /^\d+\.\d+\.\d+$/.test(p[8]) && /^-?\d+$/.test(p[5])) {
+        return { kind: 'device', number: Number(p[2]), endpoint: p[3], battery: Number(p[5]), version: p[8] };
+    }
+    if (p[0] === 'TXB' && p.length === 5 && endpoint(p[2]) && p[1] && (p[4] === 'OK' || p[4] === 'FAIL')) {
+        const b = bytes(p[3]);
+        if (b)
+            return { kind: 'tx', target: p[1], endpoint: p[2], bytes: b, ok: p[4] === 'OK' };
+    }
+    if (p[0] === 'RXB' && p.length === 4 && number(p[1]) !== null && endpoint(p[2])) {
+        const b = bytes(p[3]);
+        if (b && b.length >= 2 && b[1] === Number(p[1]))
+            return { kind: 'rx', number: Number(p[1]), endpoint: p[2], bytes: b };
+    }
+    // Normalized measurement lines have no unambiguous endpoint. Use the addressed response above only.
+    if (p[0] === 'ERR' && p[1] !== 'DEVICE')
+        return { kind: 'error' };
+    return null;
+}
+const u16 = (data, offset) => data[offset] | (data[offset + 1] << 8);
+exports.u16 = u16;

package/dist/cjs/internal/simulator.d.ts

@@ -0,0 +1,15 @@
+import type { SimulationOptions } from '../types.js';
+import type { Link } from './link.js';
+export declare class SimulationLink implements Link {
+    #private;
+    constructor(options: SimulationOptions);
+    open(line: (line: string) => void, lost: () => void): Promise<void>;
+    write(command: string): Promise<void>;
+    controls(): Readonly<{
+        disconnectDevice: (displayNumber: number) => void;
+        reconnectDevice: (displayNumber: number) => void;
+        setStartFailure: (displayNumber: number, fail: boolean) => void;
+        dropConnection: () => void;
+    }>;
+    close(): Promise<void>;
+}

package/dist/cjs/internal/simulator.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulationLink = void 0;
+const errors_js_1 = require("./errors.js");
+const codes = { free: 16, count: 17, time: 18, start: 19, stop: 20, getData: 21, getBattery: 6, vibrate: 49, buzzer: 48, showId: 51 };
+const hex = (values) => values.map(v => v.toString(16).padStart(2, '0')).join('').toUpperCase();
+const word = (n) => [n & 255, (n >> 8) & 255];
+class SimulationLink {
+    #line = null;
+    #lost = null;
+    #units;
+    #delay;
+    #failures;
+    #seed;
+    #timers = new Set();
+    constructor(options) {
+        if (!options || typeof options !== 'object' || Array.isArray(options))
+            throw new errors_js_1.SDKError('INVALID_ARGUMENT');
+        const count = (0, errors_js_1.integer)(options.deviceCount ?? 3, 1, 40);
+        this.#delay = (0, errors_js_1.integer)(options.responseDelayMs ?? 10, 0, 30000);
+        this.#seed = (0, errors_js_1.integer)(options.seed ?? 1, 0, 0xffffffff);
+        if (options.startFailures && !Array.isArray(options.startFailures))
+            throw new errors_js_1.SDKError('INVALID_ARGUMENT');
+        this.#failures = new Set((options.startFailures ?? []).map(n => (0, errors_js_1.integer)(n, 1, count)));
+        this.#units = Array.from({ length: count }, (_, i) => ({ number: i + 1, online: true, mode: 0, running: false, count: 0, ticks: 0, target: 0 }));
+    }
+    async open(line, lost) { this.#line = line; this.#lost = lost; }
+    #send(lines) {
+        const timer = setTimeout(() => { this.#timers.delete(timer); for (const line of lines)
+            this.#line?.(line); }, this.#delay);
+        this.#timers.add(timer);
+    }
+    async write(command) {
+        if (!this.#line)
+            throw new errors_js_1.SDKError('CONNECTION_LOST');
+        if (command === 'help') {
+            this.#send(['HELP: target=all|0|id|#index|!addr', 'HELP: getData|status|fw', 'HELP: getList|clearList|scanList|refreshList']);
+            return;
+        }
+        if (command === 'getList') {
+            this.#send(['LIST,BEGIN', ...this.#units.filter(u => u.online).map(u => `DEVICE,${u.number},${u.number},unit-${u.number},-,85,0,0,1.0.0,-`), 'LIST,END']);
+            return;
+        }
+        if (command === 'discover all') {
+            this.#send(['TXB,all,group,01,OK', ...this.#units.filter(u => u.online).map(u => `RXB,${u.number},unit-${u.number},${hex([1, u.number])}`)]);
+            return;
+        }
+        const [name, target, parameter] = command.split(' ');
+        const code = codes[name];
+        const unit = this.#units.find(u => `!unit-${u.number}` === target);
+        if (code === undefined || !unit) {
+            this.#send(['ERR,BAD_TARGET']);
+            return;
+        }
+        const request = hex([code, ...(parameter === undefined ? [] : word(Number(parameter)))]);
+        const tx = `TXB,${target},unit-${unit.number},${request},OK`;
+        if (!unit.online) {
+            this.#send([tx]);
+            return;
+        }
+        if (code === 19 && this.#failures.has(unit.number)) {
+            this.#send([tx, `RXB,${unit.number},unit-${unit.number},${hex([127, unit.number, 1, code])}`]);
+            return;
+        }
+        let payload = [code, unit.number];
+        if ([16, 17, 18].includes(code)) {
+            unit.mode = code - 16;
+            unit.target = Number(parameter ?? 0);
+        }
+        if (code === 19) {
+            unit.running = true;
+            unit.count = 0;
+            unit.ticks = 0;
+        }
+        if (code === 20)
+            unit.running = false;
+        if (code === 21) {
+            if (unit.running) {
+                this.#seed = (Math.imul(this.#seed, 1664525) + 1013904223) >>> 0;
+                unit.count += 1 + this.#seed % 3;
+                unit.ticks += 5;
+                if (unit.mode === 1 && unit.count >= unit.target) {
+                    unit.count = unit.target;
+                    unit.running = false;
+                }
+                if (unit.mode === 2 && unit.ticks >= unit.target * 10) {
+                    unit.ticks = unit.target * 10;
+                    unit.running = false;
+                }
+            }
+            payload = [...payload, unit.mode, ...word(unit.count % 65536), ...word(unit.ticks % 65536), 0, 0];
+        }
+        if (code === 6)
+            payload.push(85);
+        this.#send([tx, `RXB,${unit.number},unit-${unit.number},${hex(payload)}`]);
+    }
+    #unit(displayNumber) { (0, errors_js_1.integer)(displayNumber, 1, this.#units.length); return this.#units[displayNumber - 1]; }
+    controls() {
+        return Object.freeze({
+            disconnectDevice: (displayNumber) => { this.#unit(displayNumber).online = false; },
+            reconnectDevice: (displayNumber) => { this.#unit(displayNumber).online = true; },
+            setStartFailure: (displayNumber, fail) => {
+                this.#unit(displayNumber);
+                if (typeof fail !== 'boolean')
+                    throw new errors_js_1.SDKError('INVALID_ARGUMENT');
+                if (fail)
+                    this.#failures.add(displayNumber);
+                else
+                    this.#failures.delete(displayNumber);
+            },
+            dropConnection: () => { const lost = this.#lost; void this.close(); lost?.(); }
+        });
+    }
+    async close() { for (const timer of this.#timers)
+        clearTimeout(timer); this.#timers.clear(); this.#line = null; this.#lost = null; }
+}
+exports.SimulationLink = SimulationLink;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/types.d.ts

@@ -0,0 +1,182 @@
+export type ErrorCode = 'UNSUPPORTED_BROWSER' | 'INSECURE_CONTEXT' | 'USER_CANCELLED' | 'PORT_UNAVAILABLE' | 'NOT_CONNECTED' | 'UNSUPPORTED_GATEWAY' | 'UNSUPPORTED_FEATURE' | 'INVALID_ARGUMENT' | 'INVALID_STATE' | 'DEVICE_OFFLINE' | 'AMBIGUOUS_DEVICE' | 'BUSY' | 'TIMEOUT' | 'DEVICE_REJECTED' | 'CONNECTION_LOST' | 'PROTOCOL_ERROR';
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'disconnecting' | 'lost';
+export type DeviceState = 'available' | 'running' | 'unknown' | 'offline';
+export type Mode = {
+    type: 'free';
+} | {
+    type: 'count';
+    targetCount: number;
+} | {
+    type: 'time';
+    durationSeconds: number;
+};
+export type IdentifySignal = 'vibrate' | 'buzzer' | 'displayId';
+export type Battery = {
+    kind: 'percent';
+    value: number;
+} | {
+    kind: 'unknown';
+};
+export interface Capabilities {
+    modes: Array<Mode['type']>;
+    maxTargetCount: number;
+    maxDurationSeconds: number;
+    identifySignals: IdentifySignal[];
+    /** Actual hardware combinations must still pass the release acceptance checks. */
+    hardwareVerified: boolean;
+}
+export interface Device {
+    deviceId: string;
+    displayNumber: number | null;
+    state: DeviceState;
+    firmwareVersion: string | null;
+    battery: Battery;
+    capabilities: Capabilities;
+    simulated: boolean;
+}
+export interface Measurement {
+    deviceId: string;
+    displayNumber: number | null;
+    sessionId: string;
+    segmentId: string;
+    count: number;
+    elapsedMs: number;
+    pauseCount: number | null;
+    receivedAt: number;
+    source: 'live' | 'cache';
+    stale: boolean;
+    simulated: boolean;
+}
+export interface ErrorInfo {
+    code: ErrorCode;
+    message: string;
+    recoverable: boolean;
+    deviceId?: string;
+    requestId?: string;
+}
+export type ResultStatus = 'acknowledged' | 'failed' | 'unknown';
+export interface DeviceResult {
+    deviceId: string;
+    status: ResultStatus;
+    errorCode?: ErrorCode;
+    recovery?: {
+        action: 'stop';
+        status: ResultStatus;
+    };
+    finalMeasurement?: {
+        available: boolean;
+        measurement: Measurement | null;
+    };
+}
+export interface CommandResult {
+    requestId: string;
+    ok: boolean;
+    results: DeviceResult[];
+}
+export interface DisconnectResult {
+    closed: boolean;
+    stopResults: CommandResult | null;
+}
+export interface ScanResult {
+    devices: Device[];
+    status: 'complete';
+    windowMs: number;
+}
+export interface Support {
+    supported: boolean;
+    secureContext: boolean;
+    webSerial: boolean;
+    reason: ErrorCode | null;
+}
+export interface GatewayInfo {
+    connection: ConnectionState;
+    sdkVersion: string;
+    interfaceVersion: string;
+    firmwareVersion: string | null;
+    simulated: boolean;
+    features: string[];
+}
+export interface Diagnostics {
+    sdkVersion: string;
+    interfaceVersion: string;
+    connection: ConnectionState;
+    simulated: boolean;
+    deviceCount: number;
+    blockedOperationCount: number;
+    recentRequests: Array<{
+        requestId: string;
+        durationMs: number;
+        errorCode: ErrorCode | null;
+    }>;
+}
+export interface Events {
+    measurement: Measurement;
+    deviceChanged: {
+        device: Device;
+        previousState: DeviceState | null;
+    };
+    connectionChanged: {
+        state: ConnectionState;
+        previousState: ConnectionState;
+    };
+    error: ErrorInfo;
+}
+export interface GatewayOptions {
+    requestTimeoutMs?: number;
+    scanWindowMs?: number;
+    pollIntervalMs?: number;
+    staleAfterMs?: number;
+    /** Empty by default; enable only signals validated for the actual product. */
+    identifySignals?: IdentifySignal[];
+}
+export interface Gateway {
+    connect(): Promise<GatewayInfo>;
+    disconnect(): Promise<DisconnectResult>;
+    getInfo(): GatewayInfo;
+    scan(options?: {
+        timeoutMs?: number;
+    }): Promise<ScanResult>;
+    getDevices(): Device[];
+    configure(options: {
+        deviceIds: string[];
+        mode: Mode;
+    }): Promise<CommandResult>;
+    start(options: {
+        deviceIds: string[];
+    }): Promise<CommandResult>;
+    stop(options: {
+        deviceIds: string[];
+    }): Promise<CommandResult>;
+    readMeasurement(options: {
+        deviceId: string;
+        timeoutMs?: number;
+    }): Promise<Measurement>;
+    getLastMeasurement(options: {
+        deviceId: string;
+    }): Measurement | null;
+    readBattery(options: {
+        deviceId: string;
+        timeoutMs?: number;
+    }): Promise<Battery>;
+    identify(options: {
+        deviceId: string;
+        signal: IdentifySignal;
+    }): Promise<CommandResult>;
+    on<K extends keyof Events>(event: K, handler: (value: Events[K]) => void): () => void;
+    getDiagnostics(): Diagnostics;
+}
+export interface SimulationOptions extends GatewayOptions {
+    deviceCount?: number;
+    seed?: number;
+    responseDelayMs?: number;
+    /** Display numbers that reject start, for testing partial failure recovery. */
+    startFailures?: number[];
+}
+export interface SimulatedGateway extends Gateway {
+    simulation: {
+        disconnectDevice(displayNumber: number): void;
+        reconnectDevice(displayNumber: number): void;
+        setStartFailure(displayNumber: number, fail: boolean): void;
+        dropConnection(): void;
+    };
+}

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/index.d.ts

@@ -0,0 +1,6 @@
+import type { Gateway, GatewayOptions, SimulatedGateway, SimulationOptions } from './types.js';
+export { getSupport } from './internal/link.js';
+export { SDKError } from './internal/errors.js';
+export type * from './types.js';
+export declare function createGateway(options?: GatewayOptions): Gateway;
+export declare function createSimulatedGateway(options?: SimulationOptions): SimulatedGateway;

package/dist/esm/index.js

@@ -0,0 +1,22 @@
+import { GatewayEngine } from './internal/gateway.js';
+import { BrowserLink } from './internal/link.js';
+import { SimulationLink } from './internal/simulator.js';
+export { getSupport } from './internal/link.js';
+export { SDKError } from './internal/errors.js';
+function facade(engine) {
+    return {
+        connect: () => engine.connect(), disconnect: () => engine.disconnect(),
+        getInfo: () => engine.getInfo(), scan: options => engine.scan(options), getDevices: () => engine.getDevices(),
+        configure: options => engine.configure(options), start: options => engine.start(options), stop: options => engine.stop(options),
+        readMeasurement: options => engine.readMeasurement(options), getLastMeasurement: options => engine.getLastMeasurement(options),
+        readBattery: options => engine.readBattery(options), identify: options => engine.identify(options),
+        on: (event, handler) => engine.on(event, handler), getDiagnostics: () => engine.getDiagnostics()
+    };
+}
+export function createGateway(options = {}) {
+    return Object.freeze(facade(new GatewayEngine(new BrowserLink(), options)));
+}
+export function createSimulatedGateway(options = {}) {
+    const link = new SimulationLink(options);
+    return Object.freeze({ ...facade(new GatewayEngine(link, options, true)), simulation: link.controls() });
+}

package/dist/esm/internal/errors.d.ts

@@ -0,0 +1,15 @@
+import type { ErrorCode, ErrorInfo } from '../types.js';
+export declare class SDKError extends Error implements ErrorInfo {
+    readonly code: ErrorCode;
+    readonly recoverable: boolean;
+    readonly deviceId?: string;
+    readonly requestId?: string;
+    constructor(code: ErrorCode, context?: {
+        deviceId?: string;
+        requestId?: string;
+    });
+    toJSON(): ErrorInfo;
+}
+export declare const fail: (code: ErrorCode) => never;
+export declare const asError: (error: unknown, fallback?: ErrorCode) => SDKError;
+export declare function integer(value: unknown, min: number, max: number): number;

package/dist/esm/internal/errors.js

@@ -0,0 +1,37 @@
+const messages = {
+    UNSUPPORTED_BROWSER: '이 브라우저는 USB 장비 연결을 지원하지 않습니다.',
+    INSECURE_CONTEXT: 'HTTPS 또는 localhost에서 실행해주세요.',
+    USER_CANCELLED: '포트 선택을 취소했습니다.', PORT_UNAVAILABLE: 'USB 포트를 열거나 해제할 수 없습니다.',
+    NOT_CONNECTED: '게이트웨이를 먼저 연결해주세요.', UNSUPPORTED_GATEWAY: '지원하는 게이트웨이 응답을 확인하지 못했습니다.',
+    UNSUPPORTED_FEATURE: '이 장비에서 활성화되지 않은 기능입니다.', INVALID_ARGUMENT: '입력값을 확인해주세요.',
+    INVALID_STATE: '현재 상태에서 실행할 수 없습니다. 장비 상태를 먼저 확인해주세요.',
+    DEVICE_OFFLINE: '장비의 응답을 확인할 수 없습니다.', AMBIGUOUS_DEVICE: '장비 번호가 중복되었거나 응답 대상을 확인할 수 없습니다.',
+    BUSY: '다른 장비 작업이 진행 중입니다.', TIMEOUT: '제한 시간 안에 응답을 받지 못했습니다.',
+    DEVICE_REJECTED: '장비 또는 게이트웨이가 요청을 거부했습니다.', CONNECTION_LOST: '게이트웨이 연결이 끊어졌습니다.',
+    PROTOCOL_ERROR: '지원하는 응답 형식이 아닙니다.'
+};
+export class SDKError extends Error {
+    code;
+    recoverable;
+    deviceId;
+    requestId;
+    constructor(code, context = {}) {
+        super(messages[code]);
+        this.name = 'SDKError';
+        this.code = code;
+        this.recoverable = !['UNSUPPORTED_BROWSER', 'UNSUPPORTED_GATEWAY', 'UNSUPPORTED_FEATURE', 'INVALID_ARGUMENT'].includes(code);
+        this.deviceId = context.deviceId;
+        this.requestId = context.requestId;
+    }
+    toJSON() {
+        return { code: this.code, message: this.message, recoverable: this.recoverable,
+            ...(this.deviceId ? { deviceId: this.deviceId } : {}), ...(this.requestId ? { requestId: this.requestId } : {}) };
+    }
+}
+export const fail = (code) => { throw new SDKError(code); };
+export const asError = (error, fallback = 'PROTOCOL_ERROR') => error instanceof SDKError ? error : new SDKError(fallback);
+export function integer(value, min, max) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < min || value > max)
+        fail('INVALID_ARGUMENT');
+    return value;
+}

package/dist/esm/internal/gateway.d.ts

@@ -0,0 +1,41 @@
+import type { Battery, CommandResult, Device, Diagnostics, DisconnectResult, Events, Gateway, GatewayInfo, GatewayOptions, IdentifySignal, Measurement, Mode, ScanResult } from '../types.js';
+import type { Link } from './link.js';
+export declare const VERSION = "0.1.0-alpha.3";
+export declare class GatewayEngine implements Gateway {
+    #private;
+    constructor(link: Link, options?: GatewayOptions, simulated?: boolean);
+    on<K extends keyof Events>(name: K, handler: (value: Events[K]) => void): () => void;
+    connect(): Promise<GatewayInfo>;
+    scan(options?: {
+        timeoutMs?: number;
+    }): Promise<ScanResult>;
+    configure(options: {
+        deviceIds: string[];
+        mode: Mode;
+    }): Promise<CommandResult>;
+    start(options: {
+        deviceIds: string[];
+    }): Promise<CommandResult>;
+    stop(options: {
+        deviceIds: string[];
+    }): Promise<CommandResult>;
+    readMeasurement(options: {
+        deviceId: string;
+        timeoutMs?: number;
+    }): Promise<Measurement>;
+    getLastMeasurement(options: {
+        deviceId: string;
+    }): Measurement | null;
+    readBattery(options: {
+        deviceId: string;
+        timeoutMs?: number;
+    }): Promise<Battery>;
+    identify(options: {
+        deviceId: string;
+        signal: IdentifySignal;
+    }): Promise<CommandResult>;
+    disconnect(): Promise<DisconnectResult>;
+    getDevices(): Device[];
+    getInfo(): GatewayInfo;
+    getDiagnostics(): Diagnostics;
+}