@medwand/mwsdk-javascript 0.0.0-stage → 3.2.2

package/dist/index.d.ts

@@ -0,0 +1,1248 @@
+declare type CameraEvents = {
+    /**
+     * Occurs when a new frame is ready to be processed.
+     *
+     * @remarks
+     * This event provides the raw frame data as a `Uint8ClampedArray` of RGBA pixels.
+     * Subscribers can use this data for further processing, such as rendering or saving the frame.
+     */
+    FrameReady: Uint8ClampedArray;
+    /**
+     * Occurs when a recorded frame is ready for processing or display.
+     *
+     * @remarks
+     * This event is triggered after a frame has been recorded by the camera module.
+     * The event provides the recorded frame data as a `Uint8ClampedArray` of RGBA pixels.
+     */
+    RecordedFrameReady: Uint8ClampedArray;
+};
+
+/**
+ * Specifies the available camera modes for the MedWand SDK.
+ *
+ * @remarks
+ * This enumeration defines the operational modes for cameras supported by the MedWand SDK,
+ * including modes for turning the camera off, using it as a dermatoscope, or as an otoscope.
+ */
+export declare enum CameraModes {
+    /** The camera is turned off. */
+    Off = 0,
+    /** The camera is operating in dermatoscope mode, suitable for skin examinations. */
+    Dermatoscope = 1,
+    /** The camera is operating in otoscope mode, suitable for ear examinations. */
+    Otoscope = 2
+}
+
+/**
+ * Represents a module for managing camera events within a browser application.
+ */
+export declare class CameraModule extends TypedEventTarget<CameraEvents> {
+    /** Stops preview, releases camera media resources, and removes event subscriptions. */
+    Dispose(): void;
+}
+
+/**
+ * Represents the various states of a device within the device state machine.
+ */
+export declare enum DeviceState {
+    /**
+     * Indicates that the device is not currently connected.
+     */
+    NotConnected = 0,
+    /**
+     * Indicates that the device is in the process of establishing a connection.
+     */
+    Connecting = 1,
+    /**
+     * Indicates that the device is successfully connected and ready for further operations.
+     */
+    Connected = 2,
+    /**
+     * Indicates that the device is in the process of initializing.
+     * This state occurs after the device has connected but before it is fully initialized.
+     */
+    Initializing = 3,
+    /**
+     * Indicates that the device has completed the initialization process
+     * and is ready for operation.
+     */
+    Initialized = 4,
+    /**
+     * Represents the state where the device is in the process of disconnecting from its current connection.
+     */
+    DisConnecting = 5,
+    /**
+     * Represents a state in the device state machine, indicating that the device has a required firmware update pending.
+     */
+    FirmwareUpdateRequired = 6,
+    /**
+     * Represents a state in the device state machine, indicating that the device is updating the firmware.
+     */
+    FirmwareUpdating = 7,
+    /**
+     * Represents an error state in the device state machine, indicating that the device has encountered an issue.
+     */
+    Error = 8
+}
+
+declare type EcgEvents = {
+    /**
+     * Occurs when a recorded ECG strip is ready for processing or display.
+     *
+     * @remarks
+     * This event is triggered after the ECG recording is stopped and the recorded data is converted into a bitmap.
+     * The event provides the recorded ECG strip as a `Uint8Array` in BMP format.
+     */
+    RecordedStripReady: Uint8Array;
+};
+
+/**
+ * Represents the ECG (Electrocardiogram) module for browser applications, providing functionality for monitoring, recording,
+ * and processing ECG data.
+ */
+export declare class EcgModule extends TypedEventTarget<EcgEvents> {
+    private constructor();
+    /** Stops ECG processing and removes event subscriptions. */
+    Dispose(): void;
+}
+
+/**
+ * Enumeration for MedWand device/communication errors.
+ */
+export declare enum ErrorCode {
+    /**
+     * An un specified error has occured.
+     */
+    Generic = 0,
+    /**
+     * The MedWand device was not found.
+     */
+    DeviceNotFound = 1,
+    /**
+     * The serial port has failed to connect.
+     */
+    SerialPortConnectionError = 2,
+    /**
+     * The serial port has failed to open.
+     */
+    SerialPortOpenError = 3,
+    /**
+     * The serial port has failed.
+     */
+    SerialPortError = 4,
+    /**
+     * The serial port has failed.
+     */
+    SerialPortClosedError = 5,
+    /**
+     * The serial port transmission has failed.
+     */
+    SerialPortTransmitError = 6,
+    /**
+     * The serial port notification.
+     */
+    SerialPortNotification = 7
+}
+
+declare type EventHandler<T> = (payload: T) => void;
+
+declare type EventMap = Record<string, unknown>;
+
+/**
+ * The `FirmwareController` class facilitates the firmware update process by managing device connections, handling update workflows, and reporting progress and errors through events. Use `DisposeAsync` to ensure proper resource cleanup after use.
+ *
+ * See the {@link https://github.com/orgs/MedWand/repositories | MedWand DECL Sample Applications} for full examples.
+ *
+ * @remarks
+ * This copy of the MedWand Software Libraries (MSL) is licensed to You as the end user or to Your employer or another third party authorized to permit under the TERMS AND CONDITIONS OF THE MSL LICENSE AGREEMENT. Firmware updates may be required to correct performance problems and will be provided under the MSL Agreement where deemed applicable by MedWand. No license is granted to you for redistribution of MedWand Device Firmware. You expressly agree to make Device Firmware Upgrade calls, using the provided DECL(s) libraries whenever you are notified of a new firmware upgrade, and in any event, not less than every 90 days, and receive firmware updates for the MedWand hardware device within your software workflow and/or UI. Failure to update firmware when notified of a firmware update may affect the availability of features and the reliability of the MedWand and its related software. See MSL agreement for additional details.
+ */
+export declare class FirmwareController extends TypedEventSubscriptions<FirmwareControllerEvents> {
+    /**
+     * Initializes a new instance of the `FirmwareController` class.
+     *
+     * @param signal - An optional `AbortSignal` that can be used to cancel operations initiated by this controller.
+     */
+    constructor(signal?: AbortSignal | undefined);
+    /**
+     * Initiates the firmware update process for the connected MedWand device.
+     *
+     * See the {@link https://github.com/orgs/MedWand/repositories | MedWand DECL Sample Applications} for full examples.
+     *
+     * @returns A promise that resolves to `true` if the firmware update process completes successfully.
+     * It resolves to `false` on failure or cancellation.
+     *
+     * @remarks
+     * This method establishes a connection to the MedWand device and then proceeds with the firmware update.
+     * Ensure that you have internet connectivity and the device remains connected during the update process to avoid interruptions.
+     * Dispose the `MedWandController` first and invoke this method from a user gesture so the browser can request serial permission.
+     * Subscribe to `FirmwareError` or `DeviceErrorReceived` to handle specific errors.
+     */
+    StartAsync(): Promise<boolean>;
+    /** Cancels active work, releases the serial port, and removes event subscriptions. */
+    DisposeAsync(): Promise<void>;
+}
+
+declare type FirmwareControllerEvents = {
+    /** Notifies the caller when the updater moves between high-level workflow states. */
+    FirmwareStateChanged: UpdaterState;
+    /** Reports stage-local progress as an integer percentage. */
+    FirmwareProgressChanged: number;
+    /** Reports errors encountered during the firmware update. */
+    FirmwareError: Error;
+    /** Reports low-level errors raised by the browser serial connection. */
+    DeviceErrorReceived: Error;
+};
+
+/**
+ * Represents information about the focus capabilities of a camera.
+ *
+ * @remarks
+ * This record encapsulates details about the focus functionality of a camera,
+ * including whether it supports auto-focus or manual focus, as well as the
+ * minimum and maximum focus values.
+ */
+export declare interface FocusInfo {
+    /** Indicates whether the camera supports automatic focus. */
+    HasAutoFocus: boolean;
+    /** Indicates whether the camera supports manual focus. */
+    HasManualFocus: boolean;
+    /** The lowest manual focus value supported by the camera. */
+    FocusMinimum: number;
+    /** The highest manual focus value supported by the camera. */
+    FocusMaximum: number;
+}
+
+/**
+ * Specifies the available focus modes for cameras supported by the MedWand SDK.
+ *
+ * @remarks
+ * This enumeration defines the focus modes that can be used with cameras,
+ * including no focus adjustment, automatic focus adjustment, and manual focus adjustment.
+ */
+export declare enum FocusModes {
+    /** No focus adjustment is applied. */
+    None = 0,
+    /** The camera automatically adjusts the focus. */
+    Auto = 1,
+    /** The focus is manually adjusted by the user. */
+    Manual = 2
+}
+
+/**
+ * Represents an error associated with a license, including its state and any related exception details.
+ */
+export declare class LicenseError {
+    /**
+     * Represents the current state of the license.
+     */
+    readonly State: LicenseState;
+    /**
+     * Exception details.
+     */
+    readonly Exception: Error;
+    /**
+     * Initializes a new instance of the `LicenseError` class.
+     *
+     * @param state - The license state associated with the error.
+     * @param exception - The underlying error.
+     */
+    constructor(state: LicenseState, exception: Error);
+}
+
+/**
+ * Defines the various states of a license within the system.
+ */
+export declare enum LicenseState {
+    /**
+     * Represents an invalid state of the license, indicating that the license is either missing, corrupted, or otherwise unusable.
+     */
+    Invalid = 0,
+    /**
+     * Indicates that the license is does not support the feature requested.
+     */
+    InvalidFeature = 1,
+    /**
+     * Indicates that the license is nearing its expiration date but is still valid.
+     */
+    Expiring = 2,
+    /**
+     * Indicates that the license has expired and is no longer valid.
+     */
+    Expired = 3
+}
+
+/**
+ * Represents a controller for managing and interacting with various MedWand devices in a browser application.
+ *
+ * See the {@link https://github.com/orgs/MedWand/repositories | MedWand DECL Sample Applications} for full examples.
+ *
+ * @remarks
+ * This copy of the MedWand Software Libraries (MSL) is licensed to You as the end user or to Your employer or another third party authorized to permit under the TERMS AND CONDITIONS OF THE MSL LICENSE AGREEMENT. Firmware updates may be required to correct performance problems and will be provided under the MSL Agreement where deemed applicable by MedWand. No license is granted to you for redistribution of MedWand Device Firmware. You expressly agree to make Device Firmware Upgrade calls, using the provided DECL(s) libraries whenever you are notified of a new firmware upgrade, and in any event, not less than every 90 days, and receive firmware updates for the MedWand hardware device within your software workflow and/or UI. Failure to update firmware when notified of a firmware update may affect the availability of features and the reliability of the MedWand and its related software. See MSL agreement for additional details.
+ */
+export declare class MedWandController extends TypedEventTarget<MedWandControllerEvents> {
+    /**
+     * Represents the name of the MedWand device.
+     *
+     * @remarks
+     * This field is initialized with the default value "MedWand".
+     */
+    static readonly DeviceName = "MedWand";
+    /**
+     * Initializes a new instance of the `MedWandController` class.
+     *
+     * See the {@link https://github.com/orgs/MedWand/repositories | MedWand DECL Sample Applications} for full examples.
+     *
+     * @remarks
+     * This copy of the MedWand Software Libraries (MSL) is licensed to You as the end user or to Your employer or another third party authorized to permit under the TERMS AND CONDITIONS OF THE MSL LICENSE AGREEMENT. Firmware updates may be required to correct performance problems and will be provided under the MSL Agreement where deemed applicable by MedWand. No license is granted to you for redistribution of MedWand Device Firmware. You expressly agree to make Device Firmware Upgrade calls, using the provided DECL(s) libraries whenever you are notified of a new firmware upgrade, and in any event, not less than every 90 days, and receive firmware updates for the MedWand hardware device within your software workflow and/or UI. Failure to update firmware when notified of a firmware update may affect the availability of features and the reliability of the MedWand and its related software. See MSL agreement for additional details.
+     */
+    constructor();
+    /**
+     * Initializes the MedWand controller with the provided license information and public key.
+     *
+     * @param licenseString - The license string required to initialize the MedWand controller. This value must not be null or empty.
+     * @param publicKey - The public key associated with the license string. This value must not be null or empty.
+     *
+     * @remarks
+     * If the license is invalid, expired, or nearing expiration, the `OnLicenseError` event will be triggered.
+     */
+    Construct(licenseString: string, publicKey: string): void;
+    /**
+     * Configures the `MedWandController` by initializing its modules based on available features
+     * and optionally setting up the ECG module with the provided canvas.
+     *
+     * @param ecgCanvas - An `HTMLCanvasElement` used to initialize the ECG module if the ECG feature is available.
+     * Pass `null` if the ECG module should not be initialized with a canvas.
+     */
+    Configure(ecgCanvas?: HTMLCanvasElement | null): void;
+    /**
+     * Gets a value indicating whether the license associated with the MedWand device is valid.
+     *
+     * @remarks
+     * `true` if the license is valid; otherwise, `false`.
+     *
+     * This property is determined by the internal license controller and reflects the current state of the license.
+     */
+    get IsLicenseValid(): boolean;
+    /**
+     * Gets the current state of the MedWand device.
+     *
+     * @remarks
+     * The `DeviceState` property reflects the current operational state of the device,
+     * such as whether it is connected, disconnected, initializing, or in an error state.
+     * Changes to this property trigger the `OnDeviceStateChanged` event.
+     *
+     * A `DeviceState` enumeration value representing the current state of the device.
+     */
+    get DeviceState(): DeviceState;
+    /**
+     * Gets the current state of the reading process for the MedWand device.
+     *
+     * @remarks
+     * The `ReadingState` property reflects the operational state of the device's reading mechanism.
+     * Possible states include `Stopped`, `Starting`,
+     * `Started`, `Reading`, `Recording`,
+     * `Stopping`, and `Error`.
+     *
+     * A `ReadingState` enumeration value representing the current state of the reading process.
+     */
+    get ReadingState(): ReadingState;
+    /**
+     * Gets a value indicating whether the MedWand device is currently connected.
+     *
+     * @remarks
+     * A device is considered connected if its state is one of the following:
+     * `Connected`, `Initializing`, or `Initialized`.
+     *
+     * `true` if the device is connected; otherwise, `false`.
+     */
+    get IsConnected(): boolean;
+    /**
+     * Gets a value indicating whether the MedWand device has been successfully initialized.
+     *
+     * @remarks
+     * `true` if the device is initialized; otherwise, `false`.
+     *
+     * The `IsInitialized` property reflects the initialization state of the MedWand device.
+     * It becomes `true` after the device has completed the initialization process successfully.
+     */
+    get IsInitialized(): boolean;
+    /**
+     * Gets the license information associated with the current instance of the MedWand controller.
+     *
+     * @remarks
+     * This property retrieves a string representation of the license details managed by the underlying license controller.
+     *
+     * A `string` containing the license information.
+     */
+    get LicenseInfo(): string;
+    /**
+     * Gets a value indicating whether the stethoscope feature can be used with the current license.
+     *
+     * @remarks
+     * `true` if the stethoscope feature is available; otherwise, `false`.
+     *
+     * This property checks the license to determine if the "Stethoscope" feature is enabled.
+     */
+    get CanUseStethoscope(): boolean;
+    /**
+     * Gets a value indicating whether the camera feature can be used based on the current license.
+     *
+     * @remarks
+     * `true` if the camera feature is available; otherwise, `false`.
+     *
+     * This property checks the license to determine if the "Camera" feature is enabled.
+     */
+    get CanUseCamera(): boolean;
+    /**
+     * Gets a value indicating whether the ECG (Electrocardiogram) feature can be used.
+     *
+     * @remarks
+     * `true` if the ECG feature is available and licensed; otherwise, `false`.
+     *
+     * This property checks the license to determine if the ECG feature is enabled.
+     */
+    get CanUseEcg(): boolean;
+    /**
+     * Gets the Vendor ID of the connected MedWand device.
+     */
+    get VendorId(): string | null;
+    /**
+     * Gets the product identifier of the connected MedWand device.
+     */
+    get ProductId(): string | null;
+    /**
+     * Gets the name of the port associated with the MedWand device.
+     */
+    get ComPort(): string | null;
+    /**
+     * Establishes a connection to the MedWand device.
+     *
+     * @throws MedWandFirmwareUpdateRequiredException when a device in bootloader mode requires a firmware update.
+     * @throws Error when a device is in bootloader mode and the firmware service does not report a required version.
+     */
+    Connect(): Promise<void>;
+    /**
+     * Initializes the MedWand device, setting it to the `Initialized` state if successful.
+     */
+    Initialize(): Promise<void>;
+    /**
+     * Gets the firmware version read during connection, or null before it is known.
+     * A failed device version query is represented by "0.0.0.0".
+     */
+    get FirmwareVersion(): string | null;
+    /**
+     * Checks the MedWand firmware service for the version required by this device.
+     *
+     * @remarks
+     * This mirrors the Windows base controller workflow. The method only checks the
+     * installed version; it does not start an update or take ownership of the serial
+     * port for `FirmwareController`.
+     *
+     * @throws MedWandFirmwareUpdateRequiredException when the service reports a
+     * different required version. The device state is changed to
+     * `FirmwareUpdateRequired` before the exception is thrown.
+     * As in the Windows SDK, an unavailable or invalid check response is treated
+     * as no reported update and does not prevent use of the connected device.
+     */
+    CheckFirmwareVersion(): Promise<void>;
+    /**
+     * Determines whether the device is currently in bootloader mode.
+     */
+    IsBootloaderMode(forceCheck?: boolean): Promise<boolean>;
+    /**
+     * Gets the unique identifier of the connected MedWand device.
+     *
+     * @remarks
+     * The `DeviceId` property retrieves the device's unique identifier.
+     * If the identifier is not already cached, it attempts to fetch it by transmitting
+     * the appropriate command to the device and waiting for a response.
+     *
+     * A `string` representing the unique identifier of the MedWand device.
+     * Returns an empty string if the identifier cannot be retrieved.
+     */
+    get DeviceId(): string;
+    /**
+     * Gets the generation of the MedWand device.
+     *
+     * @remarks
+     * The generation is determined based on the device's unique identifier or by querying the device.
+     * Possible values include `Generation1`, `Generation2`,
+     * `Unknown`, and `NotReady`.
+     *
+     * A `MedWandGeneration` value representing the generation of the MedWand device.
+     */
+    get Generation(): MedWandGeneration;
+    /**
+     * Gets the Unique Device Identifier (UDI) of the connected MedWand device.
+     *
+     * @remarks
+     * The UDI is a globally unique identifier that provides detailed information about the device.
+     * If the UDI is not already cached, this property attempts to retrieve it from the device.
+     *
+     * A `string` representing the UDI of the device, or an empty string if the UDI could not be retrieved.
+     */
+    get Udi(): string;
+    /**
+     * Gets the most recent reading data from the MedWand sensor.
+     *
+     * @remarks
+     * An instance of `MedWandReading` containing the latest sensor data,
+     * such as timestamp, status, and various measurement values.
+     */
+    get LastReading(): MedWandReading;
+    /**
+     * Gets the currently active sensor on the MedWand device.
+     *
+     * @remarks
+     * A `MedWandSensor` value representing the sensor currently in use.
+     * Defaults to `None` if no sensor is active.
+     *
+     * The active sensor is managed by the internal reading state machine and is updated
+     * when a sensor is started or stopped. Ensure that no other sensor is active before
+     * starting a new one to avoid conflicts.
+     */
+    get ActiveSensor(): MedWandSensor;
+    /**
+     * Gets the current intensity level of the LED.
+     *
+     * @remarks
+     * An integer representing the LED intensity level.
+     *
+     * The LED intensity level is managed internally and can be adjusted using the appropriate methods.
+     * Changes to the intensity level trigger the `OnLedIntensityChanged` event.
+     */
+    get LedIntensity(): number;
+    /**
+     * Gets a value indicating whether a valid stethoscope module is available.
+     *
+     * @remarks
+     * `true` if a valid stethoscope module is present; otherwise, `false`.
+     */
+    get HasValidStethoscope(): boolean;
+    /**
+     * Gets a value indicating whether the stethoscope is currently monitoring.
+     *
+     * @remarks
+     * `true` if the stethoscope is actively monitoring; otherwise, `false`.
+     */
+    get StethoscopeIsMonitoring(): boolean;
+    /**
+     * Gets the instance of the `StethoscopeModule` associated with the controller.
+     *
+     * @remarks
+     * The `Stethoscope` property provides access to the stethoscope module, allowing interaction with
+     * stethoscope-related functionalities, such as monitoring and recording.
+     *
+     * An instance of `StethoscopeModule` if a valid stethoscope module is available; otherwise, `null`.
+     */
+    get Stethoscope(): StethoscopeModule | null;
+    /**
+     * Gets the model name of the connected stethoscope.
+     *
+     * @remarks
+     * A `string` representing the name of the stethoscope model if available; otherwise, "Unknown".
+     */
+    get StethoscopeModel(): string;
+    /**
+     * Gets the current microphone mode of the stethoscope.
+     *
+     * @remarks
+     * A `MicrophoneModes` value representing the mode of the stethoscope.
+     * Defaults to `Off` if the stethoscope is not available.
+     */
+    get StethoscopeMode(): MicrophoneModes;
+    /**
+     * Converts the provided stethoscope capture data into a WAV audio file format.
+     *
+     * @param bytes - The byte array representing the stethoscope capture data.
+     *
+     * @returns A Base64-encoded string representing the WAV audio file, or `null` if the conversion fails
+     * or the stethoscope module is not valid.
+     *
+     * @remarks
+     * This method utilizes the stethoscope module to process the raw capture data and generate
+     * a WAV audio file. Ensure that the stethoscope module is properly initialized before calling this method.
+     */
+    StethoscopeWavFromCapture(bytes: Uint8Array): string | null;
+    /**
+     * Gets a value indicating whether a valid otoscope is available.
+     *
+     * @remarks
+     * `true` if a valid otoscope is available; otherwise, `false`.
+     */
+    get HasValidOtoscope(): boolean;
+    /**
+     * Gets the camera module associated with the `MedWandController`.
+     *
+     * @remarks
+     * The `CameraModule` instance if a valid camera module is available; otherwise, `null`.
+     *
+     * The camera module provides functionality for managing camera operations, such as monitoring, zooming, and adjusting LED intensity.
+     */
+    get Camera(): CameraModule | null;
+    /**
+     * Gets a value indicating whether the camera is currently monitoring.
+     *
+     * @remarks
+     * `true` if the camera is actively monitoring; otherwise, `false`.
+     *
+     * This property checks the `Camera` instance to determine if it is in a monitoring state.
+     */
+    get CameraIsMonitoring(): boolean;
+    /**
+     * Gets the model name of the connected camera.
+     *
+     * @remarks
+     * A `string` representing the name of the camera model if a valid camera is connected; otherwise, "Unknown".
+     */
+    get CameraModel(): string;
+    /**
+     * Gets the current camera mode of the connected camera module.
+     *
+     * @remarks
+     * The `CameraModes` representing the selected camera mode.
+     * Returns `Off` if no camera module is available.
+     */
+    get CameraMode(): CameraModes;
+    /**
+     * Converts a captured byte array from the camera into a Base64-encoded bitmap string.
+     *
+     * @param bytes - The byte array representing the captured camera frame.
+     * @returns A Base64-encoded bitmap string, or `null` if the camera module is not available.
+     *
+     * @remarks
+     * This method utilizes the camera module to process the provided byte array and generate a Base64-encoded bitmap string.
+     * Ensure that the camera module is valid before invoking this method.
+     */
+    CameraBmpFromCapture(bytes: Uint8Array | Uint8ClampedArray): string | null;
+    /**
+     * Gets a value indicating whether the camera associated with the controller has an "On Timer" feature.
+     *
+     * @remarks
+     * `true` if the camera has an "On Timer" feature; otherwise, `false`.
+     *
+     * This property checks if the camera's model supports the "On Timer" functionality.
+     */
+    get CameraHasOnTimer(): boolean;
+    /**
+     * Gets the maximum duration, in seconds, that the camera can remain active before requiring a cooldown period.
+     *
+     * @remarks
+     * The maximum active time for the camera, or -100 if the camera is not available.
+     *
+     * This property retrieves the value from the camera model's `OnTimeMax` property.
+     */
+    get CameraOnTimeMax(): number;
+    /**
+     * Gets the minimum cooldown time, in seconds, required for the camera to be operational again
+     * after it has been turned off.
+     *
+     * @remarks
+     * The minimum cooldown time in seconds. Returns `-100` if the camera is not available.
+     */
+    get CameraCoolTimeMin(): number;
+    /**
+     * Moves the camera by the specified increments in the horizontal and vertical directions.
+     *
+     * @param incrementLeft - The amount to move the camera horizontally. A positive value moves the camera to the right,
+     * a negative value moves it to the left, and `null` indicates no horizontal movement.
+     *
+     * @param incrementTop - The amount to move the camera vertically. A positive value moves the camera downward,
+     * a negative value moves it upward, and `null` indicates no vertical movement.
+     */
+    CameraMove(incrementLeft: number | null, incrementTop: number | null): void;
+    /**
+     * Adjusts the zoom level of the camera by the specified increment.
+     *
+     * @param increment - The amount by which to adjust the zoom level. Positive values zoom in,
+     * while negative values zoom out.
+     *
+     * @remarks
+     * This method delegates the zoom functionality to the associated `CameraModule`.
+     * Ensure that a valid camera module is available before invoking this method.
+     */
+    CameraZoom(increment: number): void;
+    /**
+     * Adjusts the camera's radius by the specified increment.
+     *
+     * @param increment - The value by which to adjust the camera's radius. Positive values increase the radius,
+     * while negative values decrease it.
+     */
+    CameraRadius(increment: number): void;
+    /**
+     * Sets the white LED intensity on an initialized device.
+     *
+     * @param value - Intensity supported by the camera; zero turns the LED off.
+     */
+    SetLedIntensity(value: number): Promise<void>;
+    /**
+     * Sets the LED intensity for the camera.
+     *
+     * @param value - The intensity value to set for the camera's LED. The value should be within the allowable range defined by the camera.
+     *
+     * @remarks
+     * This method adjusts the brightness of the camera's LED. Ensure that the provided value is within the range specified by
+     * `CameraLedIntensityMax`.
+     */
+    CameraSetLedIntensity(value: number): Promise<void>;
+    /** Sets the camera focus mode when the active browser camera supports it. */
+    CameraSetFocusMode(focusMode: FocusModes, resetLastValue: boolean): Promise<void>;
+    /** Sets the manual focus distance when the active browser camera supports it. */
+    CameraSetFocusValue(focusValue: number): Promise<void>;
+    /**
+     * Resets the camera to its default state by invoking the reset functionality of the associated camera module.
+     *
+     * @remarks
+     * This method is a wrapper around the `Reset` method,
+     * which resets the camera's zoom and position to their initial values.
+     * It has no effect if the camera module is not valid or initialized.
+     */
+    CameraReset(): void;
+    /** Gets focus controls and distance bounds reported by the active browser camera. */
+    get CameraFocusInfo(): FocusInfo | null;
+    /**
+     * Gets the currently selected focus mode of the camera.
+     *
+     * @remarks
+     * A `FocusModes` value representing the current focus mode of the camera.
+     *
+     * The focus mode can be `None`, `Auto`, or `Manual`.
+     */
+    get CameraFocusMode(): FocusModes;
+    /**
+     * Gets a value indicating whether the camera's LED intensity is adjustable.
+     *
+     * @remarks
+     * `true` if the camera's LED intensity can be adjusted; otherwise, `false`.
+     */
+    get CameraLedIntensityAdjustable(): boolean;
+    /**
+     * Gets the maximum LED intensity value for the camera.
+     *
+     * @remarks
+     * An `int` representing the maximum LED intensity. Returns 0 if the camera is not available.
+     */
+    get CameraLedIntensityMax(): number;
+    /**
+     * Gets a value indicating whether a valid ECG (Electrocardiogram) module is available.
+     *
+     * @remarks
+     * `true` if a valid ECG module is present; otherwise, `false`.
+     */
+    get HasValidEcg(): boolean;
+    /**
+     * Gets the ECG module associated with the MedWand device.
+     *
+     * @remarks
+     * An instance of `EcgModule` if the ECG module is valid; otherwise, `null`.
+     *
+     * The ECG module provides functionality for monitoring, recording, and processing ECG data.
+     */
+    get Ecg(): EcgModule | null;
+    /**
+     * Gets the recorded ECG (Electrocardiogram) data as an array of numbers.
+     *
+     * @remarks
+     * This property retrieves the ECG data that was recorded during a session.
+     * The data is represented as a list of numerical values, where each value corresponds
+     * to a specific point in the ECG signal. If no data is available, the property returns `null`.
+     *
+     * A `number[]` representing the recorded ECG data, or `null` if no data is available.
+     */
+    get EcgRecordedData(): number[] | null;
+    /**
+     * Converts a captured byte array from the ECG into a Base64-encoded bitmap string.
+     *
+     * @param bytes - The byte array representing the captured ECG data.
+     *
+     * @returns A Base64-encoded string representation of the bitmap if the conversion is successful;
+     * otherwise, `null` if the ECG module is not available.
+     *
+     * @remarks
+     * This method utilizes the ECG module to process the provided byte array and generate
+     * a Base64-encoded bitmap string. Ensure that the ecg module is valid before invoking this method.
+     */
+    EcgBmpFromCapture(bytes: Uint8Array): string | null;
+    /**
+     * Starts the thermometer sensor for temperature measurement.
+     *
+     * @returns `true` if the thermometer starts successfully; otherwise, `false`.
+     *
+     * @remarks
+     * This method overrides the base implementation to initiate the thermometer sensor.
+     * Ensure that the necessary hardware and licenses are valid before calling this method.
+     */
+    StartThermometer(): Promise<boolean>;
+    /**
+     * Starts the pulse oximeter sensor.
+     *
+     * @returns `true` if the pulse oximeter sensor starts successfully; otherwise, `false`.
+     *
+     * @remarks
+     * This method overrides the base implementation to provide functionality specific to the
+     * `MedWandController` class.
+     */
+    StartPulseOximeter(): Promise<boolean>;
+    /**
+     * Starts the ECG (Electrocardiogram) monitoring process.
+     */
+    StartEcg(): Promise<boolean>;
+    /**
+     * Configures the stethoscope filter without opening the MedWand microphone or
+     * starting an SDK-managed audio preview.
+     *
+     * @param microphoneMode - The desired microphone mode for the stethoscope. Supported modes include Off, Heart,
+     * Lungs, and Bowel.
+     * @returns `true` if the stethoscope mode was successfully set; otherwise, `false`.
+     *
+     * @throws Error if the stethoscope module is not initialized or an unsupported microphone mode is provided.
+     *
+     * @remarks
+     * Use this overload when the application connects directly to the MedWand
+     * microphone with its own audio stack. Call this method with `Off` when the
+     * application is finished with the stethoscope.
+     */
+    SetStethoscopeMode(microphoneMode: MicrophoneModes): Promise<boolean>;
+    /**
+     * Configures the stethoscope filter and starts or stops the SDK-managed audio preview.
+     *
+     * @param microphoneMode - The desired microphone mode for the stethoscope. Supported modes include Off, Heart,
+     * Lungs, and Bowel.
+     * @param speakerName - The speaker to use for audio output. Pass `null` to use the system default speaker.
+     * @returns `true` if the stethoscope mode was successfully set; otherwise, `false`.
+     *
+     * @remarks
+     * To connect to the MedWand microphone with an application-managed audio
+     * stack, use the overload without `speakerName`.
+     */
+    SetStethoscopeMode(microphoneMode: MicrophoneModes, speakerName: string | null): Promise<boolean>;
+    /**
+     * Configures the camera mode and optionally starts the camera preview.
+     */
+    SetCameraMode(previewTarget: HTMLVideoElement | HTMLCanvasElement | null, cameraMode: CameraModes): Promise<boolean>;
+    /**
+     * Starts recording data for the currently active sensor.
+     */
+    StartRecording(): void;
+    /**
+     * Stops the recording process for the currently active sensor, if applicable.
+     */
+    StopRecording(): void;
+    /**
+     * Stops the currently active sensor, if any, and performs necessary cleanup operations.
+     */
+    StopSensor(): Promise<boolean>;
+    /**
+     * Releases all resources used by the `MedWandController` instance.
+     */
+    Dispose(): Promise<void>;
+}
+
+declare type MedWandControllerEvents = {
+    /**
+     * Occurs when there is an issue with the license state of the MedWand device.
+     *
+     * @remarks
+     * This event is triggered in scenarios such as:
+     * The license is invalid.
+     * The license has expired.
+     * The license is nearing expiration.
+     */
+    OnLicenseError: LicenseState;
+    /**
+     * Occurs when the state of the MedWand device changes.
+     *
+     * @remarks
+     * This event is triggered whenever the `DeviceState` property transitions to a new state.
+     * It can be used to monitor the connection status, initialization progress, or other state changes
+     * of the MedWand device.
+     */
+    OnDeviceStateChanged: DeviceState;
+    /**
+     * Occurs when an error related to the MedWand device is encountered.
+     *
+     * @remarks
+     * This event is triggered to notify about various device-related errors, such as connection issues,
+     * serial port errors, or other device-specific problems. The event provides detailed error information
+     * through the `MedWandDeviceError` parameter.
+     */
+    OnDeviceError: MedWandDeviceError;
+    /**
+     * Occurs when the reading state of the MedWand device changes.
+     *
+     * @remarks
+     * This event is triggered whenever the `ReadingState` property of the MedWand device changes.
+     * It provides the updated `ReadingState` as an argument to the event handler.
+     */
+    OnReadingStateChanged: ReadingState;
+    /**
+     * Occurs when a new reading is received from the MedWand device.
+     *
+     * @remarks
+     * This event is triggered whenever the MedWand device processes and provides a new reading.
+     * The event handler receives a `MedWandReading` object containing the details of the reading.
+     */
+    OnReadingReceived: MedWandReading;
+    /**
+     * Occurs when the LED intensity of the MedWand device changes.
+     *
+     * @remarks
+     * This event is triggered whenever the LED intensity is updated via the `SetLedIntensity` method.
+     * Subscribers can use this event to respond to changes in the LED intensity, such as updating UI elements or logging.
+     */
+    OnLedIntensityChanged: number;
+};
+
+/**
+ * Represents an error encountered by a MedWand device or during communication with it.
+ *
+ * @remarks
+ * This class encapsulates an error code and an associated exception, providing detailed
+ * information about the nature of the error. It is used throughout the MedWand SDK to
+ * standardize error reporting and handling.
+ */
+export declare class MedWandDeviceError {
+    /**
+     * Error code.
+     */
+    readonly Code: ErrorCode;
+    /**
+     * Exception details.
+     */
+    readonly Exception: Error;
+    /**
+     * Initializes a new instance of the `MedWandDeviceError` class.
+     *
+     * @param code - The code that identifies the device error.
+     * @param exception - The underlying error.
+     */
+    constructor(code: ErrorCode, exception: Error);
+}
+
+/**
+ * Represents an exception that is thrown when a MedWand device requires a firmware update to function properly.
+ *
+ * @remarks
+ * This exception provides details about the current firmware version of the device and the required firmware version.
+ * It is typically used to notify the application that a firmware update is necessary for compatibility or functionality.
+ */
+export declare class MedWandFirmwareUpdateRequiredException extends Error {
+    /** The firmware version currently installed on the device. */
+    readonly CurrentVersion: string;
+    /** The firmware version reported by the MedWand firmware service. */
+    readonly RequiredVersion: string;
+    /**
+     * Initializes an error indicating that the MedWand firmware must be updated.
+     *
+     * @param currentVersion - The firmware version currently installed on the device.
+     * @param requiredVersion - The firmware version required by the firmware service.
+     * @param message - The message describing the required update.
+     */
+    constructor(currentVersion: string, requiredVersion: string, message: string);
+}
+
+/************************************
+ * MedWandGeneration
+ ************************************/
+/**
+ * Enumeration for MedWand Device.
+ */
+export declare enum MedWandGeneration {
+    /**
+     * Generation 1.0 MedWand Device.
+     */
+    Generation1 = 1,
+    /**
+     * Generation 2.0 MedWand Device.
+     */
+    Generation2 = 2,
+    /**
+     * Unknown Generation MedWand Device.
+     */
+    Unknown = 0,
+    /**
+     * Initial state of generation.
+     */
+    NotReady = -1
+}
+
+/**
+ * Class used to return reading data from MedWand sensor.
+ */
+export declare class MedWandReading {
+    /**
+     * DateTime of the reading.
+     */
+    TimeStamp: Date;
+    /**
+     * Current status of the MedWand device.
+     */
+    Status: string | null;
+    /**
+     * ECG reading offest.
+     */
+    Index: number;
+    /**
+     * ECG reading values count.
+     */
+    Count: number;
+    /**
+     * Reading sensor type.
+     */
+    SensorType: string | null;
+    /**
+     * Temperature ambient value.
+     * Will return 'Low' if less than 60.0F
+     * Will return 'High' if greater than 104.0F
+     */
+    TempAmbient: string | null;
+    /**
+     * Temperature fahrenheit value.
+     * Will return 'Low' if less than 92.9F
+     * Will return 'High' if greater than 107.6F
+     */
+    TempObject: string | null;
+    /**
+     * SPO2 pulse rate value.
+     * Will return 'Low' if less than 25
+     * Will return 'High' if greater than 200
+     */
+    PulseRate: string | null;
+    /**
+     * SPO2 value.
+     * Will return 'Low' if less than 70
+     * Will return 'High' if greater than 100
+     */
+    Spo2: string | null;
+    /**
+     * ECG sensor data.
+     */
+    EcgData: string | null;
+    /**
+     * Creates a deep copy of the specified MedWandReading object.
+     *
+     * This method serializes the input object to JSON and then
+     * deserializes it to create a deep copy.
+     *
+     * @param obj The MedWandReading object to clone.
+     * @returns A new instance of MedWandReading that is a deep copy of the input object.
+     * @throws Error Thrown if the obj parameter is null or undefined.
+     */
+    static DeepClone<T>(obj: MedWandReading): MedWandReading;
+}
+
+/**
+ * Enumeration for MedWand device sensor selection.
+ */
+export declare enum MedWandSensor {
+    /**
+     * No sensor selected.
+     */
+    None = 0,
+    /**
+     * Thermometer sensor.
+     */
+    Thermometer = 1,
+    /**
+     * PulseOximeter sensor.
+     */
+    PulseOximeter = 2,
+    /**
+     * Ecg sensor.
+     */
+    Ecg = 3,
+    /**
+     * Stethoscope sensor.
+     */
+    Stethoscope = 4,
+    /**
+     * Otoscope sensor.
+     */
+    Otoscope = 5
+}
+
+/**
+ * Specifies the available microphone modes for the stethoscope functionality
+ * within the MedWand SDK.
+ *
+ * @remarks
+ * These modes determine the type of sound the stethoscope captures, such as
+ * heart sounds, lung sounds, or bowel sounds. The `Off` mode disables
+ * the microphone.
+ */
+export declare enum MicrophoneModes {
+    /** Disables the microphone. */
+    Off = 0,
+    /** Configures the microphone to capture heart sounds. */
+    Heart = 1,
+    /** Configures the microphone to capture lung sounds. */
+    Lungs = 2,
+    /** Configures the microphone to capture bowel sounds. */
+    Bowel = 3
+}
+
+/**
+ * Represents the various states of the reading process in the MedWand SDK.
+ */
+export declare enum ReadingState {
+    /**
+     * Indicates that the reading process is stopped and no active operations are being performed.
+     */
+    Stopped = 0,
+    /**
+     * Indicates that the reading process is in the initial phase of starting.
+     */
+    Starting = 1,
+    /**
+     * Indicates that the reading process has successfully started and is actively running.
+     */
+    Started = 2,
+    /**
+     * Indicates the state where the MedWand device is actively relaying readings.
+     */
+    Reading = 3,
+    /**
+     * Indicates that the MedWand SDK is actively recording data during the reading process.
+     */
+    Recording = 4,
+    /**
+     * Indicates that the reading process is in the phase of stopping.
+     */
+    Stopping = 5,
+    /**
+     * Indicates that an error has occurred during the reading process in the MedWand SDK.
+     */
+    Error = 6
+}
+
+declare type StethoscopeEvents = {
+    /**
+     * Occurs when a new frame is ready to be processed.
+     *
+     * @remarks
+     * This event provides the raw frame data as a byte array. Subscribers can use this data
+     * for further processing, such as rendering or saving the frame.
+     */
+    FrameReady: Uint8Array;
+    /**
+     * Occurs when the recorded frames are ready for processing.
+     *
+     * @remarks
+     * This event is triggered after all frames have been recorded by the stethoscope module.
+     * The event provides the recorded frame data as a byte array.
+     */
+    RecordedFramesReady: Uint8Array;
+};
+
+/**
+ * Enumeration for MedWand stethoscope filter selection.
+ */
+export declare enum StethoscopeFilter {
+    /**
+     * Default audio filter used when initialized.
+     */
+    Off = 0,
+    /**
+     * Heart audio filter.
+     */
+    Heart = 1,
+    /**
+     * Lungs audio filter.
+     */
+    Lungs = 2,
+    /**
+     * Bowel audio filter.
+     */
+    Bowel = 3
+    /**
+    * Fetal audio filter.
+    */
+}
+
+/**
+ * Represents a module for managing stethoscope-related events within a browser application.
+ */
+export declare class StethoscopeModule extends TypedEventSubscriptions<StethoscopeEvents> {
+    /** Stops preview, releases audio resources, and removes event subscriptions. */
+    Dispose(): void;
+}
+
+declare class TypedEventSubscriptions<TEvents extends EventMap> {
+    /**
+     * Subscribes a handler to the named event. The handler receives the event payload.
+     *
+     * @returns A function that removes the subscription.
+     */
+    on<TKey extends keyof TEvents>(eventName: TKey, handler: EventHandler<TEvents[TKey]>): () => void;
+    /** Removes the specified handler from the named event. */
+    off<TKey extends keyof TEvents>(eventName: TKey, handler: EventHandler<TEvents[TKey]>): void;
+}
+
+declare class TypedEventTarget<TEvents extends EventMap> extends TypedEventSubscriptions<TEvents> {
+}
+
+/**
+ * Enumeration for MedWand updater status.
+ */
+export declare enum UpdaterState {
+    /**
+     * Reconnecting to the MedWand device
+     */
+    Reconnecting = 0,
+    /**
+     * Initializing the MedWand device bootloader
+     */
+    Initializing = 1,
+    /**
+     * Erasing the MedWand device firmware
+     */
+    Erasing = 2,
+    /**
+     * Programming the MedWand device firmware
+     */
+    Programming = 3,
+    /**
+     * Reading the MedWand device firmware
+     */
+    Reading = 4,
+    /**
+     * Verifying the MedWand device firmware
+     */
+    Verifying = 5,
+    /**
+     * Commiting the MedWand device firmware
+     */
+    Commiting = 6,
+    /**
+     * Completed the MedWand device firmware
+     */
+    Complete = 7
+}
+
+export { }
+
+/** Browser globals supplied by the standalone SDK bundle. */
+declare global {
+    var MedWandSdk: {
+        readonly CameraModes: typeof CameraModes;
+        readonly CameraModule: typeof CameraModule;
+        readonly DeviceState: typeof DeviceState;
+        readonly EcgModule: typeof EcgModule;
+        readonly ErrorCode: typeof ErrorCode;
+        readonly FirmwareController: typeof FirmwareController;
+        readonly FocusModes: typeof FocusModes;
+        readonly LicenseError: typeof LicenseError;
+        readonly LicenseState: typeof LicenseState;
+        readonly MedWandController: typeof MedWandController;
+        readonly MedWandDeviceError: typeof MedWandDeviceError;
+        readonly MedWandFirmwareUpdateRequiredException: typeof MedWandFirmwareUpdateRequiredException;
+        readonly MedWandGeneration: typeof MedWandGeneration;
+        readonly MedWandReading: typeof MedWandReading;
+        readonly MedWandSensor: typeof MedWandSensor;
+        readonly MicrophoneModes: typeof MicrophoneModes;
+        readonly ReadingState: typeof ReadingState;
+        readonly StethoscopeFilter: typeof StethoscopeFilter;
+        readonly StethoscopeModule: typeof StethoscopeModule;
+        readonly UpdaterState: typeof UpdaterState;
+    };
+}