@bikefinder/sdk 0.1.3 → 0.1.4

package/dist/device-schema.d.ts

@@ -1260,6 +1260,99 @@ export declare const observationValueSchema: {
             readonly required: readonly ["qualifiedModules", "reason", "cooldownRemainingMs"];
             readonly additionalProperties: false;
         };
+        readonly ChargingAllocationMember: {
+            readonly type: "object";
+            readonly properties: {
+                readonly slot: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 7;
+                };
+                readonly target: {
+                    readonly anyOf: readonly [{
+                        readonly $ref: "#/$defs/ModuleSubject";
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly requestedInputMa: {
+                    readonly anyOf: readonly [{
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly maximum: 800;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly configuredInputMa: {
+                    readonly anyOf: readonly [{
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly maximum: 800;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly outputAcknowledged: {
+                    readonly type: "boolean";
+                };
+                readonly stopUncertain: {
+                    readonly type: "boolean";
+                };
+                readonly faultCode: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 255;
+                };
+                readonly faultAttempts: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 255;
+                };
+                readonly faultGate: {
+                    readonly type: "string";
+                    readonly enum: readonly ["clear", "cooldown", "latched", "recheck"];
+                };
+                readonly cooldownRemainingMs: {
+                    readonly anyOf: readonly [{
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly maximum: 9007199254740991;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+            };
+            readonly required: readonly ["slot", "target", "requestedInputMa", "configuredInputMa", "outputAcknowledged", "stopUncertain", "faultCode", "faultAttempts", "faultGate", "cooldownRemainingMs"];
+            readonly additionalProperties: false;
+        };
+        readonly ChargingPowerReservation: {
+            readonly type: "object";
+            readonly properties: {
+                readonly moduleId: {
+                    readonly type: "string";
+                    readonly minLength: 16;
+                    readonly maxLength: 16;
+                    readonly pattern: "^[0-9a-f]*$";
+                };
+                readonly inputMa: {
+                    readonly anyOf: readonly [{
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly maximum: 800;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly remainingMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 9007199254740991;
+                };
+            };
+            readonly required: readonly ["moduleId", "inputMa", "remainingMs"];
+            readonly additionalProperties: false;
+        };
     };
     readonly properties: {
         readonly "agnss.completed": {
@@ -1691,11 +1784,53 @@ export declare const observationValueSchema: {
                         readonly type: "null";
                     }];
                 };
+                readonly guard: {
+                    readonly anyOf: readonly [{
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly authorized: {
+                                readonly type: "boolean";
+                            };
+                            readonly outputEnabled: {
+                                readonly type: "boolean";
+                            };
+                            readonly remainingMs: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                                readonly maximum: 4294967295000;
+                            };
+                            readonly inhibitReasons: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                                readonly maximum: 4294967295;
+                            };
+                            readonly policyRevision: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                                readonly maximum: 4294967295;
+                            };
+                            readonly authorizedSample: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                                readonly maximum: 4294967295;
+                            };
+                            readonly bootGeneration: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                                readonly maximum: 4294967295;
+                            };
+                        };
+                        readonly required: readonly ["authorized", "outputEnabled", "remainingMs", "inhibitReasons", "policyRevision", "authorizedSample", "bootGeneration"];
+                        readonly additionalProperties: false;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
             };
-            readonly required: readonly ["state", "fault", "inputValidated", "voltageRegulationActive"];
+            readonly required: readonly ["state", "fault", "inputValidated", "voltageRegulationActive", "guard"];
             readonly additionalProperties: false;
             readonly title: "Battery module charger status";
-            readonly description: "State/fault are one hardware status. Optional supply fields require evidence from the same validated transaction; never fill them from older cache entries.";
+            readonly description: "State/fault and optional local MSP charging guard are one coherent hardware snapshot. Guard reports permission, actual output, remaining authorization at capture, local inhibit reasons and safety-policy/boot generations. Null on legacy modules. Supply/guard fields must never borrow older cache entries.";
             readonly "x-bf": {
                 readonly definitionId: 8;
                 readonly role: "state";
@@ -1703,7 +1838,7 @@ export declare const observationValueSchema: {
                 readonly producer: "device";
                 readonly presentation: {
                     readonly displayName: "Battery module charger status";
-                    readonly description: "State/fault are one hardware status. Optional supply fields require evidence from the same validated transaction; never fill them from older cache entries.";
+                    readonly description: "State/fault and optional local MSP charging guard are one coherent hardware snapshot. Guard reports permission, actual output, remaining authorization at capture, local inhibit reasons and safety-policy/boot generations. Null on legacy modules. Supply/guard fields must never borrow older cache entries.";
                     readonly hiddenByDefault: false;
                     readonly formatter: "status";
                 };
@@ -5494,6 +5629,283 @@ export declare const observationValueSchema: {
                 };
             };
         };
+        readonly "battery.protocolIdentity": {
+            readonly type: "object";
+            readonly properties: {
+                readonly moduleId: {
+                    readonly type: "string";
+                    readonly minLength: 16;
+                    readonly maxLength: 16;
+                    readonly pattern: "^[0-9a-f]*$";
+                };
+                readonly bootGeneration: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 4294967295;
+                };
+                readonly capabilities: {
+                    readonly type: "string";
+                    readonly minLength: 16;
+                    readonly maxLength: 16;
+                    readonly pattern: "^[0-9a-f]*$";
+                };
+                readonly hardwareRevision: {
+                    readonly anyOf: readonly [{
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly maximum: 65535;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly resetReason: {
+                    readonly anyOf: readonly [{
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly maximum: 65535;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+            };
+            readonly required: readonly ["moduleId", "bootGeneration", "capabilities", "hardwareRevision", "resetReason"];
+            readonly additionalProperties: false;
+            readonly title: "battery.protocolIdentity";
+            readonly description: "Accepted HELLO identity and metadata for this raw route. Optional unavailable metadata is null. Relay headers are not module identity evidence.";
+            readonly "x-bf": {
+                readonly definitionId: 161;
+                readonly role: "state";
+                readonly subject: "batteryRoute";
+                readonly producer: "device";
+                readonly presentation: {
+                    readonly displayName: "battery.protocolIdentity";
+                    readonly description: "Accepted HELLO identity and metadata for this raw route. Optional unavailable metadata is null. Relay headers are not module identity evidence.";
+                    readonly hiddenByDefault: true;
+                    readonly formatter: "fields";
+                    readonly fields: readonly [{
+                        readonly path: "moduleId";
+                    }, {
+                        readonly path: "bootGeneration";
+                    }, {
+                        readonly path: "capabilities";
+                    }, {
+                        readonly path: "hardwareRevision";
+                    }, {
+                        readonly path: "resetReason";
+                    }];
+                };
+            };
+        };
+        readonly "battery.protocolExchange": {
+            readonly type: "object";
+            readonly properties: {
+                readonly operation: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 65535;
+                };
+                readonly elapsedMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 4294967295;
+                };
+                readonly transportError: {
+                    readonly type: "integer";
+                    readonly minimum: -2147483648;
+                    readonly maximum: 2147483647;
+                };
+                readonly status: {
+                    readonly anyOf: readonly [{
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly maximum: 65535;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly bootGeneration: {
+                    readonly anyOf: readonly [{
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly maximum: 4294967295;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+            };
+            readonly required: readonly ["operation", "elapsedMs", "transportError", "status", "bootGeneration"];
+            readonly additionalProperties: false;
+            readonly title: "battery.protocolExchange";
+            readonly description: "Last protocol envelope exchange. Transport/framing/correlation errors are distinct from the matched MSP result. No request or response payload bytes are retained. Operation-body validity is checked separately by the typed consumer.";
+            readonly "x-bf": {
+                readonly definitionId: 162;
+                readonly role: "state";
+                readonly subject: "batteryRoute";
+                readonly producer: "device";
+                readonly presentation: {
+                    readonly displayName: "battery.protocolExchange";
+                    readonly description: "Last protocol envelope exchange. Transport/framing/correlation errors are distinct from the matched MSP result. No request or response payload bytes are retained. Operation-body validity is checked separately by the typed consumer.";
+                    readonly hiddenByDefault: true;
+                    readonly formatter: "fields";
+                    readonly fields: readonly [{
+                        readonly path: "operation";
+                    }, {
+                        readonly path: "elapsedMs";
+                        readonly format: "duration";
+                    }, {
+                        readonly path: "transportError";
+                    }, {
+                        readonly path: "status";
+                    }, {
+                        readonly path: "bootGeneration";
+                    }];
+                };
+            };
+        };
+        readonly "battery.updateHealth": {
+            readonly type: "object";
+            readonly properties: {
+                readonly requestId: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 4294967295;
+                };
+                readonly slot: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 31;
+                };
+                readonly target: {
+                    readonly $ref: "#/$defs/ModuleSubject";
+                };
+                readonly imageInstalled: {
+                    readonly type: "boolean";
+                };
+                readonly state: {
+                    readonly type: "string";
+                    readonly enum: readonly ["operational", "failed", "unsupported"];
+                };
+                readonly error: {
+                    readonly type: "integer";
+                    readonly minimum: -2147483648;
+                    readonly maximum: 2147483647;
+                };
+                readonly bootGeneration: {
+                    readonly anyOf: readonly [{
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                        readonly maximum: 4294967295;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+            };
+            readonly required: readonly ["requestId", "slot", "target", "imageInstalled", "state", "error", "bootGeneration"];
+            readonly additionalProperties: false;
+            readonly title: "battery.updateHealth";
+            readonly description: "Operational verification after a completed MSP installation and LTE restart. Installation completion does not imply operational health. A failed health check never rearms image installation or consumes another flash attempt.";
+            readonly "x-bf": {
+                readonly definitionId: 163;
+                readonly role: "state";
+                readonly subject: "device";
+                readonly producer: "device";
+                readonly presentation: {
+                    readonly displayName: "battery.updateHealth";
+                    readonly description: "Operational verification after a completed MSP installation and LTE restart. Installation completion does not imply operational health. A failed health check never rearms image installation or consumes another flash attempt.";
+                    readonly hiddenByDefault: true;
+                    readonly formatter: "fields";
+                    readonly fields: readonly [{
+                        readonly path: "requestId";
+                    }, {
+                        readonly path: "slot";
+                    }, {
+                        readonly path: "imageInstalled";
+                    }, {
+                        readonly path: "state";
+                    }, {
+                        readonly path: "error";
+                    }, {
+                        readonly path: "bootGeneration";
+                    }];
+                };
+            };
+        };
+        readonly "battery.charging.allocations": {
+            readonly type: "object";
+            readonly properties: {
+                readonly inventoryConfirmed: {
+                    readonly type: "boolean";
+                };
+                readonly held: {
+                    readonly type: "boolean";
+                };
+                readonly inputBudgetMa: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 65535;
+                };
+                readonly maximumChargers: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 8;
+                };
+                readonly reason: {
+                    readonly type: "string";
+                    readonly enum: readonly ["none", "disabled", "detached", "unknownInput", "notReady", "communication", "stale", "thermal", "cable", "full", "overcurrent", "maintenance", "chargerFault", "allocationBudget"];
+                };
+                readonly modules: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/ChargingAllocationMember";
+                    };
+                    readonly minItems: 0;
+                    readonly maxItems: 8;
+                };
+                readonly reservations: {
+                    readonly anyOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly $ref: "#/$defs/ChargingPowerReservation";
+                        };
+                        readonly minItems: 0;
+                        readonly maxItems: 8;
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+            };
+            readonly required: readonly ["inventoryConfirmed", "held", "inputBudgetMa", "maximumChargers", "reason", "modules", "reservations"];
+            readonly additionalProperties: false;
+            readonly title: "Charging allocation decisions";
+            readonly description: "LTE allocation intent and acknowledged output, not proof of actual current flow. Reports stopped fault gates and physical-identity power reservations, including unreachable modules and lost acknowledgements. Remaining durations freeze at capture; use observation age. A null reservation list is unavailable, not empty. Reads perform no UART I/O and never retire or renew a reservation.";
+            readonly "x-bf": {
+                readonly definitionId: 164;
+                readonly role: "state";
+                readonly subject: "device";
+                readonly producer: "device";
+                readonly presentation: {
+                    readonly displayName: "Charging allocation decisions";
+                    readonly hiddenByDefault: true;
+                    readonly description: "LTE allocation intent and acknowledged output, not proof of actual current flow. Reports stopped fault gates and physical-identity power reservations, including unreachable modules and lost acknowledgements. Remaining durations freeze at capture; use observation age. A null reservation list is unavailable, not empty. Reads perform no UART I/O and never retire or renew a reservation.";
+                    readonly formatter: "fields";
+                    readonly fields: readonly [{
+                        readonly path: "held";
+                    }, {
+                        readonly path: "reason";
+                    }, {
+                        readonly path: "inputBudgetMa";
+                    }, {
+                        readonly path: "maximumChargers";
+                    }, {
+                        readonly path: "modules";
+                        readonly format: "count";
+                    }, {
+                        readonly path: "reservations";
+                        readonly format: "count";
+                    }];
+                };
+            };
+        };
     };
 };
 export declare const settingsValueSchema: {
@@ -5687,13 +6099,10 @@ export declare const settingsValueSchema: {
             readonly title: "BLE advertising";
             readonly description: "Enable advertising according to the independent BLE power policy. Wi-Fi scans and updates temporarily borrow the radio.";
         };
-        readonly bleAdvertisingPower: {
-            readonly type: "integer";
-            readonly minimum: 0;
-            readonly maximum: 1;
-            readonly enum: readonly [0, 1];
-            readonly title: "BLE advertising power";
-            readonly description: "0 allows advertising on any power source. 1 requires confirmed external power, including a full battery that remains plugged in.";
+        readonly bleAdvertisingRequiresExternalPower: {
+            readonly type: "boolean";
+            readonly title: "BLE advertising requires external power";
+            readonly description: "When true, advertise only with confirmed external power, including a full battery that remains plugged in. When false, allow advertising on battery too.";
         };
         readonly bleAdvertisingIntervalUnits: {
             readonly type: "integer";
@@ -5883,11 +6292,73 @@ export declare const settingsValueSchema: {
             readonly title: "Hot shutdown recovery temperature";
             readonly description: "After a high-temperature shutdown, resume only at or below this temperature. Order: cold stop < cold stop recovery <= cold limit < cold limit recovery <= warm limit recovery < warm limit <= hot stop recovery < hot stop.";
         };
+        readonly chargingLeaseSeconds: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 4294967295;
+            readonly title: "MSP charging allocation lease";
+            readonly description: "Maximum charging allocation duration for an MSP with autonomous local safety and charger watchdog service. LTE retains shared power reservations through communication loss until verified stopped or expired. Installed MSPs retain their existing supervision.";
+        };
+        readonly wifiTimeoutSeconds: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 120;
+            readonly title: "Wi-Fi acquisition timeout";
+            readonly description: "Maximum time for one admitted Wi-Fi acquisition, including ESP startup and result delivery. The requesting operation deadline can end it sooner. Applies to installed and configurable ESP scan protocols.";
+        };
+        readonly wifiScanActiveMinMs: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 1500;
+            readonly title: "Wi-Fi active scan minimum dwell";
+            readonly description: "Minimum active scan dwell per channel. Must not exceed wifiScanActiveMaxMs. Requires ESP 10.2.1 or later; older or unknown ESP versions retain their native scan.";
+        };
+        readonly wifiScanActiveMaxMs: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 1500;
+            readonly title: "Wi-Fi active scan maximum dwell";
+            readonly description: "Maximum active scan dwell per channel. Must be at least wifiScanActiveMinMs. Requires ESP 10.2.1 or later; older or unknown ESP versions retain their native scan.";
+        };
+        readonly wifiScanPassiveMs: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 1500;
+            readonly title: "Wi-Fi passive scan dwell";
+            readonly description: "Passive scan dwell per channel. Used only for passive scans. Requires ESP 10.2.1 or later; older or unknown ESP versions retain their native scan.";
+        };
+        readonly wifiScanChannelMask: {
+            readonly type: "integer";
+            readonly minimum: 0;
+            readonly maximum: 16383;
+            readonly title: "Wi-Fi scan channels";
+            readonly description: "Channel bitmask: bit 0 is channel 1, bit 13 is channel 14. Zero selects all permitted channels. Intersected with ESP regulatory channels. Requires ESP 10.2.1 or later.";
+        };
+        readonly wifiScanBudgetMs: {
+            readonly type: "integer";
+            readonly minimum: 100;
+            readonly maximum: 60000;
+            readonly title: "Wi-Fi scan budget";
+            readonly description: "ESP initialization and scan budget, excluding result delivery. Limited by the remaining LTE acquisition deadline. Requires ESP 10.2.1 or later; older or unknown ESP versions retain their native scan.";
+        };
+        readonly wifiScanType: {
+            readonly type: "string";
+            readonly enum: readonly ["active", "passive"];
+            readonly title: "Wi-Fi scan type";
+            readonly description: "Choose active probing or passive listening. Requires ESP 10.2.1 or later; older or unknown ESP versions retain their native scan.";
+        };
+        readonly chargingStatusMaxAgeSeconds: {
+            readonly type: "integer";
+            readonly minimum: 30;
+            readonly maximum: 86400;
+            readonly title: "Charging status maximum age";
+            readonly description: "Maximum age of charger readback used for the reported charging status. Independent of charging-control safety deadlines; does not authorize charging or schedule extra hardware reads. Confirmed input loss still reports not charging immediately.";
+        };
     };
     readonly "x-bf": {
         readonly domain: "settings";
         readonly version: 1;
-        readonly settingsSchemaVersion: 24;
+        readonly settingsSchemaVersion: 27;
     };
 };
 export declare const observationDefinitions: readonly [{
@@ -6032,7 +6503,7 @@ export declare const observationDefinitions: readonly [{
     readonly producer: "device";
     readonly presentation: {
         readonly displayName: "Battery module charger status";
-        readonly description: "State/fault are one hardware status. Optional supply fields require evidence from the same validated transaction; never fill them from older cache entries.";
+        readonly description: "State/fault and optional local MSP charging guard are one coherent hardware snapshot. Guard reports permission, actual output, remaining authorization at capture, local inhibit reasons and safety-policy/boot generations. Null on legacy modules. Supply/guard fields must never borrow older cache entries.";
         readonly hiddenByDefault: false;
         readonly formatter: "status";
     };
@@ -7964,6 +8435,105 @@ export declare const observationDefinitions: readonly [{
             readonly format: "duration";
         }];
     };
+}, {
+    readonly id: 161;
+    readonly name: "battery.protocolIdentity";
+    readonly role: "state";
+    readonly subject: "batteryRoute";
+    readonly producer: "device";
+    readonly presentation: {
+        readonly displayName: "battery.protocolIdentity";
+        readonly description: "Accepted HELLO identity and metadata for this raw route. Optional unavailable metadata is null. Relay headers are not module identity evidence.";
+        readonly hiddenByDefault: true;
+        readonly formatter: "fields";
+        readonly fields: readonly [{
+            readonly path: "moduleId";
+        }, {
+            readonly path: "bootGeneration";
+        }, {
+            readonly path: "capabilities";
+        }, {
+            readonly path: "hardwareRevision";
+        }, {
+            readonly path: "resetReason";
+        }];
+    };
+}, {
+    readonly id: 162;
+    readonly name: "battery.protocolExchange";
+    readonly role: "state";
+    readonly subject: "batteryRoute";
+    readonly producer: "device";
+    readonly presentation: {
+        readonly displayName: "battery.protocolExchange";
+        readonly description: "Last protocol envelope exchange. Transport/framing/correlation errors are distinct from the matched MSP result. No request or response payload bytes are retained. Operation-body validity is checked separately by the typed consumer.";
+        readonly hiddenByDefault: true;
+        readonly formatter: "fields";
+        readonly fields: readonly [{
+            readonly path: "operation";
+        }, {
+            readonly path: "elapsedMs";
+            readonly format: "duration";
+        }, {
+            readonly path: "transportError";
+        }, {
+            readonly path: "status";
+        }, {
+            readonly path: "bootGeneration";
+        }];
+    };
+}, {
+    readonly id: 163;
+    readonly name: "battery.updateHealth";
+    readonly role: "state";
+    readonly subject: "device";
+    readonly producer: "device";
+    readonly presentation: {
+        readonly displayName: "battery.updateHealth";
+        readonly description: "Operational verification after a completed MSP installation and LTE restart. Installation completion does not imply operational health. A failed health check never rearms image installation or consumes another flash attempt.";
+        readonly hiddenByDefault: true;
+        readonly formatter: "fields";
+        readonly fields: readonly [{
+            readonly path: "requestId";
+        }, {
+            readonly path: "slot";
+        }, {
+            readonly path: "imageInstalled";
+        }, {
+            readonly path: "state";
+        }, {
+            readonly path: "error";
+        }, {
+            readonly path: "bootGeneration";
+        }];
+    };
+}, {
+    readonly id: 164;
+    readonly name: "battery.charging.allocations";
+    readonly role: "state";
+    readonly subject: "device";
+    readonly producer: "device";
+    readonly presentation: {
+        readonly displayName: "Charging allocation decisions";
+        readonly hiddenByDefault: true;
+        readonly description: "LTE allocation intent and acknowledged output, not proof of actual current flow. Reports stopped fault gates and physical-identity power reservations, including unreachable modules and lost acknowledgements. Remaining durations freeze at capture; use observation age. A null reservation list is unavailable, not empty. Reads perform no UART I/O and never retire or renew a reservation.";
+        readonly formatter: "fields";
+        readonly fields: readonly [{
+            readonly path: "held";
+        }, {
+            readonly path: "reason";
+        }, {
+            readonly path: "inputBudgetMa";
+        }, {
+            readonly path: "maximumChargers";
+        }, {
+            readonly path: "modules";
+            readonly format: "count";
+        }, {
+            readonly path: "reservations";
+            readonly format: "count";
+        }];
+    };
 }];
 export type OperationOutcome = "success" | "empty" | "partial" | "timeout" | "failed" | "cancelled" | "budgetExhausted" | "skipped";
 export type ModuleSubject = string;
@@ -8534,6 +9104,10 @@ export interface ObservationValues {
     "workflow.execution"?: WorkflowExecution;
     "battery.module.chargeCompleted"?: BatteryModuleChargeCompleted;
     "battery.module.chargeRested"?: BatteryModuleChargeRested;
+    "battery.protocolIdentity"?: BatteryProtocolIdentity;
+    "battery.protocolExchange"?: BatteryProtocolExchange;
+    "battery.updateHealth"?: BatteryUpdateHealth;
+    "battery.charging.allocations"?: ChargingAllocationDecisions;
 }
 /**
  * A single assistance exchange outcome; later fix latency is new search evidence, not a mutation of this completed record.
@@ -8650,13 +9224,22 @@ export interface InventoryMember {
     hardwareId: string | null;
 }
 /**
- * State/fault are one hardware status. Optional supply fields require evidence from the same validated transaction; never fill them from older cache entries.
+ * State/fault and optional local MSP charging guard are one coherent hardware snapshot. Guard reports permission, actual output, remaining authorization at capture, local inhibit reasons and safety-policy/boot generations. Null on legacy modules. Supply/guard fields must never borrow older cache entries.
  */
 export interface BatteryModuleChargerStatus {
     state: "ready" | "charging" | "full" | "fault";
     fault: number;
     inputValidated: boolean | null;
     voltageRegulationActive: boolean | null;
+    guard: {
+        authorized: boolean;
+        outputEnabled: boolean;
+        remainingMs: number;
+        inhibitReasons: number;
+        policyRevision: number;
+        authorizedSample: number;
+        bootGeneration: number;
+    } | null;
 }
 /**
  * Version and confidence are inseparable; relay headers do not prove remote firmware identity.
@@ -9163,6 +9746,71 @@ export interface BatteryModuleChargeRested {
     afterStopMs: number;
     sinceCompletionMs: number;
 }
+/**
+ * Accepted HELLO identity and metadata for this raw route. Optional unavailable metadata is null. Relay headers are not module identity evidence.
+ */
+export interface BatteryProtocolIdentity {
+    moduleId: string;
+    bootGeneration: number;
+    capabilities: string;
+    hardwareRevision: number | null;
+    resetReason: number | null;
+}
+/**
+ * Last protocol envelope exchange. Transport/framing/correlation errors are distinct from the matched MSP result. No request or response payload bytes are retained. Operation-body validity is checked separately by the typed consumer.
+ */
+export interface BatteryProtocolExchange {
+    operation: number;
+    elapsedMs: number;
+    transportError: number;
+    status: number | null;
+    bootGeneration: number | null;
+}
+/**
+ * Operational verification after a completed MSP installation and LTE restart. Installation completion does not imply operational health. A failed health check never rearms image installation or consumes another flash attempt.
+ */
+export interface BatteryUpdateHealth {
+    requestId: number;
+    slot: number;
+    target: ModuleSubject;
+    imageInstalled: boolean;
+    state: "operational" | "failed" | "unsupported";
+    error: number;
+    bootGeneration: number | null;
+}
+/**
+ * LTE allocation intent and acknowledged output, not proof of actual current flow. Reports stopped fault gates and physical-identity power reservations, including unreachable modules and lost acknowledgements. Remaining durations freeze at capture; use observation age. A null reservation list is unavailable, not empty. Reads perform no UART I/O and never retire or renew a reservation.
+ */
+export interface ChargingAllocationDecisions {
+    inventoryConfirmed: boolean;
+    held: boolean;
+    inputBudgetMa: number;
+    maximumChargers: number;
+    reason: "none" | "disabled" | "detached" | "unknownInput" | "notReady" | "communication" | "stale" | "thermal" | "cable" | "full" | "overcurrent" | "maintenance" | "chargerFault" | "allocationBudget";
+    /**
+     * @minItems 0
+     * @maxItems 8
+     */
+    modules: ChargingAllocationMember[];
+    reservations: ChargingPowerReservation[] | null;
+}
+export interface ChargingAllocationMember {
+    slot: number;
+    target: ModuleSubject | null;
+    requestedInputMa: number | null;
+    configuredInputMa: number | null;
+    outputAcknowledged: boolean;
+    stopUncertain: boolean;
+    faultCode: number;
+    faultAttempts: number;
+    faultGate: "clear" | "cooldown" | "latched" | "recheck";
+    cooldownRemainingMs: number | null;
+}
+export interface ChargingPowerReservation {
+    moduleId: string;
+    inputMa: number | null;
+    remainingMs: number;
+}
 /**
  * Interval between battery measurements, in seconds.
  */
@@ -9280,9 +9928,9 @@ export type I2CIdlePowerSaving = boolean;
  */
 export type BLEAdvertising = boolean;
 /**
- * 0 allows advertising on any power source. 1 requires confirmed external power, including a full battery that remains plugged in.
+ * When true, advertise only with confirmed external power, including a full battery that remains plugged in. When false, allow advertising on battery too.
  */
-export type BLEAdvertisingPower = 0 | 1;
+export type BLEAdvertisingRequiresExternalPower = boolean;
 /**
  * Advertising interval in 0.625 millisecond units. Applied by the peripheral owner independently of LTE connection work.
  */
@@ -9391,6 +10039,42 @@ export type WarmCurrentLimitingRecoveryTemperature = number;
  * After a high-temperature shutdown, resume only at or below this temperature. Order: cold stop < cold stop recovery <= cold limit < cold limit recovery <= warm limit recovery < warm limit <= hot stop recovery < hot stop.
  */
 export type HotShutdownRecoveryTemperature = number;
+/**
+ * Maximum charging allocation duration for an MSP with autonomous local safety and charger watchdog service. LTE retains shared power reservations through communication loss until verified stopped or expired. Installed MSPs retain their existing supervision.
+ */
+export type MSPChargingAllocationLease = number;
+/**
+ * Maximum time for one admitted Wi-Fi acquisition, including ESP startup and result delivery. The requesting operation deadline can end it sooner. Applies to installed and configurable ESP scan protocols.
+ */
+export type WiFiAcquisitionTimeout = number;
+/**
+ * Minimum active scan dwell per channel. Must not exceed wifiScanActiveMaxMs. Requires ESP 10.2.1 or later; older or unknown ESP versions retain their native scan.
+ */
+export type WiFiActiveScanMinimumDwell = number;
+/**
+ * Maximum active scan dwell per channel. Must be at least wifiScanActiveMinMs. Requires ESP 10.2.1 or later; older or unknown ESP versions retain their native scan.
+ */
+export type WiFiActiveScanMaximumDwell = number;
+/**
+ * Passive scan dwell per channel. Used only for passive scans. Requires ESP 10.2.1 or later; older or unknown ESP versions retain their native scan.
+ */
+export type WiFiPassiveScanDwell = number;
+/**
+ * Channel bitmask: bit 0 is channel 1, bit 13 is channel 14. Zero selects all permitted channels. Intersected with ESP regulatory channels. Requires ESP 10.2.1 or later.
+ */
+export type WiFiScanChannels = number;
+/**
+ * ESP initialization and scan budget, excluding result delivery. Limited by the remaining LTE acquisition deadline. Requires ESP 10.2.1 or later; older or unknown ESP versions retain their native scan.
+ */
+export type WiFiScanBudget = number;
+/**
+ * Choose active probing or passive listening. Requires ESP 10.2.1 or later; older or unknown ESP versions retain their native scan.
+ */
+export type WiFiScanType = "active" | "passive";
+/**
+ * Maximum age of charger readback used for the reported charging status. Independent of charging-control safety deadlines; does not authorize charging or schedule extra hardware reads. Confirmed input loss still reports not charging immediately.
+ */
+export type ChargingStatusMaximumAge = number;
 export interface DeviceSettings {
     batteryIntervalSeconds?: BatteryMeasurementInterval;
     accTapSensitivity?: AccelerometerTapSensitivity;
@@ -9421,7 +10105,7 @@ export interface DeviceSettings {
     workflowDebugEnabled?: WorkflowDebugTracing;
     i2cIdlePowerSavingEnabled?: I2CIdlePowerSaving;
     bleAdvertisingEnabled?: BLEAdvertising;
-    bleAdvertisingPower?: BLEAdvertisingPower;
+    bleAdvertisingRequiresExternalPower?: BLEAdvertisingRequiresExternalPower;
     bleAdvertisingIntervalUnits?: BLEAdvertisingInterval;
     mode?: TrackingMode;
     poweredReportIntervalSeconds?: PoweredReportInterval;
@@ -9449,6 +10133,15 @@ export interface DeviceSettings {
     chargingTemperatureColdStopRecoveryC?: ColdShutdownRecoveryTemperature;
     chargingTemperatureWarmLimitRecoveryC?: WarmCurrentLimitingRecoveryTemperature;
     chargingTemperatureHotStopRecoveryC?: HotShutdownRecoveryTemperature;
+    chargingLeaseSeconds?: MSPChargingAllocationLease;
+    wifiTimeoutSeconds?: WiFiAcquisitionTimeout;
+    wifiScanActiveMinMs?: WiFiActiveScanMinimumDwell;
+    wifiScanActiveMaxMs?: WiFiActiveScanMaximumDwell;
+    wifiScanPassiveMs?: WiFiPassiveScanDwell;
+    wifiScanChannelMask?: WiFiScanChannels;
+    wifiScanBudgetMs?: WiFiScanBudget;
+    wifiScanType?: WiFiScanType;
+    chargingStatusMaxAgeSeconds?: ChargingStatusMaximumAge;
 }
 type Definition = (typeof observationDefinitions)[number];
 export type MetricName = Definition["name"];