@ovok/native 0.4.6 → 0.4.8

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

@@ -0,0 +1 @@
+{"version":3,"file":"lepu.device-names.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/modules/bt-management/services/devices/lepu/lepu.device-names.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAsM9C,CAAC"}

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/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/module/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/module/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/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;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/module/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/module/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/module/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/module/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"}