@ovok/native 0.4.6 → 0.4.8

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

@@ -0,0 +1,52 @@
+import { FrameReadResult } from "../../types/frame-read-result";
+import { FrameReader } from "../../types/frame-reader";
+interface SentinelFrameSpec {
+    /** Byte that ends a reply. Excluded from the frame, being framing rather than payload. */
+    terminator: string;
+    /** Byte that begins one, when the device sends one. Also excluded. */
+    start?: string;
+    /**
+     * Longest reply worth waiting for.
+     *
+     * A sentinel protocol has no length field, so a lost terminator is indistinguishable from
+     * a reply that has not finished arriving - the buffer would grow for as long as the link
+     * stayed up. Past this the buffer is dropped and reported, which resynchronises on the
+     * next reply instead of holding a partial one for ever.
+     */
+    maxFrameBytes: number;
+    /**
+     * Bytes that are a whole reply on their own, carrying no delimiters at all.
+     *
+     * Serial protocols answer with a bare acknowledgement as often as with a payload, and a
+     * reader that only knows delimited replies would wait for a terminator that is never
+     * coming. Only the first byte of the buffer is tested, which is the one place a reply can
+     * begin - so a control code inside a payload is still payload.
+     */
+    standaloneBytes?: readonly string[];
+}
+/**
+ * Reads a reply that ends on a sentinel byte rather than declaring its length.
+ *
+ * The Veroval duo control answers this way, as serial protocols generally do: a request is
+ * answered across as many notifications as it takes and the end is marked, not counted. The
+ * reader therefore cannot know how much is coming and holds the buffer until the terminator
+ * lands - which is why the cap exists.
+ *
+ * There is no integrity check to make. A sentinel protocol carries no checksum, so a frame
+ * that reaches a parser here has been delimited, not verified, and whatever decodes it is
+ * the only thing standing between a corrupted reply and a reported reading. Declare a range
+ * for every field.
+ */
+export declare class SentinelFrameReader implements FrameReader {
+    private readonly spec;
+    constructor(spec: SentinelFrameSpec);
+    readFrame(buffer: readonly string[]): FrameReadResult;
+    /**
+     * Where the payload begins: after the start byte when one is declared, and at zero when
+     * none is. A declared start byte that has not arrived means the reply has not begun.
+     */
+    private frameStart;
+    private incompleteOrOverlong;
+}
+export {};
+//# sourceMappingURL=sentinel-frame-reader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sentinel-frame-reader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/modules/bt-management/services/devices/sentinel-frame-reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,UAAU,iBAAiB;IAEzB,0FAA0F;IAC1F,UAAU,EAAE,MAAM,CAAC;IAEnB,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;;OAOG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAID;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IAClC,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,iBAAiB;IAEpD,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,eAAe;IAoC5D;;;OAGG;IACH,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,oBAAoB;CAU7B"}

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

@@ -0,0 +1,53 @@
+import { CustomDeviceDefinition } from "../../../types/custom-device-definition";
+import { StandardDeviceParams } from "./standard-gatt.profile";
+/**
+ * Declarations for the Bluetooth SIG vital-signs profiles.
+ *
+ * These are the profiles a compliant patient device implements, and their layouts come from
+ * the public specification rather than from reading a vendor's app, so they can be written
+ * down exactly instead of inferred.
+ *
+ * The advertised name stays the caller's, because the SDK matches a scan result by name and
+ * every vendor names its hardware differently. A product declares the profile and supplies
+ * the name its own hardware advertises.
+ *
+ * Values are little-endian, as the specification requires. Only the layouts using each
+ * catalog's canonical unit are declared: a device reporting kPa, Fahrenheit or pounds needs
+ * a conversion a declaration cannot express, and leaving those flag values undeclared means
+ * such a device yields no reading rather than one that is quietly wrong.
+ */
+/**
+ * Blood Pressure Service 0x1810, Blood Pressure Measurement 0x2A35.
+ *
+ * The pressures sit at bytes 1-4 whatever the flags say. The pulse rate sits behind two of
+ * them: bit 1 puts a seven-byte timestamp in front of it and bit 2 says whether it is there
+ * at all, so it is read at byte 7 in one shape and byte 14 in the other, and each shape
+ * declares the length it needs. A device that reports no pulse still decodes, because the
+ * flags value it sends selects a case that never looks for one.
+ */
+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/commonjs/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;AAEjF,OAAO,EAGL,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;GAQG;AACH,QAAA,MAAM,2BAA2B,GAC/B,QAAQ,oBAAoB,KAC3B,sBA0BC,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/commonjs/src/modules/bt-management/services/devices/standard-gatt/standard-gatt.profile.d.ts

@@ -0,0 +1,45 @@
+import { MeasurementTypeKey } from "@ovok/core";
+import { CustomDeviceDefinition } from "../../../types/custom-device-definition";
+import { CustomFieldSpec } from "../../../types/custom-field-spec";
+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;
+}
+interface ProfileSpec {
+    service: string;
+    characteristic: string;
+    /** Shortest frame the profile guarantees, which bounds every field a case may read. */
+    minLengthBytes: number;
+    measurementTypeKey: MeasurementTypeKey;
+    /** Flags-byte values whose layout matches `fields`, in canonical units. */
+    selectors: readonly string[];
+    /** Read by every declared case, so only fields that keep their offset across all of them. */
+    fields: readonly CustomFieldSpec[];
+    /**
+     * Fields only some flag combinations carry, keyed by the selector that carries them.
+     *
+     * The flags byte decides which optional fields are present and therefore where the later
+     * ones sit, so a field behind a flag has a different offset in each shape - and a longer
+     * frame to go with it.
+     */
+    optionalFields?: Readonly<Record<string, {
+        fields: CustomFieldSpec[];
+        minLengthBytes: number;
+    }>>;
+}
+declare const sigUuid: (assigned: string) => string;
+/**
+ * The flags byte selects the case, because it decides which optional fields are present and
+ * therefore where the later ones sit. Fields common to every shape are declared once; a
+ * field a flag adds is declared against the selector that carries it, at the offset that
+ * flag combination puts it and with the frame length that shape guarantees.
+ */
+declare const declareProfile: (params: StandardDeviceParams, profile: ProfileSpec) => CustomDeviceDefinition;
+declare const littleEndian: (name: string, byteIndexes: number[], unit: string, encoding: CustomFieldSpec["encoding"]) => CustomFieldSpec;
+export { declareProfile, littleEndian, sigUuid };
+export type { ProfileSpec, StandardDeviceParams };
+//# sourceMappingURL=standard-gatt.profile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standard-gatt.profile.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/standard-gatt/standard-gatt.profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAMnE,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;AAED,UAAU,WAAW;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IAEvB,uFAAuF;IACvF,cAAc,EAAE,MAAM,CAAC;IAEvB,kBAAkB,EAAE,kBAAkB,CAAC;IAEvC,2EAA2E;IAC3E,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAE7B,6FAA6F;IAC7F,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IAEnC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,QAAQ,CACvB,MAAM,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,eAAe,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CACtE,CAAC;CACH;AAED,QAAA,MAAM,OAAO,GAAI,UAAU,MAAM,KAAG,MACW,CAAC;AAEhD;;;;;GAKG;AACH,QAAA,MAAM,cAAc,GAClB,QAAQ,oBAAoB,EAC5B,SAAS,WAAW,KACnB,sBA8BC,CAAC;AAEL,QAAA,MAAM,YAAY,GAChB,MAAM,MAAM,EACZ,aAAa,MAAM,EAAE,EACrB,MAAM,MAAM,EACZ,UAAU,eAAe,CAAC,UAAU,CAAC,KACpC,eAMD,CAAC;AAEH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC;AACjD,YAAY,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC"}

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

@@ -0,0 +1,18 @@
+import { CustomDeviceDefinition } from "../../../types/custom-device-definition";
+interface VerovalBpParams {
+    /** Reported back as deviceData.name, and must not collide with a built-in device. */
+    id: string;
+    /** Overrides the exact-name matcher, for firmware that advertises something else. */
+    nameMatch?: string | RegExp;
+    /** Overrides the default settle time, for hardware slower than most. */
+    stuckDataTimeoutMs?: number;
+}
+declare const verovalCompactMonitor: (advertisedName: string, params: VerovalBpParams) => CustomDeviceDefinition;
+/** BPU 26, the Veroval compact+ upper-arm monitor. */
+declare const bpu26Monitor: (params: VerovalBpParams) => CustomDeviceDefinition;
+/** BPW 26, the Veroval compact+ wrist monitor. */
+declare const bpw26Monitor: (params: VerovalBpParams) => CustomDeviceDefinition;
+/** The names these monitors advertise. */
+declare const VEROVAL_BP_MODEL_NAMES: readonly string[];
+export { bpu26Monitor, bpw26Monitor, VEROVAL_BP_MODEL_NAMES, verovalCompactMonitor, };
+//# sourceMappingURL=veroval.bp-monitors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"veroval.bp-monitors.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/veroval/veroval.bp-monitors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAoBjF,UAAU,eAAe;IAEvB,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAC;IAEX,qFAAqF;IACrF,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE5B,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,QAAA,MAAM,qBAAqB,GACzB,gBAAgB,MAAM,EACtB,QAAQ,eAAe,KACtB,sBAOC,CAAC;AAEL,sDAAsD;AACtD,QAAA,MAAM,YAAY,GAAI,QAAQ,eAAe,KAAG,sBACT,CAAC;AAExC,kDAAkD;AAClD,QAAA,MAAM,YAAY,GAAI,QAAQ,eAAe,KAAG,sBACT,CAAC;AAExC,0CAA0C;AAC1C,QAAA,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAAqB,CAAC;AAEnE,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,sBAAsB,EACtB,qBAAqB,GACtB,CAAC"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/veroval/veroval.duo-control-device.d.ts

@@ -0,0 +1,19 @@
+import { Device } from "react-native-ble-plx";
+import { CreateDeviceParams } from "../../../types/create-device-params";
+import { CustomDeviceId } from "../../../types/custom-device-id";
+import { CustomDevice } from "../custom/custom.device";
+/**
+ * The Veroval duo control.
+ *
+ * A device class rather than a declaration, because reading it is a conversation: the two
+ * user memories are asked in turn, and the device answers with bare control bytes as often
+ * as with payload. The decoding is still declared - the class supplies the framing and the
+ * walk, and nothing else.
+ *
+ * Readings are stored measurements, not live ones. The device hands over its history when
+ * asked, so what arrives was taken before the connection and may be days old.
+ */
+export declare class VerovalDuoControlDevice extends CustomDevice {
+    constructor(device: Device, params: CreateDeviceParams<CustomDeviceId>);
+}
+//# sourceMappingURL=veroval.duo-control-device.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/veroval/veroval.duo-control-device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"veroval.duo-control-device.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/veroval/veroval.duo-control-device.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAoFvD;;;;;;;;;;GAUG;AACH,qBAAa,uBAAwB,SAAQ,YAAY;gBAErD,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,kBAAkB,CAAC,cAAc,CAAC;CAkB7C"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/veroval/veroval.duo-control-sequencer.d.ts

@@ -0,0 +1,45 @@
+import { CommandSequencer } from "../../../types/command-sequencer";
+import { DeviceCommand } from "../../../types/device-command";
+interface DuoControlSequencerParams {
+    /** The characteristic commands are written to. It acknowledges nothing. */
+    write: Omit<DeviceCommand, "frame">;
+    /** Called with why the exchange stopped early. Required, so a refusal is not lost. */
+    onRefused: (reason: string) => void;
+}
+/**
+ * Walks the Veroval duo control through its stored history.
+ *
+ * The device answers one request at a time and holds two user memories, so the exchange is
+ * a fixed walk: ask user one how many records it has, read them, then user two. A memory
+ * that reports none is skipped rather than read.
+ *
+ * Two of its replies are not payload at all. A bare `ACK` means the device has more to send
+ * and is waiting to be asked, which is what `ENQ` does - so an acknowledgement provokes an
+ * enquiry rather than advancing the walk. A bare `NAK` is a refusal and ends it.
+ *
+ * Everything here is derived from HARTMANN's own application. The one part that is an
+ * inference rather than a reading is `ENQ` as flow control: the app writes it on receiving
+ * `ACK`, which is what that pair means in the serial protocol this is descended from, but
+ * the pacing was not observed on hardware.
+ */
+export declare class VerovalDuoControlSequencer implements CommandSequencer {
+    private readonly params;
+    private step;
+    private isDone;
+    constructor(params: DuoControlSequencerParams);
+    initialCommands: () => readonly DeviceCommand[];
+    nextCommand: (frame: readonly string[]) => readonly DeviceCommand[] | undefined;
+    private answerControlByte;
+    /**
+     * A memory reporting no records is skipped. Asking for the data of an empty memory is a
+     * request the device answers with nothing, which would stall the walk on its own reply.
+     */
+    private answerCount;
+    /** Past this memory's data command, to the next memory's count. */
+    private skipMemory;
+    private advance;
+    private stop;
+    private commandFor;
+}
+export {};
+//# sourceMappingURL=veroval.duo-control-sequencer.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/veroval/veroval.duo-control-sequencer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"veroval.duo-control-sequencer.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/veroval/veroval.duo-control-sequencer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAyC9D,UAAU,yBAAyB;IAEjC,2EAA2E;IAC3E,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAEpC,sFAAsF;IACtF,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAaD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,0BAA2B,YAAW,gBAAgB;IAI9C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAH1C,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,MAAM,CAAS;gBAEa,MAAM,EAAE,yBAAyB;IAE9D,eAAe,QAAO,SAAS,aAAa,EAAE,CAAyB;IAEvE,WAAW,GAChB,OAAO,SAAS,MAAM,EAAE,KACvB,SAAS,aAAa,EAAE,GAAG,SAAS,CAgBrC;IAEF,OAAO,CAAC,iBAAiB,CAYvB;IAEF;;;OAGG;IACH,OAAO,CAAC,WAAW,CAUjB;IAEF,mEAAmE;IACnE,OAAO,CAAC,UAAU,CAIhB;IAEF,OAAO,CAAC,OAAO,CAUb;IAEF,OAAO,CAAC,IAAI,CAKV;IAEF,OAAO,CAAC,UAAU,CACmC;CACtD"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/veroval/veroval.ecg-device.d.ts

@@ -0,0 +1,30 @@
+import { Device } from "react-native-ble-plx";
+import { CreateDeviceParams } from "../../../types/create-device-params";
+import { IntegratedDevices } from "../../../types/integrated-devices";
+import { IService } from "../../../types/service.type";
+import { BTManagedDevice } from "../bt-managed-device";
+import { VerovalEcgTransfer } from "./veroval.ecg-transfer";
+/**
+ * The Veroval ECG.
+ *
+ * Reading it is a download rather than a decode, so the whole recording is assembled before
+ * anything is reported: thirty-four seconds of samples at 128 Hz, two bytes each, converted
+ * to millivolts with the device's own calibration.
+ *
+ * The vendor's app plots a thirty-second window of this with a baseline-wander filter
+ * applied. That is a display transform, not calibration, so it is deliberately not
+ * reproduced here - what is reported is what the device recorded.
+ */
+export declare class VerovalEcgDevice extends BTManagedDevice<IntegratedDevices.VEROVAL_ECG> {
+    protected stuckDataTimeout: number;
+    protected preferredMtu: number;
+    protected onStreamStart: undefined;
+    protected mainServices: IService[];
+    protected validatePackage: () => boolean;
+    protected createCommandSequencer: () => VerovalEcgTransfer;
+    constructor(device: Device, params: CreateDeviceParams<IntegratedDevices.VEROVAL_ECG>);
+    /** Nothing is reported per packet; the transfer reports the recording when it is whole. */
+    protected handleSuccessResult(): void;
+    private reportRecording;
+}
+//# sourceMappingURL=veroval.ecg-device.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/veroval/veroval.ecg-device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"veroval.ecg-device.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/veroval/veroval.ecg-device.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAMvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAgC5D;;;;;;;;;;GAUG;AACH,qBAAa,gBAAiB,SAAQ,eAAe,CAAC,iBAAiB,CAAC,WAAW,CAAC;IAClF,SAAS,CAAC,gBAAgB,SAAoB;IAC9C,UAAmB,YAAY,SAAiB;IAChD,SAAS,CAAC,aAAa,YAAa;IAEpC,SAAS,CAAC,YAAY,EAAE,QAAQ,EAAE,CAKhC;IAEF,UAAmB,eAAe,QAAO,OAAO,CAAS;IAEzD,UAAmB,sBAAsB,2BAIpC;gBAGH,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,WAAW,CAAC;IAK3D,2FAA2F;IAC3F,SAAS,CAAC,mBAAmB,IAAI,IAAI;IAIrC,OAAO,CAAC,eAAe,CAerB;CACH"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/veroval/veroval.ecg-samples.d.ts

@@ -0,0 +1,39 @@
+/**
+ * How fast the device samples.
+ *
+ * Not taken on trust: the vendor's own plotting step works out to two two-hundred-and-fifty
+ * sixths of a second, and its transfer is thirty-four segments of sixteen packets of sixteen
+ * bytes - which is 256 bytes, 128 samples, one second per segment. Both say 128 Hz.
+ */
+declare const VEROVAL_ECG_SAMPLE_RATE_HZ = 128;
+/**
+ * The calibration the recording is read with.
+ *
+ * This is the EDF convention - a linear map from counts onto a physical range - and the
+ * device states its own in the header it sends before the curve. These are the values the
+ * vendor's app falls back to, and are what the SDK uses until a header supplies otherwise:
+ * the full signed sixteen-bit range spans plus or minus 27.68 mV.
+ */
+declare const DEFAULT_CALIBRATION: {
+    readonly physicalMinimumMicrovolts: -27680;
+    readonly physicalMaximumMicrovolts: 27680;
+    readonly digitalMinimum: -32768;
+    readonly digitalMaximum: 32767;
+};
+interface EcgCalibration {
+    physicalMinimumMicrovolts: number;
+    physicalMaximumMicrovolts: number;
+    digitalMinimum: number;
+    digitalMaximum: number;
+}
+/**
+ * Turns the bytes of a recording into millivolts.
+ *
+ * A trailing odd byte is ignored: half a sample is not a sample. The conversion is the
+ * device's own, applied as it states it rather than reduced to a single factor, so a header
+ * that reports a different range still decodes correctly.
+ */
+declare const decodeVerovalEcgSamples: (bytes: readonly string[], calibration?: EcgCalibration) => number[];
+export { decodeVerovalEcgSamples, DEFAULT_CALIBRATION, VEROVAL_ECG_SAMPLE_RATE_HZ, };
+export type { EcgCalibration };
+//# sourceMappingURL=veroval.ecg-samples.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/veroval/veroval.ecg-samples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"veroval.ecg-samples.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/veroval/veroval.ecg-samples.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,QAAA,MAAM,0BAA0B,MAAM,CAAC;AAEvC;;;;;;;GAOG;AACH,QAAA,MAAM,mBAAmB;;;;;CAKf,CAAC;AAIX,UAAU,cAAc;IACtB,yBAAyB,EAAE,MAAM,CAAC;IAClC,yBAAyB,EAAE,MAAM,CAAC;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB;AAWD;;;;;;GAMG;AACH,QAAA,MAAM,uBAAuB,GAC3B,OAAO,SAAS,MAAM,EAAE,EACxB,cAAa,cAAoC,KAChD,MAAM,EAsBR,CAAC;AAEF,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,0BAA0B,GAC3B,CAAC;AACF,YAAY,EAAE,cAAc,EAAE,CAAC"}

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/veroval/veroval.ecg-transfer.d.ts

@@ -0,0 +1,35 @@
+import { CommandSequencer } from "../../../types/command-sequencer";
+import { DeviceCommand } from "../../../types/device-command";
+interface EcgTransferParams {
+    /** The characteristic requests are written to. */
+    write: Omit<DeviceCommand, "frame">;
+    /** Called once, with the recording's bytes, when every segment has arrived. */
+    onRecording: (bytes: readonly string[]) => void;
+}
+/**
+ * Downloads a recording from the Veroval ECG.
+ *
+ * The exchange is a fixed walk rather than a conversation: ask for the download mode, then
+ * the header, then each second of the recording in turn. The device answers each request
+ * with a known number of twenty-byte packets, sixteen payload bytes each, so the transfer is
+ * paced by counting them - which is how the vendor's own app paces it, and is the only thing
+ * that distinguishes one phase's packets from another's.
+ *
+ * A recording is thirty-four seconds at 128 Hz. Nothing is reported until all of it has
+ * arrived: a partial ECG that looked whole would be worse than none, and the count is what
+ * says it is whole.
+ */
+export declare class VerovalEcgTransfer implements CommandSequencer {
+    private readonly params;
+    private phase;
+    private packets;
+    private segment;
+    private recording;
+    constructor(params: EcgTransferParams);
+    initialCommands: () => readonly DeviceCommand[];
+    nextCommand: (frame: readonly string[]) => readonly DeviceCommand[] | undefined;
+    private finishSegment;
+    private requestSegment;
+}
+export {};
+//# sourceMappingURL=veroval.ecg-transfer.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/services/devices/veroval/veroval.ecg-transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"veroval.ecg-transfer.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/veroval/veroval.ecg-transfer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAgD9D,UAAU,iBAAiB;IAEzB,kDAAkD;IAClD,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAEpC,+EAA+E;IAC/E,WAAW,EAAE,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,IAAI,CAAC;CACjD;AAID;;;;;;;;;;;;GAYG;AACH,qBAAa,kBAAmB,YAAW,gBAAgB;IAMtC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAL1C,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,SAAS,CAAgB;gBAEG,MAAM,EAAE,iBAAiB;IAEtD,eAAe,QAAO,SAAS,aAAa,EAAE,CAEnD;IAEK,WAAW,GAChB,OAAO,SAAS,MAAM,EAAE,KACvB,SAAS,aAAa,EAAE,GAAG,SAAS,CAyBrC;IAEF,OAAO,CAAC,aAAa,CAWnB;IAEF,OAAO,CAAC,cAAc,CAQpB;CACH"}

package/lib/typescript/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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"}

package/lib/typescript/commonjs/src/modules/bt-management/types/command-sequencer.d.ts

@@ -0,0 +1,26 @@
+import { DeviceCommand } from "./device-command";
+/**
+ * Decides what to send a device, and when.
+ *
+ * These protocols are self-clocking: the device answers a request, and the answer is what
+ * says which request comes next. A file read walks its offsets that way, and an identity
+ * check gates everything after it on the reply to the first command. Neither can be
+ * expressed by re-sending one fixed frame, which is all the SDK could do before.
+ *
+ * At most one command is outstanding at a time. The transport serialises writes, so an
+ * implementation may assume the frame it is answering is the reply to the command it last
+ * returned.
+ */
+export interface CommandSequencer {
+    /** Sent once every characteristic is subscribed. Empty starts a device that only listens. */
+    initialCommands(): readonly DeviceCommand[];
+    /**
+     * Answers one complete frame.
+     *
+     * Returning `undefined` sends nothing, which is how a sequencer waits: an unidentified
+     * device is left alone rather than addressed with an opcode that may mean something else
+     * on the hardware actually present.
+     */
+    nextCommand(frame: readonly string[]): readonly DeviceCommand[] | undefined;
+}
+//# sourceMappingURL=command-sequencer.d.ts.map

package/lib/typescript/commonjs/src/modules/bt-management/types/command-sequencer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-sequencer.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/bt-management/types/command-sequencer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAE/B,6FAA6F;IAC7F,eAAe,IAAI,SAAS,aAAa,EAAE,CAAC;IAE5C;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,aAAa,EAAE,GAAG,SAAS,CAAC;CAC7E"}