brilliantsole 0.0.1

package/build/dts/BS.d.ts

@@ -0,0 +1,25 @@
+export { setAllConsoleLevelFlags, setConsoleLevelFlagsForType } from "./utils/Console.ts";
+export * as Environment from "./utils/environment.ts";
+export { Vector2, Vector3, Quaternion, Euler } from "./utils/MathUtils.ts";
+export { default as Device, DeviceEvent, DeviceEventMap, DeviceEventListenerMap, BoundDeviceEventListeners, } from "./Device.ts";
+export { default as DeviceManager, DeviceManagerEvent, DeviceManagerEventMap, DeviceManagerEventListenerMap, BoundDeviceManagerEventListeners, } from "./DeviceManager.ts";
+export { DeviceInformation } from "./DeviceInformationManager.ts";
+export { DeviceType, DeviceTypes, MinNameLength, MaxNameLength, InsoleSides, InsoleSide, } from "./InformationManager.ts";
+export { SensorType, SensorTypes, ContinuousSensorType, ContinuousSensorTypes } from "./sensor/SensorDataManager.ts";
+export { MaxSensorRate, SensorRateStep, SensorConfiguration } from "./sensor/SensorConfigurationManager.ts";
+export { DefaultNumberOfPressureSensors, PressureData } from "./sensor/PressureSensorDataManager.ts";
+export { CenterOfPressure } from "./utils/CenterOfPressureHelper.ts";
+export { VibrationConfiguration, VibrationLocation, VibrationLocations, VibrationType, VibrationTypes, MaxNumberOfVibrationWaveformEffectSegments, MaxVibrationWaveformSegmentDuration, MaxVibrationWaveformEffectSegmentDelay, MaxVibrationWaveformEffectSegmentLoopCount, MaxNumberOfVibrationWaveformSegments, MaxVibrationWaveformEffectSequenceLoopCount, } from "./vibration/VibrationManager.ts";
+export { VibrationWaveformEffect, VibrationWaveformEffects } from "./vibration/VibrationWaveformEffects.ts";
+export { FileType, FileTypes, FileTransferDirection, FileTransferDirections } from "./FileTransferManager.ts";
+export { TfliteSensorType, TfliteSensorTypes, TfliteTask, TfliteTasks } from "./TfliteManager.ts";
+export { default as DevicePair, DevicePairEvent, DevicePairEventMap, DevicePairEventListenerMap, BoundDevicePairEventListeners, } from "./devicePair/DevicePair.ts";
+export { DiscoveredDevice } from "./scanner/BaseScanner.ts";
+/** NODE_START */
+export { default as Scanner } from "./scanner/Scanner.ts";
+export { default as WebSocketServer } from "./server/websocket/WebSocketServer.ts";
+export { default as UDPServer } from "./server/udp/UDPServer.ts";
+/** NODE_END */
+/** BROWSER_START */
+export { default as WebSocketClient } from "./server/websocket/WebSocketClient.ts";
+/** BROWSER_END */

package/build/dts/Device.d.ts

@@ -0,0 +1,136 @@
+import EventDispatcher, { BoundEventListeners, Event, EventListenerMap, EventMap } from "./utils/EventDispatcher.ts";
+import BaseConnectionManager, { TxRxMessageType, ConnectionStatus, ConnectionMessageType, ConnectionStatusEventMessages } from "./connection/BaseConnectionManager.ts";
+import { SensorConfiguration, SensorConfigurationEventMessages } from "./sensor/SensorConfigurationManager.ts";
+import { SensorDataEventMessages, SensorType } from "./sensor/SensorDataManager.ts";
+import { VibrationConfiguration } from "./vibration/VibrationManager.ts";
+import { FileTransferEventMessages, FileType } from "./FileTransferManager.ts";
+import { TfliteEventMessages } from "./TfliteManager.ts";
+import { FirmwareEventMessages } from "./FirmwareManager.ts";
+import { DeviceInformationEventMessages } from "./DeviceInformationManager.ts";
+import InformationManager, { DeviceType, InformationEventMessages } from "./InformationManager.ts";
+import { FileLike } from "./utils/ArrayBufferUtils.ts";
+export declare const DeviceEventTypes: readonly ["connectionMessage", "notConnected", "connecting", "connected", "disconnecting", "connectionStatus", "isConnected", "rx", "tx", "batteryLevel", "isCharging", "getBatteryCurrent", "getMtu", "getId", "getName", "setName", "getType", "setType", "getCurrentTime", "setCurrentTime", "manufacturerName", "modelNumber", "softwareRevision", "hardwareRevision", "firmwareRevision", "pnpId", "serialNumber", "deviceInformation", "getSensorConfiguration", "setSensorConfiguration", "getPressurePositions", "getSensorScalars", "sensorData", "pressure", "acceleration", "gravity", "linearAcceleration", "gyroscope", "magnetometer", "gameRotation", "rotation", "orientation", "activity", "stepCounter", "stepDetector", "deviceOrientation", "barometer", "maxFileLength", "getFileType", "setFileType", "getFileLength", "setFileLength", "getFileChecksum", "setFileChecksum", "setFileTransferCommand", "fileTransferStatus", "getFileBlock", "setFileBlock", "fileBytesTransferred", "fileTransferProgress", "fileTransferComplete", "fileReceived", "getTfliteName", "setTfliteName", "getTfliteTask", "setTfliteTask", "getTfliteSampleRate", "setTfliteSampleRate", "getTfliteSensorTypes", "setTfliteSensorTypes", "tfliteIsReady", "getTfliteCaptureDelay", "setTfliteCaptureDelay", "getTfliteThreshold", "setTfliteThreshold", "getTfliteInferencingEnabled", "setTfliteInferencingEnabled", "tfliteInference", "smp", "firmwareImages", "firmwareUploadProgress", "firmwareStatus", "firmwareUploadComplete"];
+export type DeviceEventType = (typeof DeviceEventTypes)[number];
+export interface DeviceEventMessages extends ConnectionStatusEventMessages, DeviceInformationEventMessages, InformationEventMessages, SensorDataEventMessages, SensorConfigurationEventMessages, TfliteEventMessages, FileTransferEventMessages, FirmwareEventMessages {
+    batteryLevel: {
+        batteryLevel: number;
+    };
+    connectionMessage: {
+        messageType: ConnectionMessageType;
+        dataView: DataView;
+    };
+}
+export type SendMessageCallback<MessageType extends string> = (messages?: {
+    type: MessageType;
+    data?: ArrayBuffer;
+}[], sendImmediately?: boolean) => Promise<void>;
+export type SendSmpMessageCallback = (data: ArrayBuffer) => Promise<void>;
+export type DeviceEventDispatcher = EventDispatcher<Device, DeviceEventType, DeviceEventMessages>;
+export type DeviceEvent = Event<Device, DeviceEventType, DeviceEventMessages>;
+export type DeviceEventMap = EventMap<Device, DeviceEventType, DeviceEventMessages>;
+export type DeviceEventListenerMap = EventListenerMap<Device, DeviceEventType, DeviceEventMessages>;
+export type BoundDeviceEventListeners = BoundEventListeners<Device, DeviceEventType, DeviceEventMessages>;
+export declare const RequiredInformationConnectionMessages: TxRxMessageType[];
+declare class Device {
+    #private;
+    get bluetoothId(): string | undefined;
+    constructor();
+    get addEventListener(): <T extends "maxFileLength" | "getFileType" | "setFileType" | "getFileLength" | "setFileLength" | "getFileChecksum" | "setFileChecksum" | "setFileTransferCommand" | "fileTransferStatus" | "getFileBlock" | "setFileBlock" | "fileBytesTransferred" | "fileTransferProgress" | "fileTransferComplete" | "fileReceived" | "pressure" | "acceleration" | "gravity" | "linearAcceleration" | "gyroscope" | "magnetometer" | "gameRotation" | "rotation" | "orientation" | "activity" | "stepCounter" | "stepDetector" | "deviceOrientation" | "barometer" | "getPressurePositions" | "getSensorScalars" | "sensorData" | "getSensorConfiguration" | "setSensorConfiguration" | "getTfliteName" | "setTfliteName" | "getTfliteTask" | "setTfliteTask" | "getTfliteSampleRate" | "setTfliteSampleRate" | "getTfliteSensorTypes" | "setTfliteSensorTypes" | "tfliteIsReady" | "getTfliteCaptureDelay" | "setTfliteCaptureDelay" | "getTfliteThreshold" | "setTfliteThreshold" | "getTfliteInferencingEnabled" | "setTfliteInferencingEnabled" | "tfliteInference" | "manufacturerName" | "modelNumber" | "softwareRevision" | "hardwareRevision" | "firmwareRevision" | "pnpId" | "serialNumber" | "deviceInformation" | "isCharging" | "getBatteryCurrent" | "getMtu" | "getId" | "getName" | "setName" | "getType" | "setType" | "getCurrentTime" | "setCurrentTime" | "notConnected" | "connecting" | "connected" | "disconnecting" | "connectionStatus" | "isConnected" | "smp" | "batteryLevel" | "rx" | "tx" | "firmwareImages" | "firmwareUploadProgress" | "firmwareStatus" | "firmwareUploadComplete" | "connectionMessage">(type: T, listener: (event: {
+        type: T;
+        target: Device;
+        message: DeviceEventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }) => void;
+    get removeEventListener(): <T extends "maxFileLength" | "getFileType" | "setFileType" | "getFileLength" | "setFileLength" | "getFileChecksum" | "setFileChecksum" | "setFileTransferCommand" | "fileTransferStatus" | "getFileBlock" | "setFileBlock" | "fileBytesTransferred" | "fileTransferProgress" | "fileTransferComplete" | "fileReceived" | "pressure" | "acceleration" | "gravity" | "linearAcceleration" | "gyroscope" | "magnetometer" | "gameRotation" | "rotation" | "orientation" | "activity" | "stepCounter" | "stepDetector" | "deviceOrientation" | "barometer" | "getPressurePositions" | "getSensorScalars" | "sensorData" | "getSensorConfiguration" | "setSensorConfiguration" | "getTfliteName" | "setTfliteName" | "getTfliteTask" | "setTfliteTask" | "getTfliteSampleRate" | "setTfliteSampleRate" | "getTfliteSensorTypes" | "setTfliteSensorTypes" | "tfliteIsReady" | "getTfliteCaptureDelay" | "setTfliteCaptureDelay" | "getTfliteThreshold" | "setTfliteThreshold" | "getTfliteInferencingEnabled" | "setTfliteInferencingEnabled" | "tfliteInference" | "manufacturerName" | "modelNumber" | "softwareRevision" | "hardwareRevision" | "firmwareRevision" | "pnpId" | "serialNumber" | "deviceInformation" | "isCharging" | "getBatteryCurrent" | "getMtu" | "getId" | "getName" | "setName" | "getType" | "setType" | "getCurrentTime" | "setCurrentTime" | "notConnected" | "connecting" | "connected" | "disconnecting" | "connectionStatus" | "isConnected" | "smp" | "batteryLevel" | "rx" | "tx" | "firmwareImages" | "firmwareUploadProgress" | "firmwareStatus" | "firmwareUploadComplete" | "connectionMessage">(type: T, listener: (event: {
+        type: T;
+        target: Device;
+        message: DeviceEventMessages[T];
+    }) => void) => void;
+    get waitForEvent(): <T extends "maxFileLength" | "getFileType" | "setFileType" | "getFileLength" | "setFileLength" | "getFileChecksum" | "setFileChecksum" | "setFileTransferCommand" | "fileTransferStatus" | "getFileBlock" | "setFileBlock" | "fileBytesTransferred" | "fileTransferProgress" | "fileTransferComplete" | "fileReceived" | "pressure" | "acceleration" | "gravity" | "linearAcceleration" | "gyroscope" | "magnetometer" | "gameRotation" | "rotation" | "orientation" | "activity" | "stepCounter" | "stepDetector" | "deviceOrientation" | "barometer" | "getPressurePositions" | "getSensorScalars" | "sensorData" | "getSensorConfiguration" | "setSensorConfiguration" | "getTfliteName" | "setTfliteName" | "getTfliteTask" | "setTfliteTask" | "getTfliteSampleRate" | "setTfliteSampleRate" | "getTfliteSensorTypes" | "setTfliteSensorTypes" | "tfliteIsReady" | "getTfliteCaptureDelay" | "setTfliteCaptureDelay" | "getTfliteThreshold" | "setTfliteThreshold" | "getTfliteInferencingEnabled" | "setTfliteInferencingEnabled" | "tfliteInference" | "manufacturerName" | "modelNumber" | "softwareRevision" | "hardwareRevision" | "firmwareRevision" | "pnpId" | "serialNumber" | "deviceInformation" | "isCharging" | "getBatteryCurrent" | "getMtu" | "getId" | "getName" | "setName" | "getType" | "setType" | "getCurrentTime" | "setCurrentTime" | "notConnected" | "connecting" | "connected" | "disconnecting" | "connectionStatus" | "isConnected" | "smp" | "batteryLevel" | "rx" | "tx" | "firmwareImages" | "firmwareUploadProgress" | "firmwareStatus" | "firmwareUploadComplete" | "connectionMessage">(type: T) => Promise<{
+        type: T;
+        target: Device;
+        message: DeviceEventMessages[T];
+    }>;
+    get connectionManager(): BaseConnectionManager | undefined;
+    set connectionManager(newConnectionManager: BaseConnectionManager | undefined);
+    private sendTxMessages;
+    connect(): Promise<void>;
+    get isConnected(): boolean;
+    get canReconnect(): boolean | undefined;
+    reconnect(): Promise<void | undefined>;
+    static Connect(): Promise<Device>;
+    static get ReconnectOnDisconnection(): boolean;
+    static set ReconnectOnDisconnection(newReconnectOnDisconnection: boolean);
+    get reconnectOnDisconnection(): boolean;
+    set reconnectOnDisconnection(newReconnectOnDisconnection: boolean);
+    get connectionType(): "webBluetooth" | "noble" | "client" | undefined;
+    disconnect(): Promise<void>;
+    toggleConnection(): void;
+    get connectionStatus(): ConnectionStatus;
+    get isConnectionBusy(): boolean;
+    latestConnectionMessage: Map<ConnectionMessageType, DataView>;
+    get deviceInformation(): import("./DeviceInformationManager.ts").DeviceInformation;
+    get batteryLevel(): number;
+    /** @private */
+    _informationManager: InformationManager;
+    get id(): string;
+    get isCharging(): boolean;
+    get batteryCurrent(): number;
+    get getBatteryCurrent(): () => Promise<void>;
+    get name(): string;
+    get setName(): (newName: string) => Promise<void>;
+    get type(): "leftInsole" | "rightInsole";
+    get setType(): (newType: DeviceType) => Promise<void>;
+    get isInsole(): boolean;
+    get insoleSide(): "left" | "right";
+    get mtu(): number;
+    get sensorTypes(): SensorType[];
+    get continuousSensorTypes(): ("pressure" | "acceleration" | "gravity" | "linearAcceleration" | "gyroscope" | "magnetometer" | "gameRotation" | "rotation" | "barometer")[];
+    get sensorConfiguration(): SensorConfiguration;
+    setSensorConfiguration(newSensorConfiguration: SensorConfiguration, clearRest?: boolean): Promise<void>;
+    clearSensorConfiguration(): Promise<void>;
+    static get ClearSensorConfigurationOnLeave(): boolean;
+    static set ClearSensorConfigurationOnLeave(newClearSensorConfigurationOnLeave: boolean);
+    get clearSensorConfigurationOnLeave(): boolean;
+    set clearSensorConfigurationOnLeave(newClearSensorConfigurationOnLeave: boolean);
+    get numberOfPressureSensors(): number;
+    resetPressureRange(): void;
+    triggerVibration(vibrationConfigurations: VibrationConfiguration[], sendImmediately?: boolean): Promise<void>;
+    get maxFileLength(): number;
+    sendFile(fileType: FileType, file: FileLike): Promise<void>;
+    receiveFile(fileType: FileType): Promise<void>;
+    get fileTransferStatus(): "idle" | "sending" | "receiving";
+    cancelFileTransfer(): void;
+    get tfliteName(): string;
+    get setTfliteName(): (newName: string, sendImmediately?: boolean) => Promise<void>;
+    get tfliteTask(): "classification" | "regression";
+    get setTfliteTask(): (newTask: import("./TfliteManager.ts").TfliteTask, sendImmediately?: boolean) => Promise<void>;
+    get tfliteSampleRate(): number;
+    get setTfliteSampleRate(): (newSampleRate: number, sendImmediately?: boolean) => Promise<void>;
+    get tfliteSensorTypes(): ("pressure" | "acceleration" | "gravity" | "linearAcceleration" | "gyroscope" | "magnetometer" | "gameRotation" | "rotation" | "orientation" | "activity" | "stepCounter" | "stepDetector" | "deviceOrientation" | "barometer")[];
+    get allowedTfliteSensorTypes(): ("pressure" | "acceleration" | "gravity" | "linearAcceleration" | "gyroscope" | "magnetometer" | "gameRotation" | "rotation" | "orientation" | "activity" | "stepCounter" | "stepDetector" | "deviceOrientation" | "barometer")[];
+    get setTfliteSensorTypes(): (newSensorTypes: SensorType[], sendImmediately?: boolean) => Promise<void>;
+    get tfliteIsReady(): boolean;
+    get tfliteInferencingEnabled(): boolean;
+    get setTfliteInferencingEnabled(): (newInferencingEnabled: boolean, sendImmediately?: boolean) => Promise<void>;
+    enableTfliteInferencing(): Promise<void>;
+    disableTfliteInferencing(): Promise<void>;
+    get toggleTfliteInferencing(): () => Promise<void>;
+    get tfliteCaptureDelay(): number;
+    get setTfliteCaptureDelay(): (newCaptureDelay: number, sendImmediately: boolean) => Promise<void>;
+    get tfliteThreshold(): number;
+    get setTfliteThreshold(): (newThreshold: number, sendImmediately: boolean) => Promise<void>;
+    private sendSmpMessage;
+    get uploadFirmware(): (file: FileLike) => Promise<void>;
+    reset(): Promise<void>;
+    get firmwareStatus(): "idle" | "uploading" | "uploaded" | "pending" | "testing" | "erasing";
+    get getFirmwareImages(): () => Promise<void>;
+    get firmwareImages(): import("./FirmwareManager.ts").FirmwareImage[];
+    get eraseFirmwareImage(): () => Promise<void>;
+    get confirmFirmwareImage(): (imageIndex?: number) => Promise<void>;
+    get testFirmwareImage(): (imageIndex?: number) => Promise<void>;
+    get isServerSide(): boolean;
+    set isServerSide(newIsServerSide: boolean);
+}
+export default Device;

package/build/dts/DeviceInformationManager.d.ts

@@ -0,0 +1,56 @@
+import Device from "./Device.ts";
+import EventDispatcher from "./utils/EventDispatcher.ts";
+export interface PnpId {
+    source: "Bluetooth" | "USB";
+    vendorId: number;
+    productId: number;
+    productVersion: number;
+}
+export interface DeviceInformation {
+    manufacturerName: string;
+    modelNumber: string;
+    softwareRevision: string;
+    hardwareRevision: string;
+    firmwareRevision: string;
+    pnpId: PnpId;
+    serialNumber: string;
+}
+export declare const DeviceInformationMessageTypes: readonly ["manufacturerName", "modelNumber", "softwareRevision", "hardwareRevision", "firmwareRevision", "pnpId", "serialNumber"];
+export type DeviceInformationMessageType = (typeof DeviceInformationMessageTypes)[number];
+export declare const DeviceInformationEventTypes: readonly ["manufacturerName", "modelNumber", "softwareRevision", "hardwareRevision", "firmwareRevision", "pnpId", "serialNumber", "deviceInformation"];
+export type DeviceInformationEventType = (typeof DeviceInformationEventTypes)[number];
+export interface DeviceInformationEventMessages {
+    manufacturerName: {
+        manufacturerName: string;
+    };
+    modelNumber: {
+        modelNumber: string;
+    };
+    softwareRevision: {
+        softwareRevision: string;
+    };
+    hardwareRevision: {
+        hardwareRevision: string;
+    };
+    firmwareRevision: {
+        firmwareRevision: string;
+    };
+    pnpId: {
+        pnpId: PnpId;
+    };
+    serialNumber: {
+        serialNumber: string;
+    };
+    deviceInformation: {
+        deviceInformation: DeviceInformation;
+    };
+}
+export type DeviceInformationEventDispatcher = EventDispatcher<Device, DeviceInformationEventType, DeviceInformationEventMessages>;
+declare class DeviceInformationManager {
+    #private;
+    eventDispatcher: DeviceInformationEventDispatcher;
+    get information(): DeviceInformation;
+    clear(): void;
+    parseMessage(messageType: DeviceInformationMessageType, dataView: DataView): void;
+}
+export default DeviceInformationManager;

package/build/dts/DeviceManager.d.ts

@@ -0,0 +1,67 @@
+import { ConnectionStatus } from "./connection/BaseConnectionManager.ts";
+import Device from "./Device.ts";
+import { DeviceType } from "./InformationManager.ts";
+import EventDispatcher, { BoundEventListeners, Event, EventListenerMap, EventMap } from "./utils/EventDispatcher.ts";
+export interface LocalStorageDeviceInformation {
+    type: DeviceType;
+    bluetoothId: string;
+}
+export interface LocalStorageConfiguration {
+    devices: LocalStorageDeviceInformation[];
+}
+export declare const DeviceManagerEventTypes: readonly ["deviceConnected", "deviceDisconnected", "deviceIsConnected", "availableDevices", "connectedDevices"];
+export type DeviceManagerEventType = (typeof DeviceManagerEventTypes)[number];
+interface DeviceManagerEventMessage {
+    device: Device;
+}
+export interface DeviceManagerEventMessages {
+    deviceConnected: DeviceManagerEventMessage;
+    deviceDisconnected: DeviceManagerEventMessage;
+    deviceIsConnected: DeviceManagerEventMessage;
+    availableDevices: {
+        availableDevices: Device[];
+    };
+    connectedDevices: {
+        connectedDevices: Device[];
+    };
+}
+export type DeviceManagerEventDispatcher = EventDispatcher<DeviceManager, DeviceManagerEventType, DeviceManagerEventMessages>;
+export type DeviceManagerEventMap = EventMap<typeof Device, DeviceManagerEventType, DeviceManagerEventMessages>;
+export type DeviceManagerEventListenerMap = EventListenerMap<typeof Device, DeviceManagerEventType, DeviceManagerEventMessages>;
+export type DeviceManagerEvent = Event<typeof Device, DeviceManagerEventType, DeviceManagerEventMessages>;
+export type BoundDeviceManagerEventListeners = BoundEventListeners<typeof Device, DeviceManagerEventType, DeviceManagerEventMessages>;
+declare class DeviceManager {
+    #private;
+    static readonly shared: DeviceManager;
+    constructor();
+    /** @private */
+    onDevice(device: Device): void;
+    /** @private */
+    OnDeviceConnectionStatusUpdated(device: Device, connectionStatus: ConnectionStatus): void;
+    get ConnectedDevices(): Device[];
+    get UseLocalStorage(): boolean;
+    set UseLocalStorage(newUseLocalStorage: boolean);
+    get CanUseLocalStorage(): false | Storage;
+    get AvailableDevices(): Device[];
+    get CanGetDevices(): false | (() => Promise<BluetoothDevice[]>);
+    /**
+     * retrieves devices already connected via web bluetooth in other tabs/windows
+     *
+     * _only available on web-bluetooth enabled browsers_
+     */
+    GetDevices(): Promise<Device[] | undefined>;
+    get AddEventListener(): <T extends "deviceConnected" | "deviceDisconnected" | "deviceIsConnected" | "availableDevices" | "connectedDevices">(type: T, listener: (event: {
+        type: T;
+        target: DeviceManager;
+        message: DeviceManagerEventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }) => void;
+    get RemoveEventListener(): <T extends "deviceConnected" | "deviceDisconnected" | "deviceIsConnected" | "availableDevices" | "connectedDevices">(type: T, listener: (event: {
+        type: T;
+        target: DeviceManager;
+        message: DeviceManagerEventMessages[T];
+    }) => void) => void;
+}
+declare const _default: DeviceManager;
+export default _default;

package/build/dts/FileTransferManager.d.ts

@@ -0,0 +1,84 @@
+import { FileLike } from "./utils/ArrayBufferUtils.ts";
+import Device, { SendMessageCallback } from "./Device.ts";
+import EventDispatcher from "./utils/EventDispatcher.ts";
+export declare const FileTransferMessageTypes: readonly ["maxFileLength", "getFileType", "setFileType", "getFileLength", "setFileLength", "getFileChecksum", "setFileChecksum", "setFileTransferCommand", "fileTransferStatus", "getFileBlock", "setFileBlock", "fileBytesTransferred"];
+export type FileTransferMessageType = (typeof FileTransferMessageTypes)[number];
+export declare const FileTypes: readonly ["tflite"];
+export type FileType = (typeof FileTypes)[number];
+export declare const FileTransferStatuses: readonly ["idle", "sending", "receiving"];
+export type FileTransferStatus = (typeof FileTransferStatuses)[number];
+export declare const FileTransferCommands: readonly ["startSend", "startReceive", "cancel"];
+export type FileTransferCommand = (typeof FileTransferCommands)[number];
+export declare const FileTransferDirections: readonly ["sending", "receiving"];
+export type FileTransferDirection = (typeof FileTransferDirections)[number];
+export declare const FileTransferEventTypes: readonly ["maxFileLength", "getFileType", "setFileType", "getFileLength", "setFileLength", "getFileChecksum", "setFileChecksum", "setFileTransferCommand", "fileTransferStatus", "getFileBlock", "setFileBlock", "fileBytesTransferred", "fileTransferProgress", "fileTransferComplete", "fileReceived"];
+export type FileTransferEventType = (typeof FileTransferEventTypes)[number];
+export interface FileTransferEventMessages {
+    maxFileLength: {
+        maxFileLength: number;
+    };
+    getFileType: {
+        fileType: FileType;
+    };
+    getFileLength: {
+        fileLength: number;
+    };
+    getFileChecksum: {
+        fileChecksum: number;
+    };
+    fileTransferStatus: {
+        fileTransferStatus: FileTransferStatus;
+    };
+    getFileBlock: {
+        fileTransferBlock: DataView;
+    };
+    fileTransferProgress: {
+        progress: number;
+    };
+    fileTransferComplete: {
+        direction: FileTransferDirection;
+    };
+    fileReceived: {
+        file: File | Blob;
+    };
+}
+export type FileTransferEventDispatcher = EventDispatcher<Device, FileTransferEventType, FileTransferEventMessages>;
+export type SendFileTransferMessageCallback = SendMessageCallback<FileTransferMessageType>;
+declare class FileTransferManager {
+    #private;
+    constructor();
+    sendMessage: SendFileTransferMessageCallback;
+    eventDispatcher: FileTransferEventDispatcher;
+    get addEventListener(): <T extends "maxFileLength" | "getFileType" | "setFileType" | "getFileLength" | "setFileLength" | "getFileChecksum" | "setFileChecksum" | "setFileTransferCommand" | "fileTransferStatus" | "getFileBlock" | "setFileBlock" | "fileBytesTransferred" | "fileTransferProgress" | "fileTransferComplete" | "fileReceived">(type: T, listener: (event: {
+        type: T;
+        target: Device;
+        message: FileTransferEventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }) => void;
+    get removeEventListener(): <T extends "maxFileLength" | "getFileType" | "setFileType" | "getFileLength" | "setFileLength" | "getFileChecksum" | "setFileChecksum" | "setFileTransferCommand" | "fileTransferStatus" | "getFileBlock" | "setFileBlock" | "fileBytesTransferred" | "fileTransferProgress" | "fileTransferComplete" | "fileReceived">(type: T, listener: (event: {
+        type: T;
+        target: Device;
+        message: FileTransferEventMessages[T];
+    }) => void) => void;
+    get waitForEvent(): <T extends "maxFileLength" | "getFileType" | "setFileType" | "getFileLength" | "setFileLength" | "getFileChecksum" | "setFileChecksum" | "setFileTransferCommand" | "fileTransferStatus" | "getFileBlock" | "setFileBlock" | "fileBytesTransferred" | "fileTransferProgress" | "fileTransferComplete" | "fileReceived">(type: T) => Promise<{
+        type: T;
+        target: Device;
+        message: FileTransferEventMessages[T];
+    }>;
+    static get MaxLength(): number;
+    /** kB */
+    get maxLength(): number;
+    get type(): "tflite" | undefined;
+    get length(): number;
+    get checksum(): number;
+    get status(): "idle" | "sending" | "receiving";
+    parseMessage(messageType: FileTransferMessageType, dataView: DataView): void;
+    send(type: FileType, file: FileLike): Promise<void>;
+    mtu: number;
+    receive(type: FileType): Promise<void>;
+    cancel(): Promise<void>;
+    get isServerSide(): boolean;
+    set isServerSide(newIsServerSide: boolean);
+}
+export default FileTransferManager;

package/build/dts/FirmwareManager.d.ts

@@ -0,0 +1,71 @@
+import Device, { SendSmpMessageCallback } from "./Device.ts";
+import EventDispatcher from "./utils/EventDispatcher.ts";
+import { FileLike } from "./utils/ArrayBufferUtils.ts";
+export declare const FirmwareMessageTypes: readonly ["smp"];
+export type FirmwareMessageType = (typeof FirmwareMessageTypes)[number];
+export declare const FirmwareEventTypes: readonly ["smp", "firmwareImages", "firmwareUploadProgress", "firmwareStatus", "firmwareUploadComplete"];
+export type FirmwareEventType = (typeof FirmwareEventTypes)[number];
+export declare const FirmwareStatuses: readonly ["idle", "uploading", "uploaded", "pending", "testing", "erasing"];
+export type FirmwareStatus = (typeof FirmwareStatuses)[number];
+export interface FirmwareImage {
+    slot: number;
+    active: boolean;
+    confirmed: boolean;
+    pending: boolean;
+    permanent: boolean;
+    bootable: boolean;
+    version: string;
+    hash?: Uint8Array;
+    empty?: boolean;
+}
+export interface FirmwareEventMessages {
+    smp: {
+        dataView: DataView;
+    };
+    firmwareImages: {
+        firmwareImages: FirmwareImage[];
+    };
+    firmwareUploadProgress: {
+        progress: number;
+    };
+    firmwareStatus: {
+        firmwareStatus: FirmwareStatus;
+    };
+}
+export type FirmwareEventDispatcher = EventDispatcher<Device, FirmwareEventType, FirmwareEventMessages>;
+declare class FirmwareManager {
+    #private;
+    sendMessage: SendSmpMessageCallback;
+    constructor();
+    eventDispatcher: FirmwareEventDispatcher;
+    get addEventListenter(): <T extends "smp" | "firmwareImages" | "firmwareUploadProgress" | "firmwareStatus" | "firmwareUploadComplete">(type: T, listener: (event: {
+        type: T;
+        target: Device;
+        message: FirmwareEventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }) => void;
+    get removeEventListener(): <T extends "smp" | "firmwareImages" | "firmwareUploadProgress" | "firmwareStatus" | "firmwareUploadComplete">(type: T, listener: (event: {
+        type: T;
+        target: Device;
+        message: FirmwareEventMessages[T];
+    }) => void) => void;
+    get waitForEvent(): <T extends "smp" | "firmwareImages" | "firmwareUploadProgress" | "firmwareStatus" | "firmwareUploadComplete">(type: T) => Promise<{
+        type: T;
+        target: Device;
+        message: FirmwareEventMessages[T];
+    }>;
+    parseMessage(messageType: FirmwareMessageType, dataView: DataView): void;
+    uploadFirmware(file: FileLike): Promise<void>;
+    get status(): "idle" | "uploading" | "uploaded" | "pending" | "testing" | "erasing";
+    get images(): FirmwareImage[];
+    getImages(): Promise<void>;
+    testImage(imageIndex?: number): Promise<void>;
+    eraseImage(): Promise<void>;
+    confirmImage(imageIndex?: number): Promise<void>;
+    echo(string: string): Promise<void>;
+    reset(): Promise<void>;
+    get mtu(): number;
+    set mtu(newMtu: number);
+}
+export default FirmwareManager;

package/build/dts/InformationManager.d.ts

@@ -0,0 +1,66 @@
+import Device, { SendMessageCallback } from "./Device.ts";
+import EventDispatcher from "./utils/EventDispatcher.ts";
+export declare const DeviceTypes: readonly ["leftInsole", "rightInsole"];
+export type DeviceType = (typeof DeviceTypes)[number];
+export declare const InsoleSides: readonly ["left", "right"];
+export type InsoleSide = (typeof InsoleSides)[number];
+export declare const MinNameLength = 2;
+export declare const MaxNameLength = 30;
+export declare const InformationMessageTypes: readonly ["isCharging", "getBatteryCurrent", "getMtu", "getId", "getName", "setName", "getType", "setType", "getCurrentTime", "setCurrentTime"];
+export type InformationMessageType = (typeof InformationMessageTypes)[number];
+export declare const InformationEventTypes: readonly ["isCharging", "getBatteryCurrent", "getMtu", "getId", "getName", "setName", "getType", "setType", "getCurrentTime", "setCurrentTime"];
+export type InformationEventType = (typeof InformationEventTypes)[number];
+export interface InformationEventMessages {
+    isCharging: {
+        isCharging: boolean;
+    };
+    getBatteryCurrent: {
+        batteryCurrent: number;
+    };
+    getMtu: {
+        mtu: number;
+    };
+    getId: {
+        id: string;
+    };
+    getName: {
+        name: string;
+    };
+    getType: {
+        type: DeviceType;
+    };
+    getCurrentTime: {
+        currentTime: number;
+    };
+}
+export type InformationEventDispatcher = EventDispatcher<Device, InformationEventType, InformationEventMessages>;
+export type SendInformationMessageCallback = SendMessageCallback<InformationMessageType>;
+declare class InformationManager {
+    #private;
+    constructor();
+    sendMessage: SendInformationMessageCallback;
+    eventDispatcher: InformationEventDispatcher;
+    get waitForEvent(): <T extends "isCharging" | "getBatteryCurrent" | "getMtu" | "getId" | "getName" | "setName" | "getType" | "setType" | "getCurrentTime" | "setCurrentTime">(type: T) => Promise<{
+        type: T;
+        target: Device;
+        message: InformationEventMessages[T];
+    }>;
+    get isCharging(): boolean;
+    get batteryCurrent(): number;
+    getBatteryCurrent(): Promise<void>;
+    get id(): string;
+    get name(): string;
+    updateName(updatedName: string): void;
+    setName(newName: string): Promise<void>;
+    get type(): "leftInsole" | "rightInsole";
+    get typeEnum(): number;
+    updateType(updatedType: DeviceType): void;
+    setType(newType: DeviceType): Promise<void>;
+    get isInsole(): boolean;
+    get insoleSide(): InsoleSide;
+    get mtu(): number;
+    get isCurrentTimeSet(): boolean;
+    parseMessage(messageType: InformationMessageType, dataView: DataView): void;
+    clear(): void;
+}
+export default InformationManager;

package/build/dts/TfliteManager.d.ts

@@ -0,0 +1,92 @@
+import EventDispatcher from "./utils/EventDispatcher.ts";
+import { SensorType } from "./sensor/SensorDataManager.ts";
+import Device, { SendMessageCallback } from "./Device.ts";
+export declare const TfliteMessageTypes: readonly ["getTfliteName", "setTfliteName", "getTfliteTask", "setTfliteTask", "getTfliteSampleRate", "setTfliteSampleRate", "getTfliteSensorTypes", "setTfliteSensorTypes", "tfliteIsReady", "getTfliteCaptureDelay", "setTfliteCaptureDelay", "getTfliteThreshold", "setTfliteThreshold", "getTfliteInferencingEnabled", "setTfliteInferencingEnabled", "tfliteInference"];
+export type TfliteMessageType = (typeof TfliteMessageTypes)[number];
+export declare const TfliteEventTypes: readonly ["getTfliteName", "setTfliteName", "getTfliteTask", "setTfliteTask", "getTfliteSampleRate", "setTfliteSampleRate", "getTfliteSensorTypes", "setTfliteSensorTypes", "tfliteIsReady", "getTfliteCaptureDelay", "setTfliteCaptureDelay", "getTfliteThreshold", "setTfliteThreshold", "getTfliteInferencingEnabled", "setTfliteInferencingEnabled", "tfliteInference"];
+export type TfliteEventType = (typeof TfliteEventTypes)[number];
+export declare const TfliteTasks: readonly ["classification", "regression"];
+export type TfliteTask = (typeof TfliteTasks)[number];
+export interface TfliteEventMessages {
+    getTfliteName: {
+        tfliteName: string;
+    };
+    getTfliteTask: {
+        tfliteTask: TfliteTask;
+    };
+    getTfliteSampleRate: {
+        tfliteSampleRate: number;
+    };
+    getTfliteSensorTypes: {
+        tfliteSensorTypes: SensorType[];
+    };
+    tfliteIsReady: {
+        tfliteIsReady: boolean;
+    };
+    getTfliteCaptureDelay: {
+        tfliteCaptureDelay: number;
+    };
+    getTfliteThreshold: {
+        tfliteThreshold: number;
+    };
+    getTfliteInferencingEnabled: {
+        tfliteInferencingEnabled: boolean;
+    };
+    tfliteInference: {
+        tfliteInference: TfliteInference;
+    };
+}
+export interface TfliteInference {
+    timestamp: number;
+    values: number[];
+    maxValue?: number;
+    maxIndex?: number;
+}
+export type TfliteEventDispatcher = EventDispatcher<Device, TfliteEventType, TfliteEventMessages>;
+export type SendTfliteMessageCallback = SendMessageCallback<TfliteMessageType>;
+export declare const TfliteSensorTypes: SensorType[];
+export type TfliteSensorType = (typeof TfliteSensorTypes)[number];
+declare class TfliteManager {
+    #private;
+    constructor();
+    sendMessage: SendTfliteMessageCallback;
+    eventDispatcher: TfliteEventDispatcher;
+    get addEventListenter(): <T extends "getTfliteName" | "setTfliteName" | "getTfliteTask" | "setTfliteTask" | "getTfliteSampleRate" | "setTfliteSampleRate" | "getTfliteSensorTypes" | "setTfliteSensorTypes" | "tfliteIsReady" | "getTfliteCaptureDelay" | "setTfliteCaptureDelay" | "getTfliteThreshold" | "setTfliteThreshold" | "getTfliteInferencingEnabled" | "setTfliteInferencingEnabled" | "tfliteInference">(type: T, listener: (event: {
+        type: T;
+        target: Device;
+        message: TfliteEventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }) => void;
+    get removeEventListener(): <T extends "getTfliteName" | "setTfliteName" | "getTfliteTask" | "setTfliteTask" | "getTfliteSampleRate" | "setTfliteSampleRate" | "getTfliteSensorTypes" | "setTfliteSensorTypes" | "tfliteIsReady" | "getTfliteCaptureDelay" | "setTfliteCaptureDelay" | "getTfliteThreshold" | "setTfliteThreshold" | "getTfliteInferencingEnabled" | "setTfliteInferencingEnabled" | "tfliteInference">(type: T, listener: (event: {
+        type: T;
+        target: Device;
+        message: TfliteEventMessages[T];
+    }) => void) => void;
+    get waitForEvent(): <T extends "getTfliteName" | "setTfliteName" | "getTfliteTask" | "setTfliteTask" | "getTfliteSampleRate" | "setTfliteSampleRate" | "getTfliteSensorTypes" | "setTfliteSensorTypes" | "tfliteIsReady" | "getTfliteCaptureDelay" | "setTfliteCaptureDelay" | "getTfliteThreshold" | "setTfliteThreshold" | "getTfliteInferencingEnabled" | "setTfliteInferencingEnabled" | "tfliteInference">(type: T) => Promise<{
+        type: T;
+        target: Device;
+        message: TfliteEventMessages[T];
+    }>;
+    get name(): string;
+    setName(newName: string, sendImmediately?: boolean): Promise<void>;
+    get task(): "classification" | "regression";
+    setTask(newTask: TfliteTask, sendImmediately?: boolean): Promise<void>;
+    get sampleRate(): number;
+    setSampleRate(newSampleRate: number, sendImmediately?: boolean): Promise<void>;
+    static AssertValidSensorType(sensorType: SensorType): void;
+    get sensorTypes(): ("pressure" | "acceleration" | "gravity" | "linearAcceleration" | "gyroscope" | "magnetometer" | "gameRotation" | "rotation" | "orientation" | "activity" | "stepCounter" | "stepDetector" | "deviceOrientation" | "barometer")[];
+    setSensorTypes(newSensorTypes: SensorType[], sendImmediately?: boolean): Promise<void>;
+    get isReady(): boolean;
+    get captureDelay(): number;
+    setCaptureDelay(newCaptureDelay: number, sendImmediately: boolean): Promise<void>;
+    get threshold(): number;
+    setThreshold(newThreshold: number, sendImmediately: boolean): Promise<void>;
+    get inferencingEnabled(): boolean;
+    setInferencingEnabled(newInferencingEnabled: boolean, sendImmediately?: boolean): Promise<void>;
+    toggleInferencingEnabled(): Promise<void>;
+    enableInferencing(): Promise<void>;
+    disableInferencing(): Promise<void>;
+    parseMessage(messageType: TfliteMessageType, dataView: DataView): void;
+}
+export default TfliteManager;