@ovok/native 0.4.5 → 0.4.7

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.file-names.d.ts

@@ -0,0 +1,14 @@
+/** Names are a fixed sixteen bytes, zero padded, in both the listing and the request. */
+declare const NAME_BYTES = 16;
+/**
+ * A file name as the device expects it: sixteen bytes, zero padded, truncated.
+ *
+ * The truncation is the device's, not ours - it copies at most sixteen bytes and pads the
+ * rest - so two names that agree in their first sixteen bytes are the same file as far as
+ * the protocol is concerned.
+ */
+declare const lepuNameBytes: (name: string) => number[];
+/** The names in a file listing: a count, then that many fixed-width padded names. */
+declare const lepuNamesFrom: (payload: readonly string[]) => string[];
+export { lepuNameBytes, lepuNamesFrom, NAME_BYTES };
+//# sourceMappingURL=lepu.file-names.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.file-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.file-names.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.file-names.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,QAAA,MAAM,UAAU,KAAK,CAAC;AAItB;;;;;;GAMG;AACH,QAAA,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,MAAM,EAGzC,CAAC;AAEJ,qFAAqF;AACrF,QAAA,MAAM,aAAa,GAAI,SAAS,SAAS,MAAM,EAAE,KAAG,MAAM,EAczD,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC"}

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.file-transfer.d.ts

@@ -0,0 +1,75 @@
+import { CommandSequencer } from "../../../types/command-sequencer";
+import { DeviceCommand } from "../../../types/device-command";
+import { LepuCommandBuilder } from "./lepu.command-builder";
+interface LepuFile {
+    name: string;
+    content: readonly string[];
+}
+interface LepuFileTransferParams {
+    /** The characteristic commands are written to. */
+    write: Omit<DeviceCommand, "frame">;
+    /** Builds this connection's frames. One per connection: it carries a sequence number. */
+    builder: LepuCommandBuilder;
+    maxFileBytes?: number;
+    /** Called once per file, and only after its length was confirmed exactly. */
+    onFile: (file: LepuFile) => void;
+    /** Called with why a transfer stopped. Required, so a failed read cannot pass unseen. */
+    onError: (reason: string) => void;
+    /** Called as each chunk lands, for a long file with a person waiting on it. */
+    onProgress?: (progress: {
+        name: string;
+        receivedBytes: number;
+        totalBytes: number;
+    }) => void;
+}
+/**
+ * Downloads the records a Lepu device has stored.
+ *
+ * Every opcode this uses is generic and inert - list, open, read, close - so unlike a
+ * realtime poll it is safe on hardware whose model is not known. That is what makes it the
+ * one thing the whole family can be asked for without identifying it first.
+ *
+ * The exchange is self-clocking and has no windowing: each reply decides the next request,
+ * and the device chooses how much to send, so the offset advances by what actually arrived
+ * rather than by an assumed chunk size. There is no retry in the protocol either - a single
+ * dropped reply stalls the transfer with nothing to resume it - which is what the data
+ * processor's stuck-data timeout is the watchdog for.
+ *
+ * A short read is an error, not a truncated success: the device is asked to close the file
+ * and the reading is discarded, because half an ECG that looks like a whole one is worse
+ * than none.
+ */
+export declare class LepuFileTransfer implements CommandSequencer {
+    private readonly params;
+    private files;
+    private fileIndex;
+    private name;
+    private totalBytes;
+    private content;
+    private isSessionOpen;
+    private isDone;
+    constructor(params: LepuFileTransferParams);
+    initialCommands: () => readonly DeviceCommand[];
+    nextCommand: (frame: readonly string[]) => readonly DeviceCommand[] | undefined;
+    private openNextFile;
+    /** The reply to opening a file states its whole length, which bounds everything after. */
+    private openedFile;
+    /**
+     * A reply with no bytes in it ends the transfer rather than asking again from the same
+     * offset, which is a request the device would answer the same way for as long as the link
+     * stayed up.
+     */
+    private appendChunk;
+    private closedFile;
+    private closeFile;
+    /**
+     * Stops, and releases the device's file handle if one is open.
+     *
+     * The device holds that handle from the moment a file is opened until it is closed, so
+     * walking away from a failed read can leave it open until the device times out or resets.
+     */
+    private fail;
+    private commandFor;
+}
+export {};
+//# sourceMappingURL=lepu.file-transfer.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.file-transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.file-transfer.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.file-transfer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAI9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAsB5D,UAAU,QAAQ;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,UAAU,sBAAsB;IAE9B,kDAAkD;IAClD,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAEpC,yFAAyF;IACzF,OAAO,EAAE,kBAAkB,CAAC;IAE5B,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,6EAA6E;IAC7E,MAAM,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;IAEjC,yFAAyF;IACzF,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAElC,+EAA+E;IAC/E,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE;QACtB,IAAI,EAAE,MAAM,CAAC;QACb,aAAa,EAAE,MAAM,CAAC;QACtB,UAAU,EAAE,MAAM,CAAC;KACpB,KAAK,IAAI,CAAC;CACZ;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,gBAAiB,YAAW,gBAAgB;IASpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAR1C,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,MAAM,CAAS;gBAEa,MAAM,EAAE,sBAAsB;IAE3D,eAAe,QAAO,SAAS,aAAa,EAAE,CAEnD;IAEK,WAAW,GAChB,OAAO,SAAS,MAAM,EAAE,KACvB,SAAS,aAAa,EAAE,GAAG,SAAS,CA2BrC;IAEF,OAAO,CAAC,YAAY,CAmBlB;IAEF,0FAA0F;IAC1F,OAAO,CAAC,UAAU,CAqBhB;IAEF;;;;OAIG;IACH,OAAO,CAAC,WAAW,CA2BjB;IAEF,OAAO,CAAC,UAAU,CAgBhB;IAEF,OAAO,CAAC,SAAS,CAEf;IAEF;;;;;OAKG;IACH,OAAO,CAAC,IAAI,CAWV;IAEF,OAAO,CAAC,UAAU,CAMf;CACJ"}

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.frame-reader.d.ts

@@ -0,0 +1,28 @@
+import { FrameReadResult } from "../../../types/frame-read-result";
+import { FrameReader } from "../../../types/frame-reader";
+/**
+ * Reads the frame every Lepu device shares.
+ *
+ * Layout: `start | cmd | ~cmd | type | seq | lenLow lenHigh | payload | crc8`, where the
+ * checksum covers every byte before it. The complement of the command byte only narrows the
+ * search for a start; the checksum is what actually decides a frame is trustworthy.
+ *
+ * The start byte is the only part that varies across the family. Most devices use `a5`, a
+ * smaller group uses `55`, and a few accept either and settle on one at runtime - so it is a
+ * list rather than a single value. Everything else is identical on every device speaking this
+ * protocol, which is why it is worth having once rather than once per device.
+ */
+export declare class LepuFrameReader implements FrameReader {
+    private readonly startBytes;
+    constructor(startBytes: readonly string[]);
+    readFrame(buffer: readonly string[]): FrameReadResult;
+    private isFrameStart;
+    private findFrameStart;
+    /**
+     * Bytes that cannot begin a frame start, and are therefore safe to drop when no start was
+     * found. The trailing bytes are kept because a start pattern may still be arriving.
+     */
+    private droppableLeadingBytes;
+    private hasValidChecksum;
+}
+//# sourceMappingURL=lepu.frame-reader.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.frame-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.frame-reader.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.frame-reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAEnE,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAe1D;;;;;;;;;;;GAWG;AACH,qBAAa,eAAgB,YAAW,WAAW;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,SAAS,MAAM,EAAE;IAE1D,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,eAAe;IAiC5D,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,cAAc;IAYtB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,gBAAgB;CAMzB"}

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.frame.d.ts

@@ -0,0 +1,12 @@
+/** The opcode a frame answers, which is what correlates a reply to its request. */
+declare const lepuCommandOf: (frame: readonly string[]) => number;
+/**
+ * The bytes a frame carries, from its own declared length.
+ *
+ * Declared rather than derived from what arrived: the frame reader has already checked that
+ * the buffer holds the whole frame, so the length field is the payload's end, and trusting
+ * the array instead would fold the checksum byte into the data.
+ */
+declare const lepuPayloadOf: (frame: readonly string[]) => string[];
+export { lepuCommandOf, lepuPayloadOf };
+//# sourceMappingURL=lepu.frame.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.frame.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.frame.ts"],"names":[],"mappings":"AAOA,mFAAmF;AACnF,QAAA,MAAM,aAAa,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MACV,CAAC;AAEzC;;;;;;GAMG;AACH,QAAA,MAAM,aAAa,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MAAM,EAIvD,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC"}

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.identity-gate.d.ts

@@ -0,0 +1,81 @@
+import { CommandSequencer } from "../../../types/command-sequencer";
+import { DeviceCommand } from "../../../types/device-command";
+import { LepuCommandBuilder } from "./lepu.command-builder";
+import { LepuDeviceInfo } from "./lepu.device-info";
+interface LepuIdentityGateParams {
+    /** The characteristic this device's commands are written to. */
+    write: Omit<DeviceCommand, "frame">;
+    /** Builds this connection's frames. One per connection: it carries a sequence number. */
+    builder: LepuCommandBuilder;
+    /** The models this driver was written for. */
+    expectedDeviceTypes: readonly number[];
+    /**
+     * The opcode to poll with, once the device has proved it is one of them.
+     *
+     * Optional, and its absence is a working mode rather than a gap: the gate asks what the
+     * device is, reports it, and sends nothing else. That is how a model number is learned
+     * in the first place - every one of them lives on the hardware and nowhere else, because
+     * the vendor's own SDK never checks the field and so never had to write the values down.
+     */
+    pollCommand?: number;
+    /** Called with what the device said it was, whether or not it was expected. */
+    onIdentified?: (info: LepuDeviceInfo) => void;
+    /**
+     * Called with why the device was refused. Required, so a refusal cannot pass unseen.
+     *
+     * The reason is built here rather than by the caller, because the gate is the only place
+     * that knows which of the several ways it can go wrong actually happened.
+     */
+    onRefused: (reason: string) => void;
+}
+/**
+ * Asks a Lepu device what it is before sending it anything that acts.
+ *
+ * The family shares one frame format, one checksum and one opcode space, but not one
+ * meaning: `0x08` polls realtime data on a BP2, starts a blood-pressure measurement on an
+ * AirBp and starts an ECG on a Lepod. A frame built for the wrong device is therefore
+ * perfectly well-formed - the CRC is computed the same way on every one of them - so
+ * nothing in the protocol catches a driver bound to the wrong hardware. What comes back is
+ * a cuff inflating on someone's arm because a name matched during a scan.
+ *
+ * `GET_INFO` is the one command that cannot cause that: it is generic, inert, and answered
+ * identically family-wide. So it goes first, and everything else waits on its reply.
+ *
+ * A declaration that names the models it was written for is refused permanently when the
+ * device answers with a different one. A declaration that names none is identified by the
+ * advertised name it already matched, which is the basis the vendor's own SDK binds every
+ * one of its products on; it is asked what it is anyway, and the answer reported, because
+ * that is the only place these model numbers exist - the vendor never reads the field back,
+ * so there is no table of them to copy.
+ *
+ * A reply that never arrives leaves the gate closed and nothing sent, which the data
+ * processor's stuck-data timeout reports and disconnects on. That is the watchdog for this
+ * too - the protocol has no retry of its own, so a dropped reply is recovered by
+ * reconnecting rather than by asking again.
+ */
+export declare class LepuIdentityGate implements CommandSequencer {
+    private readonly params;
+    private isIdentified;
+    private isRefused;
+    constructor(params: LepuIdentityGateParams);
+    initialCommands: () => readonly DeviceCommand[];
+    nextCommand: (frame: readonly string[]) => readonly DeviceCommand[] | undefined;
+    /**
+     * Decides on the reply to `GET_INFO`.
+     *
+     * A frame that is not that reply leaves the gate as it was rather than provoking another
+     * command, because the only command outstanding is the one still being waited on.
+     *
+     * A reply that is that command but carries an error type is refused rather than parsed.
+     * The payload of an error is the reason for it, so reading a model number out of it would
+     * identify the hardware from an error code.
+     */
+    private admit;
+    /** Closes the gate for good. There is no state a refused device can be talked back from. */
+    private refuse;
+    /** Nothing, for a declaration that asks what the device is and stops there. */
+    private poll;
+    private commandFor;
+}
+export {};
+//# sourceMappingURL=lepu.identity-gate.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.identity-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.identity-gate.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.identity-gate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAG9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,OAAO,EAAE,cAAc,EAAuB,MAAM,oBAAoB,CAAC;AAMzE,UAAU,sBAAsB;IAE9B,gEAAgE;IAChE,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAEpC,yFAAyF;IACzF,OAAO,EAAE,kBAAkB,CAAC;IAE5B,8CAA8C;IAC9C,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IAEvC;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,+EAA+E;IAC/E,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;IAE9C;;;;;OAKG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAID;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,gBAAiB,YAAW,gBAAgB;IAIpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAH1C,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,SAAS,CAAS;gBAEU,MAAM,EAAE,sBAAsB;IAE3D,eAAe,QAAO,SAAS,aAAa,EAAE,CAEnD;IAEK,WAAW,GAChB,OAAO,SAAS,MAAM,EAAE,KACvB,SAAS,aAAa,EAAE,GAAG,SAAS,CAUrC;IAEF;;;;;;;;;OASG;IACH,OAAO,CAAC,KAAK,CAsCX;IAEF,4FAA4F;IAC5F,OAAO,CAAC,MAAM,CAKZ;IAEF,+EAA+E;IAC/E,OAAO,CAAC,IAAI,CAGqC;IAEjD,OAAO,CAAC,UAAU,CAGf;CACJ"}

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.name-match.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Builds a matcher for one advertised name that cannot also match a longer one.
+ *
+ * The vendor tests these names with a substring check in a hand-ordered cascade, so `BP2`
+ * only fails to match a BP2W because `BP2W` happens to be checked first. Order is a fragile
+ * place to keep a safety property: it lives in whoever wrote the list, is invisible at the
+ * point of use, and an insertion in the wrong place silently binds the wrong driver.
+ *
+ * Here the exclusions are derived instead. Every name in the vocabulary that extends this
+ * one becomes a negative lookahead, so the matcher is correct wherever it is used and in
+ * whatever order it is tried.
+ *
+ * The match is deliberately open at the end, because these devices advertise a serial after
+ * the model - `BP2 1234` - and the serial's shape varies across the family.
+ */
+export declare const lepuNameMatch: (name: string, vocabulary?: readonly string[]) => RegExp;
+//# sourceMappingURL=lepu.name-match.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.name-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.name-match.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.name-match.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GACxB,MAAM,MAAM,EACZ,aAAY,SAAS,MAAM,EAAsB,KAChD,MASF,CAAC"}

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.response-type.d.ts

@@ -0,0 +1,33 @@
+/**
+ * What a Lepu device says about the request it just answered.
+ *
+ * Only `SUCCESS` means the payload holds what was asked for. Every other value is an error
+ * whose payload is not the requested data, so a reply has to be checked before it is
+ * decoded - otherwise a refusal is read as a reading, out of whatever bytes happen to
+ * follow the header.
+ */
+declare const LepuResponseType: {
+    /** A request, phone to device. Never seen on a reply. */
+    readonly REQUEST: 0;
+    readonly SUCCESS: 1;
+    /** The device rejected our checksum. */
+    readonly CRC_ERROR: 2;
+    readonly FILE_NOT_FOUND: 224;
+    readonly FILE_READ_FAILED: 225;
+    readonly FILE_WRITE_FAILED: 226;
+    readonly PARAMETER_ILLEGAL: 241;
+    readonly PERMISSION_DENIED: 242;
+    readonly DECRYPT_FAILED: 243;
+    /** Mid-measurement or otherwise occupied. Worth backing off rather than giving up. */
+    readonly DEVICE_BUSY: 251;
+    readonly COMMAND_FORMAT_ERROR: 252;
+    /** The opcode is unknown to this firmware, which is how a feature is detected. */
+    readonly COMMAND_NOT_SUPPORTED: 253;
+    readonly ERROR: 255;
+};
+declare const lepuResponseType: (frame: readonly string[]) => number;
+declare const isLepuSuccess: (frame: readonly string[]) => boolean;
+/** Why a device refused, in words, for an error a person will read. */
+declare const describeLepuResponseType: (frame: readonly string[]) => string;
+export { describeLepuResponseType, isLepuSuccess, LepuResponseType, lepuResponseType, };
+//# sourceMappingURL=lepu.response-type.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.response-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.response-type.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.response-type.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,QAAA,MAAM,gBAAgB;IACpB,yDAAyD;;;IAKzD,wCAAwC;;;;;;;;IAUxC,sFAAsF;;;IAKtF,kFAAkF;;;CAI1E,CAAC;AAiBX,QAAA,MAAM,gBAAgB,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MACP,CAAC;AAE/C,QAAA,MAAM,aAAa,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,OACI,CAAC;AAEvD,uEAAuE;AACvE,QAAA,MAAM,wBAAwB,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MAM5D,CAAC;AAEF,OAAO,EACL,wBAAwB,EACxB,aAAa,EACb,gBAAgB,EAChB,gBAAgB,GACjB,CAAC"}

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.transports.d.ts

@@ -0,0 +1,85 @@
+import { CustomCaseSpec } from "../../../types/custom-case-spec";
+import { CustomDeviceDefinition } from "../../../types/custom-device-definition";
+/**
+ * The characteristics each group of products exposes, read from the vendor's own managers.
+ *
+ * `standard` and `aw1` match the vendor's published SDK reference exactly, and `standard`
+ * also matches the SDK's existing BP2 driver, which has run against hardware on precisely
+ * these UUIDs. `ding` and `aiTele` were read from an OEM build and the vendor documents no
+ * product on them, so they are the two entries here that nothing independent confirms.
+ */
+declare const lepuTransports: {
+    readonly standard: {
+        readonly serviceUuid: "14839ac4-7d7e-415c-9a42-167340cf2339";
+        readonly notifyUuid: "0734594a-a8e7-4b1a-a6b1-cd5243059a57";
+        readonly writeUuid: "8b00ace7-eb0b-49b0-bbe9-9aee0a26e1a3";
+        readonly preferredMtu: 247;
+    };
+    /** The same characteristics on a link that will not grow past the minimum. */
+    readonly standardSmallMtu: {
+        readonly serviceUuid: "14839ac4-7d7e-415c-9a42-167340cf2339";
+        readonly notifyUuid: "0734594a-a8e7-4b1a-a6b1-cd5243059a57";
+        readonly writeUuid: "8b00ace7-eb0b-49b0-bbe9-9aee0a26e1a3";
+        readonly preferredMtu: 23;
+    };
+    readonly aw1: {
+        readonly serviceUuid: "e8fb0001-a14b-98f9-831b-4e2941d01248";
+        readonly notifyUuid: "e8fb0003-a14b-98f9-831b-4e2941d01248";
+        readonly writeUuid: "e8fb0002-a14b-98f9-831b-4e2941d01248";
+        readonly preferredMtu: 247;
+    };
+    readonly ding: {
+        readonly serviceUuid: "0000fe60-0000-1000-8000-00805f9b34fb";
+        readonly notifyUuid: "0000fe62-0000-1000-8000-00805f9b34fb";
+        readonly writeUuid: "0000fe61-0000-1000-8000-00805f9b34fb";
+        readonly preferredMtu: 247;
+    };
+    readonly aiTele: {
+        readonly serviceUuid: "00002760-08c2-11e1-9073-0e8ac72e5450";
+        readonly notifyUuid: "00002760-08c2-11e1-9073-0e8ac72e5402";
+        readonly writeUuid: "00002760-08c2-11e1-9073-0e8ac72e5401";
+        readonly preferredMtu: 247;
+    };
+};
+type LepuTransportName = keyof typeof lepuTransports;
+interface LepuDeviceParams {
+    /** Reported back as deviceData.name, and must not collide with a built-in device. */
+    id: string;
+    /** The name the hardware advertises. */
+    nameMatch: string | RegExp;
+    /** Which characteristics the product exposes. Nearly all of them are "standard". */
+    transport?: LepuTransportName;
+    /**
+     * The models this declaration was written for, as the device reports them.
+     *
+     * Required to poll, and only ever learned from hardware: declare the device without a
+     * `pollCommand` first, connect, and read the model it reports.
+     */
+    expectedDeviceTypes?: number[];
+    /**
+     * The opcode to poll with once the device has proved it is one of those models.
+     *
+     * Leave it out and the device identifies itself and nothing more. That is the safe first
+     * connection to hardware nobody has identified, because the low opcodes in this family
+     * act - one inflates a cuff, another starts an ECG - and mean different things on
+     * different products.
+     */
+    pollCommand?: number;
+    /**
+     * Shortest frame any declared case may be read from. The seven-byte header and the
+     * trailing checksum are part of it, so a one-byte payload is nine.
+     */
+    minLengthBytes: number;
+    /**
+     * Byte offsets that pick the case. The command byte at index 1 is the usual choice, and
+     * products that answer one command with several shapes add the byte that distinguishes
+     * them.
+     */
+    caseSelectorBytes?: number[];
+    cases: CustomCaseSpec[];
+    stuckDataTimeoutMs?: number;
+}
+declare const lepuDevice: (params: LepuDeviceParams) => CustomDeviceDefinition;
+export { lepuDevice, lepuTransports };
+export type { LepuDeviceParams, LepuTransportName };
+//# sourceMappingURL=lepu.transports.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/lepu/lepu.transports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.transports.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.transports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAyEjF;;;;;;;GAOG;AACH,QAAA,MAAM,cAAc;;;;;;;IAQlB,8EAA8E;;;;;;;;;;;;;;;;;;;;;;;;;CA4B9B,CAAC;AAEnD,KAAK,iBAAiB,GAAG,MAAM,OAAO,cAAc,CAAC;AAErD,UAAU,gBAAgB;IAExB,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAC;IAEX,wCAAwC;IACxC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAE3B,oFAAoF;IACpF,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAE9B;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE/B;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE7B,KAAK,EAAE,cAAc,EAAE,CAAC;IAExB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAID,QAAA,MAAM,UAAU,GAAI,QAAQ,gBAAgB,KAAG,sBAiC9C,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;AACtC,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,CAAC"}

package/lib/typescript/module/src/modules/bt-management/services/devices/polling-command-sequencer.d.ts

@@ -0,0 +1,27 @@
+import { CommandSequencer } from "../../types/command-sequencer";
+import { DeviceCommand } from "../../types/device-command";
+import { IMedicalDevice } from "../../types/i-medical-device";
+/**
+ * Sends the same commands on connect and after every frame.
+ *
+ * This is what the SDK did before a device could express anything else, and it remains
+ * right for the devices that only ever ask one question: a poll goes out, a reading comes
+ * back, and the answer is another poll. Keeping it as a named policy rather than as
+ * behaviour built into the transport is what lets a device replace it without every other
+ * device changing.
+ */
+declare class PollingCommandSequencer implements CommandSequencer {
+    private readonly commands;
+    constructor(commands: readonly DeviceCommand[]);
+    initialCommands: () => readonly DeviceCommand[];
+    nextCommand: () => readonly DeviceCommand[];
+}
+/**
+ * Builds the polling policy a device's declared services already describe.
+ *
+ * A service without a write characteristic contributes nothing, so a listen-only device
+ * gets an empty policy and is never written to.
+ */
+declare const pollingSequencerFor: (services: IMedicalDevice["mainService"]) => PollingCommandSequencer;
+export { PollingCommandSequencer, pollingSequencerFor };
+//# sourceMappingURL=polling-command-sequencer.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/polling-command-sequencer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polling-command-sequencer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/modules/bt-management/services/devices/polling-command-sequencer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAG9D;;;;;;;;GAQG;AACH,cAAM,uBAAwB,YAAW,gBAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,SAAS,aAAa,EAAE;IAE/D,eAAe,QAAO,SAAS,aAAa,EAAE,CAAkB;IAEhE,WAAW,QAAO,SAAS,aAAa,EAAE,CAAkB;CACpE;AAED;;;;;GAKG;AACH,QAAA,MAAM,mBAAmB,GACvB,UAAU,cAAc,CAAC,aAAa,CAAC,KACtC,uBAaA,CAAC;AAEJ,OAAO,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,CAAC"}

package/lib/typescript/module/src/modules/bt-management/services/devices/standard-gatt/standard-gatt.devices.d.ts

@@ -0,0 +1,44 @@
+import { CustomDeviceDefinition } from "../../../types/custom-device-definition";
+interface StandardDeviceParams {
+    /** Reported back as deviceData.name, and must not collide with a built-in device. */
+    id: string;
+    /** The name the hardware advertises. */
+    nameMatch: string | RegExp;
+    /** Overrides the default settle time, for hardware slower than most. */
+    stuckDataTimeoutMs?: number;
+}
+/**
+ * Blood Pressure Service 0x1810, Blood Pressure Measurement 0x2A35.
+ *
+ * The pulse rate is deliberately not read. Its offset moves with the timestamp flag, and
+ * every byte a declaration reads must fit inside one `minLengthBytes` for the whole
+ * characteristic - reading it would raise the minimum to sixteen bytes and reject the
+ * shorter frames outright. The pressures sit at bytes 1-4 whatever the flags say, so they
+ * are always safe. A device whose pulse matters needs a device class.
+ */
+declare const standardBloodPressureDevice: (params: StandardDeviceParams) => CustomDeviceDefinition;
+/** Health Thermometer Service 0x1809, Temperature Measurement 0x2A1C. */
+declare const standardThermometerDevice: (params: StandardDeviceParams) => CustomDeviceDefinition;
+/**
+ * Weight Scale Service 0x181D, Weight Measurement 0x2A9D.
+ *
+ * The reading is a scaled integer rather than a float, so the resolution is applied here.
+ */
+declare const standardWeightScaleDevice: (params: StandardDeviceParams) => CustomDeviceDefinition;
+/**
+ * Pulse Oximeter Service 0x1822, PLX Spot-Check Measurement 0x2A5E.
+ *
+ * Saturation and pulse rate are both required by the catalog, which matches the
+ * specification: a spot-check measurement always carries both.
+ */
+declare const standardPulseOximeterDevice: (params: StandardDeviceParams) => CustomDeviceDefinition;
+/**
+ * Heart Rate Service 0x180D, Heart Rate Measurement 0x2A37.
+ *
+ * Only the eight-bit layout is declared. The sixteen-bit variant needs byte 2, which would
+ * raise `minLengthBytes` to three and reject every eight-bit frame - the common case - so it
+ * is left out rather than made to displace it.
+ */
+declare const standardHeartRateDevice: (params: StandardDeviceParams) => CustomDeviceDefinition;
+export { standardBloodPressureDevice, standardHeartRateDevice, standardPulseOximeterDevice, standardThermometerDevice, standardWeightScaleDevice, };
+//# sourceMappingURL=standard-gatt.devices.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/standard-gatt/standard-gatt.devices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-gatt.devices.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/standard-gatt/standard-gatt.devices.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAwBjF,UAAU,oBAAoB;IAE5B,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAC;IAEX,wCAAwC;IACxC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAE3B,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAkED;;;;;;;;GAQG;AACH,QAAA,MAAM,2BAA2B,GAC/B,QAAQ,oBAAoB,KAC3B,sBAaC,CAAC;AAEL,yEAAyE;AACzE,QAAA,MAAM,yBAAyB,GAC7B,QAAQ,oBAAoB,KAC3B,sBAUC,CAAC;AAKL;;;;GAIG;AACH,QAAA,MAAM,yBAAyB,GAC7B,QAAQ,oBAAoB,KAC3B,sBAgBC,CAAC;AAEL;;;;;GAKG;AACH,QAAA,MAAM,2BAA2B,GAC/B,QAAQ,oBAAoB,KAC3B,sBAWC,CAAC;AAEL;;;;;;GAMG;AACH,QAAA,MAAM,uBAAuB,GAC3B,QAAQ,oBAAoB,KAC3B,sBAUC,CAAC;AAEL,OAAO,EACL,2BAA2B,EAC3B,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,yBAAyB,GAC1B,CAAC"}

package/lib/typescript/module/src/modules/bt-management/services/devices/viatom/viatom.bp-monitors.d.ts

@@ -0,0 +1,44 @@
+import { CustomDeviceDefinition } from "../../../types/custom-device-definition";
+interface ViatomBpParams {
+    /** Reported back as deviceData.name, and must not collide with a built-in device. */
+    id: string;
+    /**
+     * The advertised name, defaulting to a matcher for this product that cannot also match a
+     * longer one in the family.
+     */
+    nameMatch?: string | RegExp;
+    /**
+     * The models this declaration may poll, once they are known. Left empty the advertised
+     * name is the identification, which is what the vendor's own SDK binds on.
+     */
+    expectedDeviceTypes?: number[];
+}
+/**
+ * Declares one monitor of the BP2 series.
+ *
+ * `advertisedName` is the name the vendor's SDK matches - `BP2A`, `BP2T` - and the matcher
+ * derived from it excludes every longer name in the family, so a declaration for `BP2`
+ * cannot pick up a `BP2W`.
+ */
+declare const viatomBpMonitor: (advertisedName: string, params: ViatomBpParams) => CustomDeviceDefinition;
+/** BP2A, the arm-cuff monitor of the series. */
+declare const bp2aMonitor: (params: ViatomBpParams) => CustomDeviceDefinition;
+/** BP2T, documented by the vendor alongside BP2 and BP2A as the same protocol. */
+declare const bp2tMonitor: (params: ViatomBpParams) => CustomDeviceDefinition;
+/** BP2W. Documented in its own section, but decoding the same realtime struct. */
+declare const bp2wMonitor: (params: ViatomBpParams) => CustomDeviceDefinition;
+/**
+ * The names the BP3 range advertises.
+ *
+ * Fifteen products differing in cuff and casing rather than in protocol, so declaring the
+ * range is one line per name:
+ *
+ * ```typescript
+ * const bp3Devices = BP3_MODEL_NAMES.map((name) =>
+ *   viatomBpMonitor(name, { id: `viatom-${name.toLowerCase()}` }),
+ * );
+ * ```
+ */
+declare const BP3_MODEL_NAMES: readonly string[];
+export { bp2aMonitor, bp2tMonitor, bp2wMonitor, BP3_MODEL_NAMES, viatomBpMonitor, };
+//# sourceMappingURL=viatom.bp-monitors.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/viatom/viatom.bp-monitors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viatom.bp-monitors.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/viatom/viatom.bp-monitors.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAsFjF,UAAU,cAAc;IAEtB,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAC;IAEX;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE5B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED;;;;;;GAMG;AACH,QAAA,MAAM,eAAe,GACnB,gBAAgB,MAAM,EACtB,QAAQ,cAAc,KACrB,sBAWC,CAAC;AAEL,gDAAgD;AAChD,QAAA,MAAM,WAAW,GAAI,QAAQ,cAAc,KAAG,sBACb,CAAC;AAElC,kFAAkF;AAClF,QAAA,MAAM,WAAW,GAAI,QAAQ,cAAc,KAAG,sBACb,CAAC;AAElC,kFAAkF;AAClF,QAAA,MAAM,WAAW,GAAI,QAAQ,cAAc,KAAG,sBACb,CAAC;AAElC;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,eAAe,EAAE,SAAS,MAAM,EAgBrC,CAAC;AAEF,OAAO,EACL,WAAW,EACX,WAAW,EACX,WAAW,EACX,eAAe,EACf,eAAe,GAChB,CAAC"}

package/lib/typescript/module/src/modules/bt-management/services/devices/viatom/viatom.ecg-recorders.d.ts

@@ -0,0 +1,32 @@
+import { CustomDeviceDefinition } from "../../../types/custom-device-definition";
+interface ViatomEcgParams {
+    /** Reported back as deviceData.name, and must not collide with a built-in device. */
+    id: string;
+    /**
+     * The advertised name, defaulting to a matcher for this product that cannot also match a
+     * longer one in the family.
+     */
+    nameMatch?: string | RegExp;
+    /**
+     * The models this declaration may poll, once they are known. Worth more here than
+     * elsewhere in the family, because of what these opcodes mean on the wrong hardware.
+     */
+    expectedDeviceTypes?: number[];
+}
+/** The ER1, and the handheld recorders sold under other names on the same protocol. */
+declare const er1Recorder: (advertisedName: string, params: ViatomEcgParams) => CustomDeviceDefinition;
+/**
+ * The ER2, which reads the same block but over a link that grants nothing beyond the
+ * minimum. Asking it for the MTU the rest of the family grants is what the vendor's own SDK
+ * declines to do, and a command longer than the link carries is truncated rather than
+ * refused.
+ */
+declare const er2Recorder: (advertisedName: string, params: ViatomEcgParams) => CustomDeviceDefinition;
+/** The ER3, which reads the same parameter block from a different opcode. */
+declare const er3Recorder: (advertisedName: string, params: ViatomEcgParams) => CustomDeviceDefinition;
+/** The names the ER1 recorders advertise. */
+declare const ER1_MODEL_NAMES: readonly string[];
+/** The names the ER2 recorders advertise, all of them on the small-MTU link. */
+declare const ER2_MODEL_NAMES: readonly string[];
+export { er1Recorder, ER1_MODEL_NAMES, er2Recorder, ER2_MODEL_NAMES, er3Recorder, };
+//# sourceMappingURL=viatom.ecg-recorders.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/viatom/viatom.ecg-recorders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viatom.ecg-recorders.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/viatom/viatom.ecg-recorders.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAqDjF,UAAU,eAAe;IAEvB,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAC;IAEX;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE5B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AA4CD,uFAAuF;AACvF,QAAA,MAAM,WAAW,GACf,gBAAgB,MAAM,EACtB,QAAQ,eAAe,KACtB,sBASA,CAAC;AAEJ;;;;;GAKG;AACH,QAAA,MAAM,WAAW,GACf,gBAAgB,MAAM,EACtB,QAAQ,eAAe,KACtB,sBASA,CAAC;AAEJ,6EAA6E;AAC7E,QAAA,MAAM,WAAW,GACf,gBAAgB,MAAM,EACtB,QAAQ,eAAe,KACtB,sBASA,CAAC;AAEJ,6CAA6C;AAC7C,QAAA,MAAM,eAAe,EAAE,SAAS,MAAM,EASrC,CAAC;AAEF,gFAAgF;AAChF,QAAA,MAAM,eAAe,EAAE,SAAS,MAAM,EAA+C,CAAC;AAEtF,OAAO,EACL,WAAW,EACX,eAAe,EACf,WAAW,EACX,eAAe,EACf,WAAW,GACZ,CAAC"}

package/lib/typescript/module/src/modules/bt-management/services/devices/viatom/viatom.lepod.d.ts

@@ -0,0 +1,25 @@
+import { CustomDeviceDefinition } from "../../../types/custom-device-definition";
+interface LepodParams {
+    /** Reported back as deviceData.name, and must not collide with a built-in device. */
+    id: string;
+    /**
+     * The advertised name, defaulting to a matcher for this product that cannot also match a
+     * longer one in the family.
+     */
+    nameMatch?: string | RegExp;
+    /** The models this declaration may poll, once they are known. */
+    expectedDeviceTypes?: number[];
+}
+/**
+ * Declares a Lepod, reporting every reading its realtime frame carries.
+ *
+ * An instrument that is not attached reports a value outside the physiological range for
+ * what it measures, so that reading is discarded and reported while the others in the same
+ * frame are still delivered. The device also marks those conditions in bits of a lead-off
+ * byte, which a declaration cannot select on - reading them quietly needs a device class.
+ */
+declare const lepodMonitor: (advertisedName: string, params: LepodParams) => CustomDeviceDefinition;
+/** The names the Lepod range advertises. */
+declare const LEPOD_MODEL_NAMES: readonly string[];
+export { LEPOD_MODEL_NAMES, lepodMonitor };
+//# sourceMappingURL=viatom.lepod.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/viatom/viatom.lepod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viatom.lepod.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/viatom/viatom.lepod.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAoGjF,UAAU,WAAW;IAEnB,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAC;IAEX;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE5B,iEAAiE;IACjE,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,QAAA,MAAM,YAAY,GAChB,gBAAgB,MAAM,EACtB,QAAQ,WAAW,KAClB,sBAsBC,CAAC;AAEL,4CAA4C;AAC5C,QAAA,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAA0B,CAAC;AAEnE,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC"}

package/lib/typescript/module/src/modules/bt-management/services/devices/viatom/viatom.oximeters.d.ts

@@ -0,0 +1,39 @@
+import { CustomDeviceDefinition } from "../../../types/custom-device-definition";
+interface ViatomOximeterParams {
+    /** Reported back as deviceData.name, and must not collide with a built-in device. */
+    id: string;
+    /**
+     * The advertised name, defaulting to a matcher for this product that cannot also match a
+     * longer one in the family.
+     */
+    nameMatch?: string | RegExp;
+    /**
+     * The models this declaration may poll, once they are known. Left empty the advertised
+     * name is the identification, which is what the vendor's own SDK binds on.
+     */
+    expectedDeviceTypes?: number[];
+}
+/**
+ * Declares one oximeter of the range.
+ *
+ * **A finger that is not in the sensor yields no reading, reported as an error.** The device
+ * answers every poll whether or not it is measuring, and marks an unusable reading in two
+ * bits of a status byte - which a declaration cannot read, because a case is selected by
+ * whole bytes. What it can do is refuse the number: an oxygen saturation measured off the
+ * finger falls outside the physiological range, so it is discarded rather than reported.
+ * The reading is therefore never wrong, but a device left connected with nobody wearing it
+ * reports a decoding failure on each poll. Reading those bits quietly needs a device class.
+ */
+declare const viatomOximeter: (advertisedName: string, params: ViatomOximeterParams) => CustomDeviceDefinition;
+/**
+ * The names the oximeter range advertises.
+ *
+ * ```typescript
+ * const oximeters = VIATOM_OXIMETER_NAMES.map((name) =>
+ *   viatomOximeter(name, { id: `viatom-${name.toLowerCase()}` }),
+ * );
+ * ```
+ */
+declare const VIATOM_OXIMETER_NAMES: readonly string[];
+export { VIATOM_OXIMETER_NAMES, viatomOximeter };
+//# sourceMappingURL=viatom.oximeters.d.ts.map

package/lib/typescript/module/src/modules/bt-management/services/devices/viatom/viatom.oximeters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viatom.oximeters.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/viatom/viatom.oximeters.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AA2BjF,UAAU,oBAAoB;IAE5B,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAC;IAEX;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE5B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED;;;;;;;;;;GAUG;AACH,QAAA,MAAM,cAAc,GAClB,gBAAgB,MAAM,EACtB,QAAQ,oBAAoB,KAC3B,sBAkCC,CAAC;AAEL;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAqB3C,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,CAAC"}