@tempivo/sensor-beacon 1.1.7 → 1.1.9

package/CHANGELOG.md

@@ -6,6 +6,29 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.1.9] - 2026-10-14
+
+### Changed
+
+- npm package metadata: drop private GitHub `repository` so npmjs.com no longer links Changelog / bugs to an inaccessible repo. Changelog remains in the published package (`CHANGELOG.md`).
+
+## [1.1.8] - 2026-10-14
+
+### Added
+
+- Cellular (HC7 native): `getCellularNetworkStatus()` returns short partner labels (`label`, `statusLabel`, `operatorName`, `summary`, `tone`; `locale`: `en` \| `sv`), same vocabulary as the Tempivo app (No SIM, No internet, No server, Server OK, Telia Sweden, …). Raw GATT JSON via `getCellularNetworkStatusJson()`.
+- Pure helpers (no radio): `cellularNetworkStatusViewFromJson`, `parseCellularNetworkStatusJson`, `formatCellularNetworkStatusLabel`, `getOperatorNameFromPlmn`, and related exports.
+- `setOperator('AUTO' | country ISO)` sets preferred PLMN (e.g. `SE` → 24001).
+- `getConfigurationErrors()`: read `configurationErrors` (+ timestamp) from ProtoConfig over BLE after set/get. Helpers: `decodeConfigurationError`, `configurationErrorsFromProtoConfig`, `formatConfigurationErrorTimestamp`. Human `label` matches cloud Slack (`side · parameter · value`); `errorTimestampUtc` is `YYYY-MM-DD HH:mm:ss UTC`.
+- Reject `temperatureAlerts` with `channel: "probe"` when the device baseline `channelTypes` has no measurement channel 3 (ambient-only sensors). Uses ProtoConfig from `getConfiguration` before BLE set. Helpers: `deviceSupportsProbeFromChannelTypes`, `deviceSupportsProbeFromBeaconReadings`, `assertProbeAlertsAllowed`.
+
+### Changed
+
+- Production defaults: treat all-zero UUID cloud tokens and CoAP paths without a leading `/` (`m` vs `/m`) as matching factory settings.
+- Production defaults: measurement period and transmission interval accept any positive value; `networkTroubleshooting=2` is OK when BLE turn-off is never.
+- BLE `getCalibration()` / `decodeLaboratoryCalibrationTimestamp`: normalize timestamp to unix seconds and expose calendar date only (`laboratoryCalibrationDate`). Helpers: `formatLaboratoryCalibration`, `normalizeLaboratoryCalibration`. No wall-clock time (device stores date only).
+- Auto-release leftover GATT on JS module load and before `startScan` (Metro / process reuse). Still call `disconnect()` when you finish a session.
+
 ## [1.1.7] - 2026-09-30
 
 ### Added

package/README.md

@@ -49,6 +49,7 @@ import {
   connect,
   setConfigurationJson,
   getConfiguration,
+  getConfigurationErrors,
   triggerTransmission,
   disconnect,
 } from '@tempivo/sensor-beacon';
@@ -81,6 +82,9 @@ try {
   // other queued Cellular fields can still downlink. To cancel the whole queue:
   // DELETE /api/v1/devices/{serial}/config (see docs/cellular-api.md).
   const applied = await getConfiguration();
+  // After set, firmware may store reject codes in ProtoConfig.configurationErrors:
+  const { errors, errorTimestampUnix, errorTimestampUtc } = await getConfigurationErrors();
+  if (errors.length) console.warn('config errors', errors, errorTimestampUtc ?? errorTimestampUnix);
 } finally {
   await disconnect(); // required so advertising / startScan can see the sensor again
 }
@@ -90,7 +94,7 @@ sub.remove();
 
 `startScan` and `connect` request Bluetooth permission. Sticker PIN is required on `connect`. Wrong PIN is `invalidPin`.
 
-**Connect tips:** stop scan before GATT connect. Pass the scan row’s `deviceId` and MAC when they differ from the sticker serial (`parseSensorQrForConnect`). 5–6 digit PINs map to an encryption key internally; numeric `resetCode` alone is not enough on all devices. Call `disconnect()` when finished. **While any device holds a GATT connection, the sensor does not advertise**, so `startScan` will not show beacon / live readings for that sensor until everyone disconnects (including other apps).
+**Connect tips:** stop scan before GATT connect. Pass the scan row’s `deviceId` and MAC when they differ from the sticker serial (`parseSensorQrForConnect`). 5–6 digit PINs map to an encryption key internally; numeric `resetCode` alone is not enough on all devices. Call `disconnect()` when finished. The SDK also releases a leftover GATT session on JS module load and before `startScan` (Metro reload / process reuse often keeps native BLE alive while wiping JS). **While any device holds a GATT connection, the sensor does not advertise**, so `startScan` will not show beacon / live readings for that sensor until everyone disconnects (including other apps).
 
 If a bundler misses native BLE, import `@tempivo/sensor-beacon/react-native`.
 
@@ -106,9 +110,23 @@ The Expo config plugin sets **minSdk 26**, Android BLE permissions, and **`NSBlu
 | `addDeviceFoundListener` | Callback per discovered device (includes `telemetry` when decoded). |
 | `connect` / `disconnect` | GATT session with parsed QR (`TempivoSensorQr`). |
 | `getConfiguration` / `setConfigurationJson` | Read / write alert rules, schedule, optional intervals. |
+| `getConfigurationErrors` | Read decoded `configurationErrors` from ProtoConfig (BLE get). Empty list when none. |
 | `triggerTransmission` | Ask firmware to uplink now; returns `{ ok }`. Cloud pending syncs after that uplink (or schedule/button), not from the BLE write alone. |
-| `clearMeasurementQueue` | Clear on-device measurement / uplink queue (memory reset). Manual recovery only; not used by `setConfigurationJson`. |
-| `getCalibration` | Optional BLE read of laboratory calibration date. Prefer the Cellular API (see below). |
+| `clearMeasurementQueue` / `deleteMeasurements` | Clear on-device measurement / uplink queue (memory reset). Manual recovery only; not used by `setConfigurationJson`. |
+| `getCellularNetworkStatus` / `getCellularNetworkStatusJson` / `setOperator` | GATT network status with short labels (`label` includes operator when known, plus `statusLabel` / `operatorName` / `summary` / `tone`; `locale`: `en` \| `sv`), raw JSON, PLMN `AUTO` or country ISO (`SE`, …). |
+| `cellularNetworkStatusViewFromJson` (+ related) | Pure label helpers from stored GATT JSON (no radio). |
+| `getCalibration` | BLE read of lab calibration. Returns `laboratoryCalibrationDate` (`YYYY-MM-DD`) and unix `laboratoryCalibrationTimestamp` (start of that day). Device has no wall-clock time. Prefer Cellular API in production. |
+
+```ts
+const { label, statusLabel, operatorName, summary, tone } = await getCellularNetworkStatus({
+  locale: 'en',
+});
+// label: "Telia Sweden, Server OK" (operator from GATT rplmn when known)
+// statusLabel: "No server" | "No internet" | "Server OK" | …
+// operatorName: "Telia Sweden" | null
+
+await setOperator('AUTO'); // or 'SE', 'NO', …
+```
 
 **Cloud queue:** BLE updates the sensor only. After uplink, Tempivo drops from Cellular `pendingConfig` only fields the device already matches; other queued fields can still downlink. Cancel the whole queue with `DELETE /api/v1/devices/{serial}/config` (see Tempivo Cellular API docs).
 
@@ -281,7 +299,7 @@ Use `parseSensorConfigurationJson` to validate before write. Use `parseSensorCon
 | Field | Meaning |
 |------|---------|
 | `type` | `range` (band), `min` (below), or `max` (above). |
-| `channel` | `ambient` or `probe`. |
+| `channel` | `ambient` or `probe`. **Probe** requires measurement channel 3 on the device (external probe). Ambient-only sensors (temp + humidity) reject probe alerts before write when `getConfiguration` baseline `channelTypes` is known. You can also check scan `telemetry.readings` via `deviceSupportsProbeFromBeaconReadings`. |
 | `lowC` / `highC` | Inclusive band for `type: "range"`. |
 | `minC` | Threshold for `type: "min"`. |
 | `maxC` | Threshold for `type: "max"`. |
@@ -458,7 +476,7 @@ npm run test:unit
 
 ## Changelog
 
-See [CHANGELOG.md](./CHANGELOG.md).
+See [CHANGELOG.md](./CHANGELOG.md) in this package (also on npm under Code).
 
 ## License
 

package/android/src/main/java/expo/modules/tempivosensorbeacon/SensorBeaconNative.java

@@ -36,6 +36,9 @@ final class SensorBeaconNative {
 
   void startScan(Context context, DeviceCallback callback) {
     try {
+      // Own GATT stops advertising for that sensor; release before scan (Metro/app relaunch
+      // often leaves a live session while JS is wiped).
+      disconnect();
       requireScanner(context).startScan(device -> callback.onDevice(deviceMap(device)));
     } catch (Throwable error) {
       throw wrap(error);
@@ -133,6 +136,22 @@ final class SensorBeaconNative {
     }
   }
 
+  String getCellularNetworkStatusJson() {
+    try {
+      return requireSessionConnected().getCellularNetworkStatusJsonBlocking();
+    } catch (Throwable error) {
+      throw wrap(error);
+    }
+  }
+
+  void setOperator(boolean automatic, Integer plmn) {
+    try {
+      requireSessionConnected().setOperatorBlocking(automatic, plmn);
+    } catch (Throwable error) {
+      throw wrap(error);
+    }
+  }
+
   Map<String, Object> getCalibration() {
     try {
       return calibrationMap(requireSessionConnected().getCalibrationBlocking());

package/android/src/main/java/expo/modules/tempivosensorbeacon/TempivoSensorBeaconModule.kt

@@ -100,6 +100,22 @@ class TempivoSensorBeaconModule : Module() {
       }
     }
 
+    AsyncFunction("getCellularNetworkStatusJson") {
+      try {
+        native.getCellularNetworkStatusJson()
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
+    AsyncFunction("setOperator") { automatic: Boolean, plmn: Int? ->
+      try {
+        native.setOperator(automatic, plmn)
+      } catch (error: Throwable) {
+        throw error.toSensorException()
+      }
+    }
+
     AsyncFunction("getCalibration") {
       try {
         native.calibration

package/android-aar/library/build.gradle

@@ -30,6 +30,7 @@ dependencies {
     implementation "androidx.core:core-ktx:1.17.0"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2"
+    implementation "com.google.code.gson:gson:2.11.0"
     implementation "pl.efento.mobile:bluetooth:2.3.0"
     testImplementation "junit:junit:4.13.2"
 }

package/android-aar/library/src/main/java/com/tempivo/sensor/beacon/SensorBleRuntime.kt

@@ -9,8 +9,10 @@ import pl.efento.mobile.bluetooth.model.BluetoothMacAddress
 import pl.efento.mobile.bluetooth.model.MeasurementPeriod
 import pl.efento.mobile.bluetooth.model.sensor.Rule
 import pl.efento.mobile.bluetooth.model.sensor.RuleCalendar
+import pl.efento.mobile.bluetooth.model.Plmn
 import pl.efento.mobile.bluetooth.model.sensor.SensorConfiguration
 import pl.efento.mobile.bluetooth.model.sensor.cellular.TransmissionInterval
+import com.google.gson.Gson
 
 /**
  * Internal adapter to the sensor BLE runtime. Keep vendor types inside this file.
@@ -38,8 +40,14 @@ internal object SensorBleRuntime {
                 TempivoSensorException(TempivoSensorException.Code.UNSUPPORTED_COMMAND, "Unsupported command.", e)
             className.contains("NotConnected") ->
                 TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.", e)
-            else ->
-                TempivoSensorException(TempivoSensorException.Code.UNKNOWN, "Sensor request failed.", e)
+            else -> {
+                val detail = e.message?.takeIf { it.isNotBlank() } ?: e.javaClass.simpleName
+                TempivoSensorException(
+                    TempivoSensorException.Code.UNKNOWN,
+                    "Sensor request failed ($detail).",
+                    e,
+                )
+            }
         }
     }
 
@@ -120,12 +128,73 @@ internal object SensorBleRuntime {
     }
 
     /**
-     * Clear on-device measurement / uplink queue (memory reset).
+     * Clear on-device measurement / uplink queue (memory reset / delete measurements).
      * Manual recovery only: not used by [writeConfiguration] / partner setConfiguration.
      */
     suspend fun clearMeasurementQueue(session: Session) {
         val base = modernGetConfiguration(session.connection)
-        session.connection.commands.setConfiguration(base.copy(resetMemoryRequest = true)) { }
+        val next =
+            prepareForSetConfiguration(
+                base.copy(
+                    resetMemoryRequest = true,
+                    updateSoftwareRequest = false,
+                    clearRuntimeErrorsRequest = false,
+                    configurationRequest = false,
+                    deviceInfoRequest = false,
+                    extendedConfigurationRequest = false,
+                ),
+            )
+        session.connection.commands.setConfiguration(next) { }
+    }
+
+    suspend fun getCellularNetworkStatusJson(session: Session): String {
+        val status = session.connection.commands.getCellularNetworkStatus { }
+        return Gson().toJson(status)
+    }
+
+    /**
+     * Set PLMN AUTO or CUSTOM (operator code). Bypasses partner setConfigurationJson cellular block.
+     *
+     * Merges into a fresh getConfiguration read (same as Tempivo Capacitor) and truncates rules
+     * so SDK 2.3 does not reject oversized readbacks. Stays on the vendor GATT session (no raw
+     * ProtoConfig link, which drops the session and can hang the Expo UI).
+     */
+    suspend fun setOperator(session: Session, automatic: Boolean, plmn: Int?) {
+        val plmnValue =
+            if (automatic) {
+                Plmn.Automatic
+            } else {
+                require(plmn != null && plmn in 10_000..999_999) { "plmn required for VALUE mode" }
+                Plmn.Custom(plmn)
+            }
+        val base = modernGetConfiguration(session.connection)
+        val next =
+            prepareForSetConfiguration(
+                base.copy(
+                    plmn = plmnValue,
+                    updateSoftwareRequest = false,
+                    resetMemoryRequest = false,
+                    clearRuntimeErrorsRequest = false,
+                    configurationRequest = false,
+                    deviceInfoRequest = false,
+                    extendedConfigurationRequest = false,
+                ),
+            )
+        session.connection.commands.setConfiguration(next) { }
+    }
+
+    /** Truncate rule slots SDK 2.3 rejects on setConfiguration (>12 rules / >6 calendars). */
+    private fun prepareForSetConfiguration(cfg: SensorConfiguration): SensorConfiguration {
+        var out = cfg
+        val rules = out.rules
+        if (rules != null && rules.size > 12) {
+            out = out.copy(rules = rules.take(12))
+        }
+        val calendars = out.ruleCalendars
+        if (calendars != null && calendars.size > 6) {
+            out = out.copy(ruleCalendars = calendars.take(6))
+        }
+        return out
     }
 
     suspend fun readCalibration(session: Session): TempivoSensorCalibration {

package/android-aar/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorCalibration.kt

@@ -6,6 +6,7 @@ import java.util.TimeZone
 
 data class TempivoSensorCalibration(
     val laboratoryCalibrationDate: String?,
+    /** Unix seconds UTC at start of that day (days-since-epoch from device are converted). */
     val laboratoryCalibrationTimestamp: Long?,
 )
 
@@ -16,16 +17,11 @@ object TempivoSensorCalibrationDecoder {
         if (raw == null || raw <= 0L) {
             return TempivoSensorCalibration(null, null)
         }
-        val date =
-            if (raw < 100_000L) {
-                isoDateUtc(raw * SECONDS_PER_DAY)
-            } else {
-                isoDateUtc(raw)
-            }
-        return TempivoSensorCalibration(date, raw)
+        val unixSeconds = if (raw < 100_000L) raw * SECONDS_PER_DAY else raw
+        return TempivoSensorCalibration(utcDate(unixSeconds), unixSeconds)
     }
 
-    private fun isoDateUtc(unixSeconds: Long): String {
+    private fun utcDate(unixSeconds: Long): String {
         val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"), Locale.US)
         cal.timeInMillis = unixSeconds * 1000L
         val y = cal.get(Calendar.YEAR)

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

@@ -180,6 +180,21 @@ class TempivoSensorSession(
         }
     }
 
+    suspend fun getCellularNetworkStatusJson(): String {
+        return runGatt {
+            ensureSdkConnected()
+            SensorBleRuntime.getCellularNetworkStatusJson(requireSession())
+        }
+    }
+
+    /** @param automatic true for AUTO; otherwise [plmn] required. */
+    suspend fun setOperator(automatic: Boolean, plmn: Int? = null) {
+        runGatt {
+            ensureSdkConnected()
+            SensorBleRuntime.setOperator(requireSession(), automatic, plmn)
+        }
+    }
+
     suspend fun getCalibration(): TempivoSensorCalibration {
         return runGatt {
             ensureSdkConnected()
@@ -204,6 +219,10 @@ class TempivoSensorSession(
 
     fun clearMeasurementQueueBlocking() = runBlocking { clearMeasurementQueue() }
 
+    fun getCellularNetworkStatusJsonBlocking(): String = runBlocking { getCellularNetworkStatusJson() }
+
+    fun setOperatorBlocking(automatic: Boolean, plmn: Int?) = runBlocking { setOperator(automatic, plmn) }
+
     fun getCalibrationBlocking(): TempivoSensorCalibration = runBlocking { getCalibration() }
 
     private fun requireSession(): SensorBleRuntime.Session =

package/dist/calibration.d.ts

@@ -2,6 +2,14 @@ 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).
+ * Always returns unix seconds in {@link TempivoSensorCalibration.laboratoryCalibrationTimestamp}.
+ * Device stores a calendar date only (no wall-clock time).
  */
 export declare function decodeLaboratoryCalibrationTimestamp(raw: number | null | undefined): TempivoSensorCalibration;
+/** One-line label for logs / UI (`YYYY-MM-DD` or `none`). */
+export declare function formatLaboratoryCalibration(cal: TempivoSensorCalibration): string;
+/**
+ * Normalize a native/partner calibration payload (date and/or timestamp) into the full shape.
+ */
+export declare function normalizeLaboratoryCalibration(input: Partial<TempivoSensorCalibration> | null | undefined): TempivoSensorCalibration;
 export declare function calibrationFromExtendedJson(json: string): TempivoSensorCalibration;

package/dist/calibration.js

@@ -2,33 +2,68 @@ const SECONDS_PER_DAY = 86_400;
 function pad2(n) {
     return n < 10 ? `0${n}` : String(n);
 }
-function isoDateUtcFromUnixSeconds(seconds) {
+function utcDateFromUnixSeconds(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);
+    const y = d.getUTCFullYear();
+    const m = pad2(d.getUTCMonth() + 1);
+    const day = pad2(d.getUTCDate());
+    return `${y}-${m}-${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).
+ * Always returns unix seconds in {@link TempivoSensorCalibration.laboratoryCalibrationTimestamp}.
+ * Device stores a calendar date only (no wall-clock time).
  */
 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,
+            laboratoryCalibrationDate: null,
+            laboratoryCalibrationTimestamp: null,
         };
     }
+    const n = Math.trunc(raw);
+    const unixSeconds = n < 100_000 ? n * SECONDS_PER_DAY : n;
     return {
-        laboratoryCalibrationDate: isoDateUtcFromUnixSeconds(n),
-        laboratoryCalibrationTimestamp: n,
+        laboratoryCalibrationDate: utcDateFromUnixSeconds(unixSeconds),
+        laboratoryCalibrationTimestamp: unixSeconds,
     };
 }
+/** One-line label for logs / UI (`YYYY-MM-DD` or `none`). */
+export function formatLaboratoryCalibration(cal) {
+    return cal.laboratoryCalibrationDate ?? 'none';
+}
+/** Accept unix seconds from native (number or numeric string). */
+function asPositiveUnix(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0)
+        return Math.trunc(value);
+    if (typeof value === 'string' && /^\d+$/.test(value.trim())) {
+        const n = parseInt(value.trim(), 10);
+        return n > 0 ? n : null;
+    }
+    return null;
+}
+/**
+ * Normalize a native/partner calibration payload (date and/or timestamp) into the full shape.
+ */
+export function normalizeLaboratoryCalibration(input) {
+    if (!input || typeof input !== 'object') {
+        return decodeLaboratoryCalibrationTimestamp(null);
+    }
+    const fromTs = asPositiveUnix(input.laboratoryCalibrationTimestamp);
+    if (fromTs != null) {
+        return decodeLaboratoryCalibrationTimestamp(fromTs);
+    }
+    const date = typeof input.laboratoryCalibrationDate === 'string' && input.laboratoryCalibrationDate.trim()
+        ? input.laboratoryCalibrationDate.trim().slice(0, 10)
+        : null;
+    if (date && /^\d{4}-\d{2}-\d{2}$/.test(date)) {
+        const [y, m, d] = date.split('-').map((p) => parseInt(p, 10));
+        const unix = Math.floor(Date.UTC(y, m - 1, d) / 1000);
+        return decodeLaboratoryCalibrationTimestamp(unix);
+    }
+    return decodeLaboratoryCalibrationTimestamp(null);
+}
 export function calibrationFromExtendedJson(json) {
     try {
         const o = JSON.parse(json);
@@ -37,6 +72,6 @@ export function calibrationFromExtendedJson(json) {
         return decodeLaboratoryCalibrationTimestamp(Number.isFinite(n) ? n : null);
     }
     catch {
-        return { laboratoryCalibrationDate: null, laboratoryCalibrationTimestamp: null };
+        return decodeLaboratoryCalibrationTimestamp(null);
     }
 }

package/dist/cellular-network-status.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Parse GATT cellular network status JSON and format short partner-facing labels
+ * (same vocabulary as the Tempivo app: No SIM, No internet, No server, …).
+ */
+export type TempivoCellularNetworkStatus = {
+    ipAddress: string | null;
+    registrationStatus: string | null;
+    serverCommunicationStatus: string | null;
+    communicationStatus: string | null;
+    /** RSSI from GATT `signalStrength`, normalized to dBm when possible. */
+    signalStrengthDbm: number | null;
+    ecl: 0 | 1 | 2 | null;
+    rsrpDbm: number | null;
+    simCardStatus: string | null;
+    /** Registered / serving PLMN from GATT (`rplmn`). */
+    registeredPlmn: number | null;
+    legacySession: boolean;
+};
+export type TempivoCellularStatusLocale = 'en' | 'sv';
+export type TempivoCellularStatusTone = 'ok' | 'warn' | 'bad' | 'muted';
+export type TempivoCellularNetworkStatusView = {
+    /** Raw JSON from native GATT. */
+    json: string;
+    status: TempivoCellularNetworkStatus | null;
+    /** Registered PLMN from GATT (`rplmn`), when present. */
+    operatorPlmn: number | null;
+    /** Operator name (e.g. Tele2 Sweden), or `PLMN {code}` when unknown. */
+    operatorName: string | null;
+    /**
+     * Short chip label. Status only, or `Operator, status` when PLMN is known
+     * (e.g. Tele2 Sweden, No server).
+     */
+    label: string;
+    /** Status without operator (No internet, No server, Server OK). */
+    statusLabel: string;
+    /** One-line summary for toasts / logs (includes operator when known). */
+    summary: string;
+    tone: TempivoCellularStatusTone;
+};
+export declare function isValidCellularIpAddress(ip: string | null | undefined): boolean;
+export declare function normalizeCellularSignalStrengthDbm(raw: number | null | undefined): number | null;
+export declare function parseCellularNetworkStatusObject(obj: Record<string, unknown>, legacySession?: boolean): TempivoCellularNetworkStatus;
+/** Parse Gson/SDK JSON from {@link getCellularNetworkStatusJson}. */
+export declare function parseCellularNetworkStatusJson(json: string, legacySession?: boolean): TempivoCellularNetworkStatus | null;
+export declare function isCellularRegistrationOk(status: TempivoCellularNetworkStatus): boolean;
+export declare function isSimCardOk(status: TempivoCellularNetworkStatus): boolean;
+export declare function isCellularServerCommunicationOk(status: TempivoCellularNetworkStatus): boolean;
+export declare function isCellularConnectionFullyOk(status: TempivoCellularNetworkStatus): boolean;
+/** Server/cloud detail (Timeout, No server, …). */
+export declare function formatCellularServerDetailLabel(status: TempivoCellularNetworkStatus, locale?: TempivoCellularStatusLocale): string;
+/**
+ * Short status label for UI (No SIM, No internet, No server, Server OK).
+ * Same mapping as Tempivo live BLE strip (without operator).
+ */
+export declare function formatCellularNetworkStatusLabel(status: TempivoCellularNetworkStatus, locale?: TempivoCellularStatusLocale): string;
+/** Prefix status with operator when GATT reports a registered PLMN. */
+export declare function formatCellularNetworkStatusLabelWithOperator(status: TempivoCellularNetworkStatus, locale?: TempivoCellularStatusLocale): string;
+/** One short sentence for toasts / logs. */
+export declare function formatCellularNetworkStatusSummary(status: TempivoCellularNetworkStatus, opts?: {
+    locale?: TempivoCellularStatusLocale;
+    afterServerTrigger?: boolean;
+}): string;
+export declare function resolveCellularStatusTone(status: TempivoCellularNetworkStatus): TempivoCellularStatusTone;
+/** Build a partner-ready view from raw GATT JSON (no radio). */
+export declare function cellularNetworkStatusViewFromJson(json: string, opts?: {
+    locale?: TempivoCellularStatusLocale;
+    afterServerTrigger?: boolean;
+    legacySession?: boolean;
+}): TempivoCellularNetworkStatusView;