@tempivo/sensor-beacon 0.1.0 → 0.2.0

package/android/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorProfile.kt

@@ -0,0 +1,171 @@
+package com.tempivo.sensor.beacon
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+data class TempivoTemperatureAlert(
+    val type: String,
+    val channel: String,
+    val lowC: Double? = null,
+    val highC: Double? = null,
+    val minC: Double? = null,
+    val maxC: Double? = null,
+    val hysteresisC: Double? = null,
+    val transmitOnBreach: Boolean = true,
+    val transmitOnReturn: Boolean = true,
+)
+
+data class TempivoSchedule(
+    val always: Boolean,
+    val weekdays: List<Int> = emptyList(),
+    val from: String? = null,
+    val to: String? = null,
+    val utcOffsetMinutes: Int = 0,
+)
+
+data class TempivoSensorConfiguration(
+    val temperatureAlerts: List<TempivoTemperatureAlert>,
+    val schedule: TempivoSchedule,
+)
+
+object TempivoSensorProfile {
+    private val timeRe = Regex("^([01]\\d|2[0-3]):([0-5]\\d)$")
+
+    fun parseJson(json: String): TempivoSensorConfiguration {
+        val root =
+            try {
+                JSONObject(json)
+            } catch (_: Exception) {
+                throw TempivoSensorException(TempivoSensorException.Code.INVALID_CONFIG, "Configuration is not valid JSON.")
+            }
+        return parse(root)
+    }
+
+    fun parse(root: JSONObject): TempivoSensorConfiguration {
+        if (root.has("profiles") && root.optJSONArray("profiles") != null) {
+            throw invalid("Pass one profile from GET /devices/config-profiles/{slug}, not the list.")
+        }
+        val body =
+            root.optJSONObject("profile")?.takeIf {
+                it.has("temperatureAlerts") || it.has("schedule") || it.has("slug")
+            } ?: root
+        if (!body.has("temperatureAlerts") && body.has("alarmRules")) {
+            throw invalid("Use a config profile with temperatureAlerts (GET /devices/config-profiles/{slug}), not alarmRules.")
+        }
+        val alerts = mutableListOf<TempivoTemperatureAlert>()
+        val arr = body.optJSONArray("temperatureAlerts") ?: JSONArray()
+        for (i in 0 until arr.length()) {
+            val item = arr.optJSONObject(i) ?: throw invalid("temperatureAlerts[$i] must be an object.")
+            alerts.add(parseAlert(item, i))
+        }
+        return TempivoSensorConfiguration(alerts, parseSchedule(body.optJSONObject("schedule")))
+    }
+
+    fun toJson(cfg: TempivoSensorConfiguration): String {
+        val root = JSONObject()
+        val arr = JSONArray()
+        for (a in cfg.temperatureAlerts) {
+            val o = JSONObject()
+            o.put("type", a.type)
+            o.put("channel", a.channel)
+            if (a.lowC != null) o.put("lowC", a.lowC)
+            if (a.highC != null) o.put("highC", a.highC)
+            if (a.minC != null) o.put("minC", a.minC)
+            if (a.maxC != null) o.put("maxC", a.maxC)
+            if (a.hysteresisC != null) o.put("hysteresisC", a.hysteresisC)
+            o.put("transmitOnBreach", a.transmitOnBreach)
+            if (a.type == "range") o.put("transmitOnReturn", a.transmitOnReturn)
+            arr.put(o)
+        }
+        root.put("temperatureAlerts", arr)
+        val s = JSONObject()
+        if (cfg.schedule.always) {
+            s.put("always", true)
+        } else {
+            val days = JSONArray()
+            cfg.schedule.weekdays.forEach { days.put(it) }
+            s.put("weekdays", days)
+            s.put("from", cfg.schedule.from)
+            s.put("to", cfg.schedule.to)
+            s.put("utcOffsetMinutes", cfg.schedule.utcOffsetMinutes)
+        }
+        root.put("schedule", s)
+        return root.toString()
+    }
+
+    private fun parseAlert(item: JSONObject, index: Int): TempivoTemperatureAlert {
+        val channel = item.optString("channel")
+        if (channel != "ambient" && channel != "probe") {
+            throw invalid("temperatureAlerts[$index].channel must be ambient or probe.")
+        }
+        val hysteresis = if (item.has("hysteresisC") && !item.isNull("hysteresisC")) item.optDouble("hysteresisC") else 1.0
+        val transmit = if (item.has("transmitOnBreach")) item.optBoolean("transmitOnBreach", true) else true
+        val transmitOnReturn = if (item.has("transmitOnReturn")) item.optBoolean("transmitOnReturn", true) else true
+        return when (item.optString("type")) {
+            "range" -> {
+                if (!item.has("lowC") || !item.has("highC")) {
+                    throw invalid("temperatureAlerts[$index] needs lowC and highC.")
+                }
+                val low = item.optDouble("lowC")
+                val high = item.optDouble("highC")
+                if (high <= low) throw invalid("temperatureAlerts[$index]: highC must be greater than lowC.")
+                TempivoTemperatureAlert(
+                    "range",
+                    channel,
+                    lowC = low,
+                    highC = high,
+                    hysteresisC = hysteresis,
+                    transmitOnBreach = transmit,
+                    transmitOnReturn = transmitOnReturn,
+                )
+            }
+            "min" -> {
+                if (!item.has("minC")) throw invalid("temperatureAlerts[$index] needs minC.")
+                TempivoTemperatureAlert("min", channel, minC = item.optDouble("minC"), hysteresisC = hysteresis, transmitOnBreach = transmit)
+            }
+            "max" -> {
+                if (!item.has("maxC")) throw invalid("temperatureAlerts[$index] needs maxC.")
+                TempivoTemperatureAlert("max", channel, maxC = item.optDouble("maxC"), hysteresisC = hysteresis, transmitOnBreach = transmit)
+            }
+            else -> throw invalid("temperatureAlerts[$index].type must be range, min, or max.")
+        }
+    }
+
+    private fun parseSchedule(raw: JSONObject?): TempivoSchedule {
+        if (raw == null || raw.optBoolean("always", false)) return TempivoSchedule(always = true)
+        val weekdays = raw.optJSONArray("weekdays") ?: throw invalid("schedule.weekdays is required.")
+        val days = mutableListOf<Int>()
+        for (i in 0 until weekdays.length()) {
+            val n = weekdays.optInt(i, -1)
+            if (n !in 0..6) throw invalid("schedule.weekdays must be 0 to 6.")
+            days.add(n)
+        }
+        if (days.isEmpty()) throw invalid("schedule.weekdays is required.")
+        val from = raw.optString("from")
+        val to = raw.optString("to")
+        if (!timeRe.matches(from) || !timeRe.matches(to)) {
+            throw invalid("schedule.from and schedule.to must be HH:MM.")
+        }
+        if (!raw.has("utcOffsetMinutes")) throw invalid("schedule.utcOffsetMinutes is required.")
+        return TempivoSchedule(
+            always = false,
+            weekdays = days,
+            from = from,
+            to = to,
+            utcOffsetMinutes = raw.optInt("utcOffsetMinutes"),
+        )
+    }
+
+    fun minutesFromHhmm(value: String): Int {
+        val m = timeRe.matchEntire(value) ?: throw invalid("Invalid time $value.")
+        return m.groupValues[1].toInt() * 60 + m.groupValues[2].toInt()
+    }
+
+    fun hhmmFromMinutes(minutes: Int): String {
+        val clamped = minutes.coerceIn(0, 1439)
+        return String.format(java.util.Locale.US, "%02d:%02d", clamped / 60, clamped % 60)
+    }
+
+    private fun invalid(message: String): TempivoSensorException =
+        TempivoSensorException(TempivoSensorException.Code.INVALID_CONFIG, message)
+}

package/android/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorQr.kt

@@ -0,0 +1,82 @@
+package com.tempivo.sensor.beacon
+
+import org.json.JSONObject
+import java.util.Locale
+
+data class TempivoSensorQr(
+    val serial: String,
+    val pin: String,
+    val model: String?,
+    val sessionType: TempivoSensorSession.SessionType,
+    val bluetoothMac: String,
+)
+
+object TempivoSensorQrParser {
+    const val DEFAULT_MODEL = "HC7"
+
+    fun normalizeSerial(value: String): String =
+        value.trim().uppercase(Locale.US).replace(Regex("[^A-Z0-9]"), "")
+
+    fun bluetoothMacFromSerial(serial: String): String {
+        val key = normalizeSerial(serial)
+        if (key.length != 12 || !key.matches(Regex("[0-9A-F]{12}"))) {
+            throw TempivoSensorException(TempivoSensorException.Code.INVALID_QR, "Serial must be 12 hex characters.")
+        }
+        return buildString(17) {
+            for (i in 0 until 12 step 2) {
+                if (isNotEmpty()) append(':')
+                append(key, i, i + 2)
+            }
+        }
+    }
+
+    fun sessionTypeFromModel(model: String?): TempivoSensorSession.SessionType {
+        if (model.isNullOrBlank()) return TempivoSensorSession.SessionType.MODERN
+        val m = model.trim().uppercase(Locale.US).replace("-", "")
+        return if (m == "HC5" || m.startsWith("6")) {
+            TempivoSensorSession.SessionType.LEGACY
+        } else {
+            TempivoSensorSession.SessionType.MODERN
+        }
+    }
+
+    fun parse(json: String): TempivoSensorQr {
+        val rec =
+            try {
+                JSONObject(json.trim())
+            } catch (_: Exception) {
+                throw TempivoSensorException(TempivoSensorException.Code.INVALID_QR, "QR is not valid JSON.")
+            }
+        val snRaw =
+            when {
+                rec.has("sn") && !rec.isNull("sn") -> rec.opt("sn")?.toString().orEmpty()
+                else -> ""
+            }
+        val serial = normalizeSerial(snRaw)
+        val pin = pinFrom(rec)
+        if (serial.length < 8) {
+            throw TempivoSensorException(TempivoSensorException.Code.INVALID_QR, "QR is missing serial (sn).")
+        }
+        if (pin.isEmpty()) {
+            throw TempivoSensorException(TempivoSensorException.Code.INVALID_QR, "QR is missing PIN.")
+        }
+        val model = rec.optString("model").trim().ifEmpty { DEFAULT_MODEL }
+        val hex = if (serial.length == 12) serial else serial.takeLast(12)
+        return TempivoSensorQr(
+            serial = serial,
+            pin = pin,
+            model = model,
+            sessionType = sessionTypeFromModel(model),
+            bluetoothMac = bluetoothMacFromSerial(hex),
+        )
+    }
+
+    private fun pinFrom(rec: JSONObject): String {
+        val raw = if (rec.has("pin") && !rec.isNull("pin")) rec.opt("pin") else rec.opt("resetCode")
+        return when (raw) {
+            null, JSONObject.NULL -> ""
+            is Number -> raw.toLong().toString()
+            else -> raw.toString().trim()
+        }
+    }
+}

package/android/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorSession.kt

@@ -0,0 +1,114 @@
+package com.tempivo.sensor.beacon
+
+import android.app.Application
+import android.content.Context
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+
+/**
+ * GATT session: connect, read/write alert rules and schedule, trigger uplink, read lab calibration date.
+ */
+class TempivoSensorSession(
+    context: Context,
+) {
+    enum class SessionType {
+        MODERN,
+        LEGACY,
+    }
+
+    data class TriggerResult(
+        val ok: Boolean,
+        val supported: Boolean,
+    )
+
+    private val application = context.applicationContext as Application
+    private val mutex = Mutex()
+    private var session: SensorBleRuntime.Session? = null
+
+    suspend fun connect(
+        serial: String,
+        bluetoothMac: String,
+        pin: String,
+        sessionType: SessionType = SessionType.MODERN,
+    ) {
+        val pinInt =
+            pin.trim().toIntOrNull()
+                ?: throw TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "PIN must be numeric.")
+        try {
+            mutex.withLock {
+                SensorBleRuntime.disconnect(session)
+                session = null
+                session =
+                    withContext(Dispatchers.Main) {
+                        SensorBleRuntime.connect(
+                            application = application,
+                            serial = TempivoSensorQrParser.normalizeSerial(serial),
+                            bluetoothMac = bluetoothMac,
+                            pin = pinInt,
+                            legacy = sessionType == SessionType.LEGACY,
+                        )
+                    }
+            }
+        } catch (e: Throwable) {
+            throw SensorBleRuntime.mapError(e).let {
+                if (it.code == TempivoSensorException.Code.UNKNOWN) {
+                    TempivoSensorException(TempivoSensorException.Code.CONNECT_FAILED, "Could not connect.", e)
+                } else {
+                    it
+                }
+            }
+        }
+    }
+
+    suspend fun connect(qr: TempivoSensorQr) {
+        connect(qr.serial, qr.bluetoothMac, qr.pin, qr.sessionType)
+    }
+
+    suspend fun disconnect() {
+        mutex.withLock {
+            SensorBleRuntime.disconnect(session)
+            session = null
+        }
+    }
+
+    suspend fun getConfiguration(): TempivoSensorConfiguration {
+        return runGatt {
+            SensorBleRuntime.decompile(SensorBleRuntime.readConfiguration(requireSession()))
+        }
+    }
+
+    suspend fun getConfigurationJson(): String = TempivoSensorProfile.toJson(getConfiguration())
+
+    suspend fun setConfiguration(configuration: TempivoSensorConfiguration) {
+        val (rules, calendars) = SensorBleRuntime.compileRules(configuration)
+        runGatt {
+            SensorBleRuntime.writeRules(requireSession(), rules, calendars)
+        }
+    }
+
+    suspend fun setConfigurationJson(json: String) {
+        setConfiguration(TempivoSensorProfile.parseJson(json))
+    }
+
+    suspend fun triggerTransmission(): TriggerResult {
+        return runGatt { SensorBleRuntime.triggerTransmission(requireSession()) }
+    }
+
+    suspend fun getCalibration(): TempivoSensorCalibration {
+        return runGatt { SensorBleRuntime.readCalibration(requireSession()) }
+    }
+
+    private fun requireSession(): SensorBleRuntime.Session =
+        session
+            ?: throw TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.")
+
+    private suspend fun <T> runGatt(block: suspend () -> T): T {
+        try {
+            return mutex.withLock { block() }
+        } catch (e: Throwable) {
+            throw SensorBleRuntime.mapError(e)
+        }
+    }
+}

package/android/settings.gradle

@@ -0,0 +1,19 @@
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+        maven { url "https://maven.efento.io/releases" }
+    }
+}
+
+rootProject.name = "tempivo-sensor-beacon"
+include(":library")

package/dist/calibration.d.ts

@@ -0,0 +1,7 @@
+import type { TempivoSensorCalibration } from './session-types.js';
+/**
+ * Device extended config may send lab date as Unix seconds or as days since 1970.
+ * Values below 100_000 are treated as days (year 2243 in seconds, year 2243 in days is far larger).
+ */
+export declare function decodeLaboratoryCalibrationTimestamp(raw: number | null | undefined): TempivoSensorCalibration;
+export declare function calibrationFromExtendedJson(json: string): TempivoSensorCalibration;

package/dist/calibration.js

@@ -0,0 +1,42 @@
+const SECONDS_PER_DAY = 86_400;
+function pad2(n) {
+    return n < 10 ? `0${n}` : String(n);
+}
+function isoDateUtcFromUnixSeconds(seconds) {
+    const d = new Date(seconds * 1000);
+    return `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+}
+function isoDateUtcFromEpochDays(days) {
+    return isoDateUtcFromUnixSeconds(days * SECONDS_PER_DAY);
+}
+/**
+ * Device extended config may send lab date as Unix seconds or as days since 1970.
+ * Values below 100_000 are treated as days (year 2243 in seconds, year 2243 in days is far larger).
+ */
+export function decodeLaboratoryCalibrationTimestamp(raw) {
+    if (raw == null || !Number.isFinite(raw) || raw <= 0) {
+        return { laboratoryCalibrationDate: null, laboratoryCalibrationTimestamp: null };
+    }
+    const n = Math.trunc(raw);
+    if (n < 100_000) {
+        return {
+            laboratoryCalibrationDate: isoDateUtcFromEpochDays(n),
+            laboratoryCalibrationTimestamp: n,
+        };
+    }
+    return {
+        laboratoryCalibrationDate: isoDateUtcFromUnixSeconds(n),
+        laboratoryCalibrationTimestamp: n,
+    };
+}
+export function calibrationFromExtendedJson(json) {
+    try {
+        const o = JSON.parse(json);
+        const raw = o.laboratoryCalibrationTimestamp ?? o.laboratory_calibration_date;
+        const n = typeof raw === 'number' ? raw : typeof raw === 'string' ? Number(raw) : null;
+        return decodeLaboratoryCalibrationTimestamp(Number.isFinite(n) ? n : null);
+    }
+    catch {
+        return { laboratoryCalibrationDate: null, laboratoryCalibrationTimestamp: null };
+    }
+}

package/dist/decoder.js

@@ -47,29 +47,29 @@ function unitForType(mtype) {
 export function decodeMeasurementSlot(mtype, raw24) {
     const spec = MEASURE_SPECS.get(mtype);
     if (!spec) {
-        return `0x${mtype.toString(16).padStart(2, '0').toUpperCase()}: raw 0x${(raw24 & 0xffffff).toString(16).padStart(6, '0')}`;
+        return `0x${mtype.toString(16).padStart(2, '0').toUpperCase()}: 0x${(raw24 & 0xffffff).toString(16).padStart(6, '0')}`;
     }
     if (!spec.continuous) {
-        return `${spec.name}: (binary / status)`;
+        return '(status)';
     }
     const z = zigzagDecode24(raw24);
     if (spec.metaFactor === 1) {
         const v = z * spec.resolution;
         const unit = unitForType(mtype);
         const num = formatNum(v, mtype);
-        return unit ? `${spec.name} ${num} ${unit}` : `${spec.name} ${num}`;
+        return unit ? `${num} ${unit}` : num;
     }
     if (mtype === 0x06) {
         const iaq = z % (1 << 9);
         const cal = (z >> 9) & 0x03;
         const calS = ['not_stab', 'cal_req', 'cal_ongoing', 'cal_done'][Math.min(cal, 3)];
-        return `${spec.name} ${iaq} (${calS})`;
+        return `${iaq} (${calS})`;
     }
     if (mtype === 0x1a || mtype === 0x1c || mtype === 0x1d || mtype === 0x1e) {
         const v = (z / spec.metaFactor) * spec.resolution;
-        return `${spec.name} ${v}`;
+        return String(v);
     }
-    return `${spec.name} z=${z}`;
+    return String(z);
 }
 function parsedValuesFromSlot(mtype, raw24) {
     const spec = MEASURE_SPECS.get(mtype);
@@ -151,9 +151,7 @@ function fw5Summary(frame) {
     return `FW 5.x ${maj}.${min} (limited broadcast decode)`;
 }
 function serialMacFromAdv03(frame) {
-    return Array.from(frame.subarray(1, 7))
-        .map((x) => (x & 0xff).toString(16).padStart(2, '0').toUpperCase())
-        .join(':');
+    return serialKeyFromAdv03Frame(frame) ?? '';
 }
 function parseFw6Adv03(frame) {
     if (frame.length < ADV_FRAME_03_LEN)
@@ -183,9 +181,7 @@ function parseFw6Adv03(frame) {
         measurementCounter: ts >>> 0,
         readingTimestampUnix: ts,
         readingTimestampIso,
-        periodBaseSeconds: pbase,
-        periodFactor: pfact,
-        periodLabel: `${pbase}s × ${pfact}`,
+        measurementIntervalSeconds: pbase * pfact,
     };
 }
 function parseScan04(frame) {
@@ -230,9 +226,7 @@ export function buildSensorBeaconReading(adv03, adv04, rawHex = '') {
         measurementCounter: null,
         readingTimestampUnix: null,
         readingTimestampIso: null,
-        periodBaseSeconds: null,
-        periodFactor: null,
-        periodLabel: '',
+        measurementIntervalSeconds: null,
     };
     if (adv03?.length) {
         const tag = u8(adv03, 0);
@@ -282,9 +276,7 @@ export function buildSensorBeaconReading(adv03, adv04, rawHex = '') {
         measurementCounter: base.measurementCounter ?? null,
         readingTimestampUnix: base.readingTimestampUnix ?? null,
         readingTimestampIso: base.readingTimestampIso ?? null,
-        periodBaseSeconds: base.periodBaseSeconds ?? null,
-        periodFactor: base.periodFactor ?? null,
-        periodLabel: base.periodLabel || '—',
+        measurementIntervalSeconds: base.measurementIntervalSeconds ?? null,
         measurements,
         summary: sumOut,
         temperatures,

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+/** Partner-facing error codes. Native runtimes map internal exceptions to these. */
+export type TempivoSensorErrorCode = 'invalidPin' | 'invalidQr' | 'invalidConfig' | 'notConnected' | 'unsupportedCommand' | 'runtimeUnavailable' | 'connectFailed' | 'unknown';
+export declare class TempivoSensorError extends Error {
+    readonly code: TempivoSensorErrorCode;
+    constructor(code: TempivoSensorErrorCode, message: string);
+}

package/dist/errors.js

@@ -0,0 +1,8 @@
+export class TempivoSensorError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'TempivoSensorError';
+        this.code = code;
+    }
+}

package/dist/index.d.ts

@@ -1,5 +1,10 @@
-export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, legacyHintFromFirmware, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
 export { ingestManufacturerPayload } from './ingest.js';
 export { dataViewToUint8Array, normalizeManufacturerBytes } from './normalize.js';
 export { MEASURE_SPECS, type MeasureSpec } from './measure-specs.js';
 export { createSensorBeaconFrameCache, type SensorBeaconFrameCache, type SensorBeaconMeasurement, type SensorBeaconReading, } from './types.js';
+export { TempivoSensorError, type TempivoSensorErrorCode } from './errors.js';
+export { DEFAULT_SENSOR_MODEL, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
+export { DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
+export type { TempivoSchedule, TempivoScheduleAlways, TempivoScheduleWeek, TempivoSensorCalibration, TempivoSensorConfiguration, TempivoSensorQr, TempivoSensorSessionType, TempivoTemperatureAlert, TempivoTemperatureChannel, TempivoTemperatureMaxAlert, TempivoTemperatureMinAlert, TempivoTemperatureRangeAlert, TempivoTriggerTransmissionResult, } from './session-types.js';

package/dist/index.js

@@ -1,5 +1,9 @@
-export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, legacyHintFromFirmware, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
 export { ingestManufacturerPayload } from './ingest.js';
 export { dataViewToUint8Array, normalizeManufacturerBytes } from './normalize.js';
 export { MEASURE_SPECS } from './measure-specs.js';
 export { createSensorBeaconFrameCache, } from './types.js';
+export { TempivoSensorError } from './errors.js';
+export { DEFAULT_SENSOR_MODEL, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
+export { DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';

package/dist/profile.d.ts

@@ -0,0 +1,10 @@
+import type { TempivoSensorConfiguration } from './session-types.js';
+/** Same default as Cellular API config profiles. */
+export declare const DEFAULT_ALERT_HYSTERESIS_C = 1;
+/** Validate Cellular API config-profile JSON for BLE setConfiguration. */
+export declare function parseSensorConfiguration(input: unknown): TempivoSensorConfiguration;
+/** Same as {@link parseSensorConfiguration}: GET `{ profile }` or the profile object. */
+export declare const configurationFromApiProfile: typeof parseSensorConfiguration;
+export declare function parseSensorConfigurationJson(json: string): TempivoSensorConfiguration;
+export declare function compileSensorProfileToBleJson(input: unknown): string;
+export declare function pickPartnerConfigurationJson(json: string): string;