tirecheck-device-sdk 0.2.65 → 0.2.67

package/dist/index.cjs

@@ -228,6 +228,14 @@ const bridgeTools = {
   hexToDecimalArray(hex) {
     return hex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || [];
   },
+  /** Combine little-endian bytes (low byte first) into a single integer. */
+  bytesToInt(bytes) {
+    return bytes.reduce((acc, byte, index) => acc + ((byte || 0) << 8 * index), 0);
+  },
+  /** Split an integer into `byteCount` little-endian bytes (low byte first). */
+  intToBytes(value, byteCount) {
+    return Array.from({ length: byteCount }, (_unused, index) => value >> 8 * index & 255);
+  },
   getFwVersion(payload) {
     if (payload?.length !== 3) {
       console.warn("Could not process FwVersion ", payload);
@@ -246,9 +254,7 @@ const bridgeTools = {
   },
   convertBarToKpaByte(deviceId, value) {
     if (!value) return 0;
-    const deviceData = getBridgeFromStore(deviceId);
-    if (!deviceData) throw new Error(`Cannot convert bar to kpa byte, no device data found: ${deviceId}`);
-    const bitValue = deviceData.name.includes("030717") ? 6.7 : 5.0625;
+    const bitValue = this.usesKpaPressure(deviceId) ? 1 : 5.0625;
     return ___default.round((value + 1) * 100 / bitValue);
   },
   convertSensorIdForBridge(sensorId) {
@@ -271,9 +277,7 @@ const bridgeTools = {
     if (!___default.isNumber(value)) {
       throw new TypeError("Value has to be a number");
     }
-    const deviceData = getBridgeFromStore(deviceId);
-    if (!deviceData) throw new Error(`Cannot convert kpa byte to bar, no device data found: ${deviceId}`);
-    const bitValue = deviceData.name.includes("030717") ? 6.7 : 5.0625;
+    const bitValue = this.usesKpaPressure(deviceId) ? 1 : 5.0625;
     const rawBar = value * bitValue / 100;
     return ___default.round(Math.max(rawBar - decrementValue, 0), 1);
   },
@@ -287,6 +291,9 @@ const bridgeTools = {
     }
     return false;
   },
+  usesKpaPressure(deviceId) {
+    return this.isVersionGreaterThan(deviceId, "1.1.F");
+  },
   convertSensorIdFromBridge(sensorId) {
     if (sensorId.startsWith("B")) {
       return Number.parseInt(sensorId, 16).toString();
@@ -1266,6 +1273,78 @@ const bridgeCommandStructures = {
       }
     }
   },
+  /**
+   * kPa per-axle pressure layout used from FW 1.2.0 onwards (same sub-command 0x30 as `pressuresPerAxle`).
+   * Each axle packs the same three values (set; min; max) but every value is a 2-byte little-endian raw kPa
+   * uint16 (no 5.0625 bit scaling), so each axle is 6 bytes instead of 3. Selected at runtime via
+   * `bridgeTools.usesKpaPressure(deviceId)`.
+   */
+  pressuresPerAxleKpa: {
+    id: [98, 48],
+    name: "pressuresPerAxleKpa",
+    structure: {
+      axle01: {
+        size: 6,
+        description: "Axle 01 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle02: {
+        size: 6,
+        description: "Axle 02 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle03: {
+        size: 6,
+        description: "Axle 03 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle04: {
+        size: 6,
+        description: "Axle 04 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle05: {
+        size: 6,
+        description: "Axle 05 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle06: {
+        size: 6,
+        description: "Axle 06 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle07: {
+        size: 6,
+        description: "Axle 07 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle08: {
+        size: 6,
+        description: "Axle 08 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle09: {
+        size: 6,
+        description: "Axle 09 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle10: {
+        size: 6,
+        description: "Axle 10 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle11: {
+        size: 6,
+        description: "Axle 11 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle12: {
+        size: 6,
+        description: "Axle 12 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle13: {
+        size: 6,
+        description: "Axle 13 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle14: {
+        size: 6,
+        description: "Axle 14 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle15: {
+        size: 6,
+        description: "Axle 15 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      }
+    }
+  },
   autolearnSettings: {
     id: [98, 160],
     name: "autolearnSettings",
@@ -1571,6 +1650,95 @@ const bridgeCommandStructures = {
         version: "1.0.3"
       }
     }
+  },
+  idsPerWheel: {
+    // base sub-command id, the actual axle is addressed via `0x20 + axleIndex` (0x20 - 0x2F)
+    id: [98, 32],
+    name: "idsPerWheel",
+    structure: {
+      wheel01: {
+        size: 4,
+        description: "Wheel 01 sensor ID (4-byte, little-endian)"
+      },
+      wheel02: {
+        size: 4,
+        description: "Wheel 02 sensor ID (4-byte, little-endian)"
+      },
+      wheel03: {
+        size: 4,
+        description: "Wheel 03 sensor ID (4-byte, little-endian)"
+      },
+      wheel04: {
+        size: 4,
+        description: "Wheel 04 sensor ID (4-byte, little-endian)"
+      },
+      wheel05: {
+        size: 4,
+        description: "Wheel 05 sensor ID (4-byte, little-endian)"
+      },
+      wheel06: {
+        size: 4,
+        description: "Wheel 06 sensor ID (4-byte, little-endian), left-outer position"
+      },
+      wheel07: {
+        size: 4,
+        description: "Wheel 07 sensor ID (4-byte, little-endian), left-inner position"
+      },
+      wheel08: {
+        size: 4,
+        description: "Wheel 08 sensor ID (4-byte, little-endian), center / spare position"
+      },
+      wheel09: {
+        size: 4,
+        description: "Wheel 09 sensor ID (4-byte, little-endian), right-inner position"
+      },
+      wheel10: {
+        size: 4,
+        description: "Wheel 10 sensor ID (4-byte, little-endian), right-outer position"
+      },
+      wheel11: {
+        size: 4,
+        description: "Wheel 11 sensor ID (4-byte, little-endian)"
+      },
+      wheel12: {
+        size: 4,
+        description: "Wheel 12 sensor ID (4-byte, little-endian)"
+      },
+      wheel13: {
+        size: 4,
+        description: "Wheel 13 sensor ID (4-byte, little-endian)"
+      },
+      wheel14: {
+        size: 4,
+        description: "Wheel 14 sensor ID (4-byte, little-endian)"
+      },
+      wheel15: {
+        size: 4,
+        description: "Wheel 15 sensor ID (4-byte, little-endian)"
+      }
+    }
+  },
+  firmwareVersion: {
+    id: [98, 144],
+    name: "firmwareVersion",
+    structure: {
+      bluetoothStackVersion: {
+        size: 20,
+        description: "Bluetooth stack version + bootloader (e.g. BT stack 4.0.0.191)"
+      },
+      configurationDataVersion: {
+        size: 4,
+        description: "Configuration data version"
+      },
+      bleChipFwCompilationDate: {
+        size: 7,
+        description: "BLE chip FW compilation date: second, minute, hour, day, month, year (2-byte, big-endian)"
+      },
+      bluetoothChipFwVersion: {
+        size: 4,
+        description: "Bluetooth chip FW version: major.minor.patch + release type (e.g. 1.2.0 Release)"
+      }
+    }
   }
 };
 
@@ -1980,12 +2148,13 @@ const bridgeCommands = {
     );
     return await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.autolearnIdStatus, payload);
   },
-  async getAutolearnUnknownSensors(device) {
-    const result = await this.readCommand(device, subCommandIds.autolearnUnknownSensors);
+  async getAutolearnUnknownSensors(deviceId) {
+    const deviceData = bridgeTools.getBridgeFromStore(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.autolearnUnknownSensors);
     const structurized = bridgeTools.convertBytesToStructure(
       bridgeCommandStructures.autolearnUnknownSensors.structure,
       result.data,
-      device.advertisingData.fwVersion
+      deviceData.advertisingData.fwVersion
     );
     return { ...structurized, isFactory: result.isFactory };
   },
@@ -2009,8 +2178,9 @@ const bridgeCommands = {
   async getPressuresPerAxle(deviceId) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
     const result = await this.readCommand(deviceData, subCommandIds.pressurePerAxle);
+    const structure = bridgeTools.usesKpaPressure(deviceId) ? bridgeCommandStructures.pressuresPerAxleKpa.structure : bridgeCommandStructures.pressuresPerAxle.structure;
     const structurizedData = bridgeTools.convertBytesToStructure(
-      bridgeCommandStructures.pressuresPerAxle.structure,
+      structure,
       result.data,
       deviceData.advertisingData.fwVersion
     );
@@ -2018,8 +2188,9 @@ const bridgeCommands = {
   },
   async setPressuresPerAxle(deviceId, structurizedPayload) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
+    const structure = bridgeTools.usesKpaPressure(deviceId) ? bridgeCommandStructures.pressuresPerAxleKpa.structure : bridgeCommandStructures.pressuresPerAxle.structure;
     const payload = bridgeTools.convertStructureToBytes(
-      bridgeCommandStructures.pressuresPerAxle.structure,
+      structure,
       structurizedPayload,
       deviceData.advertisingData.fwVersion
     );
@@ -2056,6 +2227,18 @@ const bridgeCommands = {
     );
     return structurizedData;
   },
+  async getFirmwareVersion(deviceId) {
+    const deviceData = bridgeTools.getBridgeFromStore(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.firmwareVersion, {
+      headerLength: 5,
+      footerLength: 0
+    });
+    return bridgeTools.convertBytesToStructure(
+      bridgeCommandStructures.firmwareVersion.structure,
+      result.data,
+      deviceData.advertisingData.fwVersion
+    );
+  },
   async getSensorMeasurement(deviceId, positionId) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
     const isSpare = String(positionId).endsWith("0");
@@ -2069,7 +2252,7 @@ const bridgeCommands = {
     const result = await this.writeCommand(deviceData, commandIds$1.sensorMeasurement, subCommandId, []);
     return result;
   },
-  async readCommand(device, subCommandId) {
+  async readCommand(device, subCommandId, { headerLength = 19, footerLength = 8 } = {}) {
     const commandLength = 2;
     const result = await this.promisify(device, [
       ...this.getCommandHeader(device),
@@ -2077,9 +2260,9 @@ const bridgeCommands = {
       commandIds$1.readData,
       subCommandId
     ]);
-    const data = result.slice(19, result.length - 8);
-    const crc = result.slice(result.length - 8, result.length - 4);
-    const isFactory = crc.every((n) => n === 0);
+    const data = result.slice(headerLength, result.length - footerLength);
+    const crc = result.slice(result.length - footerLength, result.length - footerLength + 4);
+    const isFactory = crc.length === 4 && crc.every((n) => n === 0);
     return { data, isFactory };
   },
   async writeCommand(device, commandId, subCommandId, payload) {
@@ -2216,7 +2399,7 @@ async function setVehicleLayout(deviceId, tcVehicle) {
   }
   await bridgeCommands.setVehicleLayout(deviceId, result);
 }
-async function getConfiguration(deviceId) {
+async function getConfiguration(deviceId, includeVehicleData = false) {
   const customerCANSettings = await bridgeCommands.getCustomerCANSettings(deviceId);
   const workshopCANSettings = await bridgeCommands.getWorkshopCANSettings(deviceId);
   const customerPressureThresholds = await bridgeCommands.getCustomerPressureThresholds(deviceId);
@@ -2227,7 +2410,7 @@ async function getConfiguration(deviceId) {
   if (bridgeTools.isVersionGreaterThan(deviceId, "0.9.7")) {
     autolearnSettings = await bridgeCommands.getAutolearnSettings(deviceId);
   }
-  return {
+  const configuration = {
     customerCANSettings,
     workshopCANSettings,
     customerPressureThresholds,
@@ -2236,6 +2419,24 @@ async function getConfiguration(deviceId) {
     pressuresPerAxle,
     autolearnSettings
   };
+  if (includeVehicleData) {
+    configuration.vehicleLayout = await bridgeCommands.getVehicleLayout(deviceId);
+    configuration.axleInfo = [];
+    for (let axleIndex = 0; axleIndex < 15; axleIndex++) {
+      const axleBytes = await bridgeCommands.getAxleInfo(deviceId, axleIndex);
+      configuration.axleInfo.push(
+        bridgeTools.convertBytesToStructure(bridgeCommandStructures.idsPerWheel.structure, axleBytes)
+      );
+    }
+    if (bridgeTools.isVersionGreaterThan(deviceId, "1.1.F")) {
+      configuration.firmwareVersion = await bridgeCommands.getFirmwareVersion(deviceId);
+    }
+    if (bridgeTools.isVersionGreaterThan(deviceId, "0.9.7")) {
+      configuration.autolearnIdStatus = await bridgeCommands.getAutolearnIdStatus(deviceId);
+      configuration.autolearnUnknownSensors = await bridgeCommands.getAutolearnUnknownSensors(deviceId);
+    }
+  }
+  return configuration;
 }
 function bridgeVehiclesDifference(original, change) {
   const differences = [];
@@ -2404,6 +2605,8 @@ async function setAxleInfo(deviceId, tcVehicle) {
 async function setAxlesPressure(deviceId, axles) {
   let data = [];
   let bridgeAxlesPressureData;
+  const width = bridgeTools.usesKpaPressure(deviceId) ? 2 : 1;
+  const maxFallback = width === 2 ? 65535 : 255;
   for (let index = 0; index < 15; index++) {
     let { targetPressure, maxTargetPressure, minTargetPressure, isSpare } = axles[index] || {};
     maxTargetPressure = bridgeTools.convertBarToKpaByte(deviceId, maxTargetPressure);
@@ -2417,14 +2620,19 @@ async function setAxlesPressure(deviceId, axles) {
       if (!bridgeAxlesPressureData) {
         bridgeAxlesPressureData = await bridgeCommands.getAxlesPressure(deviceId);
       }
-      maxTargetPressure = bridgeAxlesPressureData.data[index * 3] || 255;
+      const base = index * width * 3;
+      maxTargetPressure = bridgeTools.bytesToInt(bridgeAxlesPressureData.data.slice(base, base + width)) || maxFallback;
     }
     if (targetPressure > maxTargetPressure) {
       targetPressure = maxTargetPressure;
     } else if (targetPressure < minTargetPressure) {
       targetPressure = minTargetPressure;
     }
-    data = data.concat([maxTargetPressure, minTargetPressure, targetPressure]);
+    data = data.concat([
+      ...bridgeTools.intToBytes(maxTargetPressure, width),
+      ...bridgeTools.intToBytes(minTargetPressure, width),
+      ...bridgeTools.intToBytes(targetPressure, width)
+    ]);
   }
   await bridgeCommands.setAxlesPressure(deviceId, data);
 }
@@ -2771,21 +2979,20 @@ async function assignTyres(deviceId, tcVehicle) {
 }
 async function assignAxlePressureLimits(deviceId, tcVehicle, tcVehicleAxle, axleIndex, bridgeAxlesPressureData) {
   const axlesPressureData = bridgeAxlesPressureData ?? (await bridgeCommands.getAxlesPressure(deviceId)).data;
-  if (axlesPressureData[axleIndex * 3]) {
-    tcVehicleAxle.maxTargetPressure = ___default.floor(
-      bridgeTools.convertKpaByteToBar(deviceId, axlesPressureData[axleIndex * 3]),
-      1
-    );
+  const width = bridgeTools.usesKpaPressure(deviceId) ? 2 : 1;
+  const base = axleIndex * width * 3;
+  const maxRaw = bridgeTools.bytesToInt(axlesPressureData.slice(base, base + width));
+  const minRaw = bridgeTools.bytesToInt(axlesPressureData.slice(base + width, base + width * 2));
+  const setRaw = bridgeTools.bytesToInt(axlesPressureData.slice(base + width * 2, base + width * 3));
+  if (maxRaw) {
+    tcVehicleAxle.maxTargetPressure = ___default.floor(bridgeTools.convertKpaByteToBar(deviceId, maxRaw), 1);
   }
-  if (axlesPressureData[axleIndex * 3 + 1]) {
-    tcVehicleAxle.minTargetPressure = ___default.ceil(
-      bridgeTools.convertKpaByteToBar(deviceId, axlesPressureData[axleIndex * 3 + 1]),
-      1
-    );
+  if (minRaw) {
+    tcVehicleAxle.minTargetPressure = ___default.ceil(bridgeTools.convertKpaByteToBar(deviceId, minRaw), 1);
   }
-  if (axlesPressureData[axleIndex * 3 + 2]) {
+  if (setRaw) {
     tcVehicleAxle.targetPressure = ___default.round(
-      bridgeTools.convertKpaByteToBar(deviceId, axlesPressureData[axleIndex * 3 + 2], void 0),
+      bridgeTools.convertKpaByteToBar(deviceId, setRaw, void 0),
       1
     );
   }

package/dist/index.d.cts

@@ -419,6 +419,78 @@ declare const _default: {
             };
         };
     };
+    /**
+     * kPa per-axle pressure layout used from FW 1.2.0 onwards (same sub-command 0x30 as `pressuresPerAxle`).
+     * Each axle packs the same three values (set; min; max) but every value is a 2-byte little-endian raw kPa
+     * uint16 (no 5.0625 bit scaling), so each axle is 6 bytes instead of 3. Selected at runtime via
+     * `bridgeTools.usesKpaPressure(deviceId)`.
+     */
+    pressuresPerAxleKpa: {
+        id: number[];
+        name: string;
+        structure: {
+            axle01: {
+                size: number;
+                description: string;
+            };
+            axle02: {
+                size: number;
+                description: string;
+            };
+            axle03: {
+                size: number;
+                description: string;
+            };
+            axle04: {
+                size: number;
+                description: string;
+            };
+            axle05: {
+                size: number;
+                description: string;
+            };
+            axle06: {
+                size: number;
+                description: string;
+            };
+            axle07: {
+                size: number;
+                description: string;
+            };
+            axle08: {
+                size: number;
+                description: string;
+            };
+            axle09: {
+                size: number;
+                description: string;
+            };
+            axle10: {
+                size: number;
+                description: string;
+            };
+            axle11: {
+                size: number;
+                description: string;
+            };
+            axle12: {
+                size: number;
+                description: string;
+            };
+            axle13: {
+                size: number;
+                description: string;
+            };
+            axle14: {
+                size: number;
+                description: string;
+            };
+            axle15: {
+                size: number;
+                description: string;
+            };
+        };
+    };
     autolearnSettings: {
         id: number[];
         name: string;
@@ -501,7 +573,87 @@ declare const _default: {
             };
         };
     };
-    autolearnIdStatus: BridgeCommandStructure;
+    autolearnIdStatus: {
+        id: number[];
+        name: string;
+        structure: {
+            axle01: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle02: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle03: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle04: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle05: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle06: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle07: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle08: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle09: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle10: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle11: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle12: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle13: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle14: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+            axle15: {
+                size: number;
+                description: string;
+                display: "reverseHex";
+            };
+        };
+    };
     autolearnUnknownSensors: {
         id: number[];
         name: string;
@@ -645,6 +797,94 @@ declare const _default: {
             };
         };
     };
+    idsPerWheel: {
+        id: number[];
+        name: string;
+        structure: {
+            wheel01: {
+                size: number;
+                description: string;
+            };
+            wheel02: {
+                size: number;
+                description: string;
+            };
+            wheel03: {
+                size: number;
+                description: string;
+            };
+            wheel04: {
+                size: number;
+                description: string;
+            };
+            wheel05: {
+                size: number;
+                description: string;
+            };
+            wheel06: {
+                size: number;
+                description: string;
+            };
+            wheel07: {
+                size: number;
+                description: string;
+            };
+            wheel08: {
+                size: number;
+                description: string;
+            };
+            wheel09: {
+                size: number;
+                description: string;
+            };
+            wheel10: {
+                size: number;
+                description: string;
+            };
+            wheel11: {
+                size: number;
+                description: string;
+            };
+            wheel12: {
+                size: number;
+                description: string;
+            };
+            wheel13: {
+                size: number;
+                description: string;
+            };
+            wheel14: {
+                size: number;
+                description: string;
+            };
+            wheel15: {
+                size: number;
+                description: string;
+            };
+        };
+    };
+    firmwareVersion: {
+        id: number[];
+        name: string;
+        structure: {
+            bluetoothStackVersion: {
+                size: number;
+                description: string;
+            };
+            configurationDataVersion: {
+                size: number;
+                description: string;
+            };
+            bleChipFwCompilationDate: {
+                size: number;
+                description: string;
+            };
+            bluetoothChipFwVersion: {
+                size: number;
+                description: string;
+            };
+        };
+    };
 };
 
 type DeepPartial<T> = T extends object ? {
@@ -732,6 +972,15 @@ interface BridgeConfiguration {
     pressuresPerAxle: BridgeCommandStructurized<typeof _default.pressuresPerAxle.structure>;
     /** only available after 0.9.8 fw */
     autolearnSettings?: BridgeCommandStructurized<typeof _default.autolearnSettings.structure>;
+    vehicleLayout?: BridgeCommandStructurized<typeof _default.vehicleLayout.structure>;
+    /** Per-axle wheel sensor IDs, indexed by axle (0-14). Each entry holds the 15 wheel slots of one axle. */
+    axleInfo?: BridgeCommandStructurized<typeof _default.idsPerWheel.structure>[];
+    /** Parsed 0x90 SW Version DID (BT stack, config data version, BLE chip compilation date, BT chip FW version). */
+    firmwareVersion?: BridgeCommandStructurized<typeof _default.firmwareVersion.structure>;
+    /** only available after 0.9.7 fw */
+    autolearnIdStatus?: BridgeCommandStructurized<typeof _default.autolearnIdStatus.structure>;
+    /** only available after 0.9.7 fw */
+    autolearnUnknownSensors?: BridgeCommandStructurized<typeof _default.autolearnUnknownSensors.structure>;
 }
 interface BridgeReading {
     date: number;
@@ -963,7 +1212,7 @@ declare function createTirecheckDeviceSdk(platform: DevicePlatform, bleImplement
         connect: (deviceId: string, accessLevel: BridgeAccessLevel) => Promise<void>;
         getVehicle: (deviceId: string) => Promise<BridgeTcVehicle>;
         setVehicle: (deviceId: string, tcVehicle: BridgeTcVehicle) => Promise<void>;
-        getConfiguration: (deviceId: string) => Promise<BridgeConfiguration>;
+        getConfiguration: (deviceId: string, includeVehicleData?: boolean) => Promise<BridgeConfiguration>;
         setConfiguration: (deviceId: string, bridgeConfiguration: BridgeConfiguration) => Promise<void>;
         getSensorReading: (deviceId: string, positionId: number) => Promise<BridgeReading>;
         getVehicleReadings: (deviceId: string, tcVehicle: BridgeTcVehicle) => Promise<BridgeReading[]>;