@hangtime/grip-connect 0.5.2 → 0.5.4

package/README.md

@@ -117,7 +117,7 @@ motherboardButton.addEventListener("click", () => {
     enable it at `chrome://flags/#enable-experimental-web-platform-features`.
 - ✅ [Kilter Board](https://stevie-ray.github.io/hangtime-grip-connect/devices/kilterboard.html)
 - ✅ [Entralpi](https://stevie-ray.github.io/hangtime-grip-connect/devices/entralpi.html) / Lefu Scale
-- ⏳ [PitchSix Force Board](https://stevie-ray.github.io/hangtime-grip-connect/devices/forceboard.html)
+- ✅ [PitchSix Force Board](https://stevie-ray.github.io/hangtime-grip-connect/devices/forceboard.html)
 - ➡️ [Climbro](https://stevie-ray.github.io/hangtime-grip-connect/devices/climbro.html)
 - ➡️ [Smartboard Climbing - mySmartBoard](https://stevie-ray.github.io/hangtime-grip-connect/devices/mysmartboard.html)
 

package/dist/{download.d.ts → helpers/download.d.ts}

@@ -1,4 +1,4 @@
-import type { DownloadPacket } from "./types/download";
+import type { DownloadPacket } from "../interfaces/download.interface";
 /**
  * Array of DownloadPacket entries.
  */

package/dist/helpers/is-device.d.ts

@@ -1,37 +1,37 @@
 import type { Device } from "./../models/device.model";
 /**
- * Checks if the given device is an Entralpi device.
- * @param {Device} [board] - The device to check.
+ * Checks if the given device is an Entralpi.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with the name "ENTRALPI", otherwise `false`.
  */
-export declare const isEntralpi: (board?: Device) => boolean;
+export declare const isEntralpi: (device?: Device) => boolean;
 /**
  * Checks if the given device is a Force Board.
- * @param {Device} [board] - The device to check.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with the name "Force Board", otherwise `false`.
  */
-export declare const isForceBoard: (board?: Device) => boolean;
+export declare const isForceBoard: (device?: Device) => boolean;
 /**
- * Checks if the given device is a Kilterboard.
- * @param {Device} [board] - The device to check.
- * @returns {boolean} `true` if the device has a service UUID matching the Kilterboard Aurora UUID, otherwise `false`.
+ * Checks if the given device is a Kilter Board.
+ * @param {Device} [device] - The device to check.
+ * @returns {boolean} `true` if the device has a service UUID matching the Kilter Board Aurora UUID, otherwise `false`.
  */
-export declare const isKilterboard: (board?: Device) => boolean;
+export declare const isKilterBoard: (device?: Device) => boolean;
 /**
  * Checks if the given device is a Motherboard.
- * @param {Device} [board] - The device to check.
- * @returns {boolean} `true` if the device has a filter with the name "Motherboard", otherwise `false`.
+ * @param {Device} [device] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with the name "Motherdevice", otherwise `false`.
  */
-export declare const isMotherboard: (board?: Device) => boolean;
+export declare const isMotherboard: (device?: Device) => boolean;
 /**
  * Checks if the given device is a Progressor.
- * @param {Device} [board] - The device to check.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with a namePrefix of "Progressor", otherwise `false`.
  */
-export declare const isProgressor: (board?: Device) => boolean;
+export declare const isProgressor: (device?: Device) => boolean;
 /**
  * Checks if the given device is a WH-C06.
- * @param {Device} [board] - The device to check.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with the company identifier 0x0100, otherwise `false`.
  */
-export declare const isWHC06: (board?: Device) => boolean;
+export declare const isWHC06: (device?: Device) => boolean;

package/dist/helpers/is-device.js

@@ -1,39 +1,39 @@
-import { AuroraUUID } from "./../models/device/kilterboard.model";
+import { KilterBoard } from "../models";
 /**
- * Checks if the given device is an Entralpi device.
- * @param {Device} [board] - The device to check.
+ * Checks if the given device is an Entralpi.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with the name "ENTRALPI", otherwise `false`.
  */
-export const isEntralpi = (board) => board?.filters.some((filter) => filter.name === "ENTRALPI") ?? false;
+export const isEntralpi = (device) => device?.filters.some((filter) => filter.name === "ENTRALPI") ?? false;
 /**
  * Checks if the given device is a Force Board.
- * @param {Device} [board] - The device to check.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with the name "Force Board", otherwise `false`.
  */
-export const isForceBoard = (board) => board?.filters.some((filter) => filter.name === "Force Board") ?? false;
+export const isForceBoard = (device) => device?.filters.some((filter) => filter.name === "Force Board") ?? false;
 /**
- * Checks if the given device is a Kilterboard.
- * @param {Device} [board] - The device to check.
- * @returns {boolean} `true` if the device has a service UUID matching the Kilterboard Aurora UUID, otherwise `false`.
+ * Checks if the given device is a Kilter Board.
+ * @param {Device} [device] - The device to check.
+ * @returns {boolean} `true` if the device has a service UUID matching the Kilter Board Aurora UUID, otherwise `false`.
  */
-export const isKilterboard = (board) => {
-    return board?.filters.some((filter) => filter.services?.includes(AuroraUUID)) ?? false;
+export const isKilterBoard = (device) => {
+    return device?.filters.some((filter) => filter.services?.includes(KilterBoard.AuroraUUID)) ?? false;
 };
 /**
  * Checks if the given device is a Motherboard.
- * @param {Device} [board] - The device to check.
- * @returns {boolean} `true` if the device has a filter with the name "Motherboard", otherwise `false`.
+ * @param {Device} [device] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with the name "Motherdevice", otherwise `false`.
  */
-export const isMotherboard = (board) => board?.filters.some((filter) => filter.name === "Motherboard") ?? false;
+export const isMotherboard = (device) => device?.filters.some((filter) => filter.name === "Motherdevice") ?? false;
 /**
  * Checks if the given device is a Progressor.
- * @param {Device} [board] - The device to check.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with a namePrefix of "Progressor", otherwise `false`.
  */
-export const isProgressor = (board) => board?.filters.some((filter) => filter.namePrefix === "Progressor") ?? false;
+export const isProgressor = (device) => device?.filters.some((filter) => filter.namePrefix === "Progressor") ?? false;
 /**
  * Checks if the given device is a WH-C06.
- * @param {Device} [board] - The device to check.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with the company identifier 0x0100, otherwise `false`.
  */
-export const isWHC06 = (board) => board?.filters.some((filter) => filter.manufacturerData?.some((data) => data.companyIdentifier === 0x0100)) ?? false;
+export const isWHC06 = (device) => device?.filters.some((filter) => filter.manufacturerData?.some((data) => data.companyIdentifier === 0x0100)) ?? false;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { Climbro, Entralpi, ForceBoard, KilterBoard, Motherboard, mySmartBoard, WHC06, Progressor, } from "./models/index";
-export { isEntralpi, isKilterboard, isMotherboard, isWHC06, isProgressor } from "./helpers/is-device";
-export { download } from "./download";
-export { active, isActive } from "./is-active";
-export { tare } from "./tare";
+export { isEntralpi, isKilterBoard, isMotherboard, isWHC06, isProgressor } from "./helpers/is-device";
+export { download } from "./helpers/download";
+export { active, isActive } from "./helpers/is-active";
+export { tare } from "./helpers/tare";

package/dist/index.js

@@ -1,7 +1,6 @@
 export { Climbro, Entralpi, ForceBoard, KilterBoard, Motherboard, mySmartBoard, WHC06, Progressor, } from "./models/index";
 // helpers
-export { isEntralpi, isKilterboard, isMotherboard, isWHC06, isProgressor } from "./helpers/is-device";
-// TODO: Make functions device specific
-export { download } from "./download";
-export { active, isActive } from "./is-active";
-export { tare } from "./tare";
+export { isEntralpi, isKilterBoard, isMotherboard, isWHC06, isProgressor } from "./helpers/is-device";
+export { download } from "./helpers/download";
+export { active, isActive } from "./helpers/is-active";
+export { tare } from "./helpers/tare";

package/dist/interfaces/callback.interface.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Represents the mass data collected from a device.
+ */
+export interface massObject {
+    /**
+     * The total mass measured from the device.
+     * This is the overall weight or force reading.
+     */
+    massTotal: string;
+    /**
+     * The maximum mass recorded during the session.
+     * This is the highest weight or force value detected.
+     */
+    massMax: string;
+    /**
+     * The average mass calculated from all the recorded data points.
+     * This represents the mean value of the mass measurements.
+     */
+    massAverage: string;
+    /**
+     * The mass recorded on the left side of the device (optional for Motherboard devices).
+     * Used for devices that measure force across multiple zones.
+     */
+    massLeft?: string;
+    /**
+     * The mass recorded at the center of the device (optional for Motherboard devices).
+     * Used for devices that measure force distribution across a center zone.
+     */
+    massCenter?: string;
+    /**
+     * The mass recorded on the right side of the device (optional for Motherboard devices).
+     * Used for devices that measure force across multiple zones.
+     */
+    massRight?: string;
+}
+/**
+ * Defines the type for a callback function that handles mass data notifications.
+ * The callback receives a `massObject` as the parameter.
+ * @callback NotifyCallback
+ * @param {massObject} data - The mass data passed to the callback.
+ */
+export type NotifyCallback = (data: massObject) => void;
+/**
+ * Defines the type for a callback function that handles write operations to the device.
+ * The callback receives the data string written to the device.
+ * @callback WriteCallback
+ * @param {string} data - The string data passed to the callback.
+ */
+export type WriteCallback = (data: string) => void;

package/dist/interfaces/command.interface.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Represents the available commands for various devices such as the Motherboard and Tindeq Progressor.
+ */
+export interface Commands {
+    /**
+     * Starts a weight measurement on the device.
+     * Used to begin collecting weight or force data.
+     */
+    START_WEIGHT_MEAS?: string;
+    /**
+     * Stops the current weight measurement on the device.
+     * Used to end the data collection.
+     */
+    STOP_WEIGHT_MEAS?: string;
+    /**
+     * Puts the device to sleep or in a low-power mode.
+     * The format can be a string or a number depending on the device.
+     */
+    SLEEP?: number | string;
+    /**
+     * Retrieves the serial number of the device.
+     * This command fetches the unique identifier assigned by the manufacturer.
+     */
+    GET_SERIAL?: string;
+    /**
+     * Retrieves textual information from the device.
+     * May include readable data.
+     */
+    GET_TEXT?: string;
+    /**
+     * Starts or stops a debug data stream from the device.
+     * Used for diagnostic purposes or to monitor real-time data.
+     */
+    DEBUG_STREAM?: string;
+    /**
+     * Retrieves calibration data from the device.
+     * Used to ensure accurate measurements by applying calibration points.
+     */
+    GET_CALIBRATION?: string;
+    /**
+     * Tares the scale, zeroing the current weight measurement.
+     * Used to reset the baseline for weight data.
+     */
+    TARE_SCALE?: string;
+    /**
+     * Starts measuring the peak rate of force development (RFD).
+     * Captures how quickly force is applied over time.
+     */
+    START_PEAK_RFD_MEAS?: string;
+    /**
+     * Starts measuring a series of peak RFD measurements.
+     * This captures multiple RFD data points over a period of time.
+     */
+    START_PEAK_RFD_MEAS_SERIES?: string;
+    /**
+     * Adds a calibration point to the device.
+     * Used to improve the accuracy of future measurements.
+     */
+    ADD_CALIB_POINT?: string;
+    /**
+     * Saves the current calibration settings to the device.
+     * Ensures the device remembers the calibration for future sessions.
+     */
+    SAVE_CALIB?: string;
+    /**
+     * Retrieves the firmware version of the device.
+     * Useful for ensuring compatibility and tracking updates.
+     */
+    GET_FW_VERSION?: string;
+    /**
+     * Retrieves error information from the device.
+     * Provides details on any faults or issues that occurred during operation.
+     */
+    GET_ERR_INFO?: string;
+    /**
+     * Clears the error information on the device.
+     * Used to reset error logs after troubleshooting or repair.
+     */
+    CLR_ERR_INFO?: string;
+    /**
+     * Retrieves the battery voltage level of the device.
+     * Provides insight into the device's remaining battery power.
+     */
+    GET_BATT_VLTG?: string;
+}

package/dist/interfaces/device/forceboard.interface.d.ts

@@ -18,4 +18,20 @@ export interface IForceBoard extends IDevice {
      * @returns {Promise<string | undefined>} A Promise that resolves with the manufacturer information.
      */
     manufacturer(): Promise<string | undefined>;
+    /**
+     * Stops the data stream on the specified device.
+     * @returns {Promise<void>} A promise that resolves when the stream is stopped.
+     */
+    stop(): Promise<void>;
+    /**
+     * Starts streaming data from the specified device.
+     * @param {number} [duration=0] - The duration of the stream in milliseconds. If set to 0, stream will continue indefinitely.
+     * @returns {Promise<void>} A promise that resolves when the streaming operation is completed.
+     */
+    stream(duration?: number): Promise<void>;
+    /**
+     * Retrieves temperature information from the device.
+     * @returns {Promise<string | undefined>} A Promise that resolves with the humidity level.
+     */
+    temperature(): Promise<string | undefined>;
 }

package/dist/interfaces/device.interface.d.ts

@@ -1,5 +1,6 @@
 import type { IBase } from "./base.interface";
-import type { massObject } from "../types/notify";
+import type { massObject } from "./callback.interface";
+import type { Commands } from "./command.interface";
 /**
  * Represents a characteristic of a Bluetooth service.
  */
@@ -30,12 +31,26 @@ export interface Service {
  * Represents a Bluetooth device.
  */
 export interface IDevice extends IBase {
-    /** Filters to indentify the device */
+    /**
+     * Filters to identify the device during Bluetooth scanning.
+     * Used to match devices that meet specific criteria such as name, service UUIDs, etc.
+     */
     filters: BluetoothLEScanFilter[];
-    /** Array of services provided by the device */
+    /**
+     * Array of services provided by the device.
+     * Services represent functionalities that the device supports, such as weight measurement, battery information, or custom services.
+     */
     services: Service[];
-    /** Reference to the BluetoothDevice object representing this device */
+    /**
+     * Reference to the `BluetoothDevice` object representing this device.
+     * This is the actual device object obtained from the Web Bluetooth API after a successful connection.
+     */
     bluetooth?: BluetoothDevice;
+    /**
+     * Object representing the set of commands available for this device.
+     * These commands allow communication with the device to perform various operations such as starting measurements, retrieving data, or calibrating the device.
+     */
+    commands: Commands;
     /**
      * Connects to a Bluetooth device.
      * @param {Function} [onSuccess] - Optional callback function to execute on successful connection. Default logs success.
@@ -76,12 +91,6 @@ export interface IDevice extends IBase {
      * @returns {void}
      */
     notify(callback: (data: massObject) => void): void;
-    /**
-     * Defines the type for the callback function.
-     * @callback NotifyCallback
-     * @param {massObject} data - The data passed to the callback.
-     */
-    notifyCallback: (data: massObject) => void;
     /**
      * Handles the 'connected' event.
      * @param {Function} onSuccess - Callback function to execute on successful connection.
@@ -97,9 +106,9 @@ export interface IDevice extends IBase {
      * @param {string} serviceId - The service ID where the characteristic belongs.
      * @param {string} characteristicId - The characteristic ID to read from.
      * @param {number} [duration=0] - The duration to wait before resolving the promise, in milliseconds.
-     * @returns {Promise<string>} A promise that resolves when the read operation is completed.
+     * @returns {Promise<string | undefined>} A promise that resolves when the read operation is completed.
      */
-    read(serviceId: string, characteristicId: string, duration?: number): Promise<string>;
+    read(serviceId: string, characteristicId: string, duration?: number): Promise<string | undefined>;
     /**
      * Writes a message to the specified characteristic of a Bluetooth device and optionally provides a callback to handle responses.
      * @param {string} serviceId - The service UUID of the Bluetooth device containing the target characteristic.
@@ -119,14 +128,5 @@ export interface IDevice extends IBase {
      * });
      */
     write(serviceId: string, characteristicId: string, message: string | Uint8Array | undefined, duration?: number, callback?: (data: string) => void): Promise<void>;
-    /**
-     * A default write callback that logs the response
-     */
-    writeCallback: (data: string) => void;
-    /**
-     * The last message written to the device.
-     * @type {string | Uint8Array | null}
-     */
-    writeLast: string | Uint8Array | null;
 }
 export {};

package/dist/models/device/entralpi.model.d.ts

@@ -18,7 +18,7 @@ export declare class Entralpi extends Device implements IEntralpi {
      */
     firmware: () => Promise<string | undefined>;
     /**
-     * Handles data received from the Progressor device, processes weight measurements,
+     * Handles data received from the device, processes weight measurements,
      * and updates mass data including maximum and average values.
      * It also handles command responses for retrieving device information.
      *

package/dist/models/device/entralpi.model.js

@@ -1,11 +1,6 @@
 import { Device } from "../device.model";
-import { applyTare } from "../../tare";
-import { checkActivity } from "../../is-active";
-// Constants
-let MASS_MAX = "0";
-let MASS_AVERAGE = "0";
-let MASS_TOTAL_SUM = 0;
-let DATAPOINT_COUNT = 0;
+import { applyTare } from "../../helpers/tare";
+import { checkActivity } from "../../helpers/is-active";
 export class Entralpi extends Device {
     constructor() {
         super({
@@ -133,40 +128,24 @@ export class Entralpi extends Device {
      * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information.
      */
     battery = async () => {
-        if (this.isConnected()) {
-            return await this.read("battery", "level", 250);
-        }
-        // If device is not found, return undefined
-        return undefined;
+        return await this.read("battery", "level", 250);
     };
     /**
      * Retrieves IEEE 11073-20601 Regulatory Certification from the device.
      * @returns {Promise<string>} A Promise that resolves with the certification.
      */
     certification = async () => {
-        // Check if the device is connected
-        if (this.isConnected()) {
-            // Read certification from the device
-            return await this.read("device", "certification", 250);
-        }
-        // If device is not found, return undefined
-        return undefined;
+        return await this.read("device", "certification", 250);
     };
     /**
      * Retrieves firmware version from the device.
      * @returns {Promise<string>} A Promise that resolves with the firmware version.
      */
     firmware = async () => {
-        // Check if the device is connected
-        if (this.isConnected()) {
-            // Read firmware version from the Motherboard
-            return await this.read("device", "firmware", 250);
-        }
-        // If device is not found, return undefined
-        return undefined;
+        return await this.read("device", "firmware", 250);
     };
     /**
-     * Handles data received from the Progressor device, processes weight measurements,
+     * Handles data received from the device, processes weight measurements,
      * and updates mass data including maximum and average values.
      * It also handles command responses for retrieving device information.
      *
@@ -183,20 +162,20 @@ export class Entralpi extends Device {
                 let numericData = Number(receivedData);
                 // Tare correction
                 numericData -= applyTare(numericData);
-                // Update MASS_MAX
-                MASS_MAX = Math.max(Number(MASS_MAX), numericData).toFixed(1);
+                // Update massMax
+                this.massMax = Math.max(Number(this.massMax), numericData).toFixed(1);
                 // Update running sum and count
                 const currentMassTotal = Math.max(-1000, numericData);
-                MASS_TOTAL_SUM += currentMassTotal;
-                DATAPOINT_COUNT++;
+                this.massTotalSum += currentMassTotal;
+                this.dataPointCount++;
                 // Calculate the average dynamically
-                MASS_AVERAGE = (MASS_TOTAL_SUM / DATAPOINT_COUNT).toFixed(1);
+                this.massAverage = (this.massTotalSum / this.dataPointCount).toFixed(1);
                 // Check if device is being used
                 checkActivity(numericData);
                 // Notify with weight data
                 this.notifyCallback({
-                    massMax: MASS_MAX,
-                    massAverage: MASS_AVERAGE,
+                    massMax: this.massMax,
+                    massAverage: this.massAverage,
                     massTotal: Math.max(-1000, numericData).toFixed(1),
                 });
             }
@@ -207,39 +186,21 @@ export class Entralpi extends Device {
      * @returns {Promise<string>} A Promise that resolves with the hardware version.
      */
     hardware = async () => {
-        // Check if the device is connected
-        if (this.isConnected()) {
-            // Read hardware version from the device
-            return await this.read("device", "hardware", 250);
-        }
-        // If device is not found, return undefined
-        return undefined;
+        return await this.read("device", "hardware", 250);
     };
     /**
      * Retrieves manufacturer information from the device.
      * @returns {Promise<string>} A Promise that resolves with the manufacturer information.
      */
     manufacturer = async () => {
-        // Check if the device is connected
-        if (this.isConnected()) {
-            // Read manufacturer information from the device
-            return await this.read("device", "manufacturer", 250);
-        }
-        // If device is not found, return undefined
-        return undefined;
+        return await this.read("device", "manufacturer", 250);
     };
     /**
      * Retrieves model number from the device.
      * @returns {Promise<string>} A Promise that resolves with the model number.
      */
     model = async () => {
-        // Check if the device is connected
-        if (this.isConnected()) {
-            // Read model number from the Entralpi
-            return await this.read("device", "model", 250);
-        }
-        // If device is not found, return undefined
-        return undefined;
+        return await this.read("device", "model", 250);
     };
     /**
      * Retrieves PnP ID from the device, a set of values that used to create a device ID value that is unique for this device.
@@ -247,38 +208,20 @@ export class Entralpi extends Device {
      * @returns {Promise<string>} A Promise that resolves with the PnP ID.
      */
     pnp = async () => {
-        // Check if the device is connected
-        if (this.isConnected()) {
-            // Read software version from the Entralpi
-            return await this.read("device", "pnp", 250);
-        }
-        // If device is not found, return undefined
-        return undefined;
+        return await this.read("device", "pnp", 250);
     };
     /**
      * Retrieves software version from the device.
      * @returns {Promise<string>} A Promise that resolves with the software version.
      */
     software = async () => {
-        // Check if the device is connected
-        if (this.isConnected()) {
-            // Read software version from the Entralpi
-            return await this.read("device", "software", 250);
-        }
-        // If device is not found, return undefined
-        return undefined;
+        return await this.read("device", "software", 250);
     };
     /**
      * Retrieves system id from the device.
      * @returns {Promise<string>} A Promise that resolves with the system id.
      */
     system = async () => {
-        // Check if the device is connected
-        if (this.isConnected()) {
-            // Read system id from the device
-            return await this.read("device", "system", 250);
-        }
-        // If device is not found, return undefined
-        return undefined;
+        return await this.read("device", "system", 250);
     };
 }

package/dist/models/device/forceboard.model.d.ts

@@ -10,6 +10,14 @@ export declare class ForceBoard extends Device implements IForceBoard {
      * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information,
      */
     battery: () => Promise<string | undefined>;
+    /**
+     * Handles data received from the device, processes weight measurements,
+     * and updates mass data including maximum and average values.
+     * It also handles command responses for retrieving device information.
+     *
+     * @param {Event} event - The notification event.
+     */
+    handleNotifications: (event: Event) => void;
     /**
      * Retrieves humidity level from the device.
      * @returns {Promise<string>} A Promise that resolves with the humidity level,
@@ -20,4 +28,20 @@ export declare class ForceBoard extends Device implements IForceBoard {
      * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
      */
     manufacturer: () => Promise<string | undefined>;
+    /**
+     * Stops the data stream on the specified device.
+     * @returns {Promise<void>} A promise that resolves when the stream is stopped.
+     */
+    stop: () => Promise<void>;
+    /**
+     * Starts streaming data from the specified device.
+     * @param {number} [duration=0] - The duration of the stream in milliseconds. If set to 0, stream will continue indefinitely.
+     * @returns {Promise<void>} A promise that resolves when the streaming operation is completed.
+     */
+    stream: (duration?: number) => Promise<void>;
+    /**
+     * Retrieves temperature information from the device.
+     * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
+     */
+    temperature: () => Promise<string | undefined>;
 }