brilliantsole 0.0.1

package/build/dts/connection/BaseConnectionManager.d.ts

@@ -0,0 +1,59 @@
+export declare const ConnectionTypes: readonly ["webBluetooth", "noble", "client"];
+export type ConnectionType = (typeof ConnectionTypes)[number];
+export declare const ConnectionStatuses: readonly ["notConnected", "connecting", "connected", "disconnecting"];
+export type ConnectionStatus = (typeof ConnectionStatuses)[number];
+export declare const ConnectionEventTypes: readonly ["notConnected", "connecting", "connected", "disconnecting", "connectionStatus", "isConnected"];
+export type ConnectionEventType = (typeof ConnectionEventTypes)[number];
+export interface ConnectionStatusEventMessages {
+    notConnected: any;
+    connecting: any;
+    connected: any;
+    disconnecting: any;
+    connectionStatus: {
+        connectionStatus: ConnectionStatus;
+    };
+    isConnected: {
+        isConnected: boolean;
+    };
+}
+export interface TxMessage {
+    type: TxRxMessageType;
+    data?: ArrayBuffer;
+}
+export declare const TxRxMessageTypes: readonly ["isCharging", "getBatteryCurrent", "getMtu", "getId", "getName", "setName", "getType", "setType", "getCurrentTime", "setCurrentTime", "getSensorConfiguration", "setSensorConfiguration", "getPressurePositions", "getSensorScalars", "sensorData", "triggerVibration", "getTfliteName", "setTfliteName", "getTfliteTask", "setTfliteTask", "getTfliteSampleRate", "setTfliteSampleRate", "getTfliteSensorTypes", "setTfliteSensorTypes", "tfliteIsReady", "getTfliteCaptureDelay", "setTfliteCaptureDelay", "getTfliteThreshold", "setTfliteThreshold", "getTfliteInferencingEnabled", "setTfliteInferencingEnabled", "tfliteInference", "maxFileLength", "getFileType", "setFileType", "getFileLength", "setFileLength", "getFileChecksum", "setFileChecksum", "setFileTransferCommand", "fileTransferStatus", "getFileBlock", "setFileBlock", "fileBytesTransferred"];
+export type TxRxMessageType = (typeof TxRxMessageTypes)[number];
+export declare const SMPMessageTypes: readonly ["smp"];
+export type SMPMessageType = (typeof SMPMessageTypes)[number];
+export declare const BatteryLevelMessageTypes: readonly ["batteryLevel"];
+export type BatteryLevelMessageType = (typeof BatteryLevelMessageTypes)[number];
+export declare const MetaConnectionMessageTypes: readonly ["rx", "tx"];
+export type MetaConnectionMessageType = (typeof MetaConnectionMessageTypes)[number];
+export declare const ConnectionMessageTypes: readonly ["batteryLevel", "manufacturerName", "modelNumber", "softwareRevision", "hardwareRevision", "firmwareRevision", "pnpId", "serialNumber", "rx", "tx", "isCharging", "getBatteryCurrent", "getMtu", "getId", "getName", "setName", "getType", "setType", "getCurrentTime", "setCurrentTime", "getSensorConfiguration", "setSensorConfiguration", "getPressurePositions", "getSensorScalars", "sensorData", "triggerVibration", "getTfliteName", "setTfliteName", "getTfliteTask", "setTfliteTask", "getTfliteSampleRate", "setTfliteSampleRate", "getTfliteSensorTypes", "setTfliteSensorTypes", "tfliteIsReady", "getTfliteCaptureDelay", "setTfliteCaptureDelay", "getTfliteThreshold", "setTfliteThreshold", "getTfliteInferencingEnabled", "setTfliteInferencingEnabled", "tfliteInference", "maxFileLength", "getFileType", "setFileType", "getFileLength", "setFileLength", "getFileChecksum", "setFileChecksum", "setFileTransferCommand", "fileTransferStatus", "getFileBlock", "setFileBlock", "fileBytesTransferred", "smp"];
+export type ConnectionMessageType = (typeof ConnectionMessageTypes)[number];
+export type ConnectionStatusCallback = (status: ConnectionStatus) => void;
+export type MessageReceivedCallback = (messageType: ConnectionMessageType, dataView: DataView) => void;
+declare abstract class BaseConnectionManager {
+    #private;
+    abstract get bluetoothId(): string;
+    onStatusUpdated?: ConnectionStatusCallback;
+    onMessageReceived?: MessageReceivedCallback;
+    protected get baseConstructor(): typeof BaseConnectionManager;
+    static get isSupported(): boolean;
+    get isSupported(): boolean;
+    static type: ConnectionType;
+    get type(): ConnectionType;
+    constructor();
+    get status(): "notConnected" | "connecting" | "connected" | "disconnecting";
+    protected set status(newConnectionStatus: "notConnected" | "connecting" | "connected" | "disconnecting");
+    get isConnected(): boolean;
+    connect(): Promise<void>;
+    get canReconnect(): boolean;
+    reconnect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendSmpMessage(data: ArrayBuffer): Promise<void>;
+    sendTxMessages(messages: TxMessage[] | undefined, sendImmediately?: boolean): Promise<void>;
+    mtu?: number;
+    sendTxData(data: ArrayBuffer): Promise<void>;
+    parseRxMessage(dataView: DataView): void;
+}
+export default BaseConnectionManager;

package/build/dts/connection/ClientConnectionManager.d.ts

@@ -0,0 +1,23 @@
+import BaseConnectionManager, { ConnectionType } from "./BaseConnectionManager.ts";
+import { ClientDeviceMessage } from "../server/ServerUtils.ts";
+export type SendClientMessageCallback = (...messages: ClientDeviceMessage[]) => void;
+declare class ClientConnectionManager extends BaseConnectionManager {
+    #private;
+    static get isSupported(): boolean;
+    static get type(): ConnectionType;
+    get bluetoothId(): string;
+    set bluetoothId(newBluetoothId: string);
+    get isConnected(): boolean;
+    set isConnected(newIsConnected: boolean);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    get canReconnect(): boolean;
+    reconnect(): Promise<void>;
+    sendClientMessage: SendClientMessageCallback;
+    sendClientConnectMessage: Function;
+    sendClientDisconnectMessage: Function;
+    sendSmpMessage(data: ArrayBuffer): Promise<void>;
+    sendTxData(data: ArrayBuffer): Promise<void>;
+    onClientMessage(dataView: DataView): void;
+}
+export default ClientConnectionManager;

package/build/dts/connection/WebSocketClientConnectionManager.d.ts

@@ -0,0 +1,23 @@
+import BaseConnectionManager, { ConnectionType } from "./BaseConnectionManager.ts";
+import { ClientDeviceMessage } from "../server/ServerUtils.ts";
+export type SendWebSocketMessageCallback = (...messages: ClientDeviceMessage[]) => void;
+declare class WebSocketClientConnectionManager extends BaseConnectionManager {
+    #private;
+    static get isSupported(): boolean;
+    static get type(): ConnectionType;
+    get bluetoothId(): string;
+    set bluetoothId(newBluetoothId: string);
+    get isConnected(): boolean;
+    set isConnected(newIsConnected: boolean);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    get canReconnect(): boolean;
+    reconnect(): Promise<void>;
+    sendWebSocketMessage: SendWebSocketMessageCallback;
+    sendWebSocketConnectMessage: Function;
+    sendWebSocketDisconnectMessage: Function;
+    sendSmpMessage(data: ArrayBuffer): Promise<void>;
+    sendTxData(data: ArrayBuffer): Promise<void>;
+    onWebSocketMessage(dataView: DataView): void;
+}
+export default WebSocketClientConnectionManager;

package/build/dts/connection/bluetooth/BluetoothConnectionManager.d.ts

@@ -0,0 +1,10 @@
+import BaseConnectionManager from "../BaseConnectionManager.ts";
+import { BluetoothCharacteristicName } from "./bluetoothUUIDs.ts";
+declare abstract class BluetoothConnectionManager extends BaseConnectionManager {
+    isInRange: boolean;
+    protected onCharacteristicValueChanged(characteristicName: BluetoothCharacteristicName, dataView: DataView): void;
+    protected writeCharacteristic(characteristicName: BluetoothCharacteristicName, data: ArrayBuffer): Promise<void>;
+    sendSmpMessage(data: ArrayBuffer): Promise<void>;
+    sendTxData(data: ArrayBuffer): Promise<void>;
+}
+export default BluetoothConnectionManager;

package/build/dts/connection/bluetooth/NobleConnectionManager.d.ts

@@ -0,0 +1,42 @@
+import BluetoothConnectionManager from "./BluetoothConnectionManager.ts";
+/** NODE_START */
+import type * as noble from "@abandonware/noble";
+/** NODE_END */
+import { BluetoothCharacteristicName, BluetoothServiceName } from "./bluetoothUUIDs.ts";
+import { ConnectionType } from "../BaseConnectionManager.ts";
+import NobleScanner from "../../scanner/NobleScanner.ts";
+interface HasConnectionManager {
+    connectionManager: NobleConnectionManager | undefined;
+}
+export interface NoblePeripheral extends noble.Peripheral, HasConnectionManager {
+    scanner: NobleScanner;
+}
+interface NobleService extends noble.Service, HasConnectionManager {
+    name: BluetoothServiceName;
+}
+interface NobleCharacteristic extends noble.Characteristic, HasConnectionManager {
+    name: BluetoothCharacteristicName;
+}
+declare class NobleConnectionManager extends BluetoothConnectionManager {
+    #private;
+    get bluetoothId(): string;
+    static get isSupported(): boolean;
+    static get type(): ConnectionType;
+    get isConnected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    writeCharacteristic(characteristicName: BluetoothCharacteristicName, data: ArrayBuffer): Promise<void>;
+    get canReconnect(): boolean;
+    reconnect(): Promise<void>;
+    get noblePeripheral(): NoblePeripheral | undefined;
+    set noblePeripheral(newNoblePeripheral: NoblePeripheral);
+    onNoblePeripheralConnect(noblePeripheral: NoblePeripheral): Promise<void>;
+    onNoblePeripheralDisconnect(noblePeripheral: NoblePeripheral): Promise<void>;
+    onNoblePeripheralRssiUpdate(noblePeripheral: NoblePeripheral, rssi: number): Promise<void>;
+    onNoblePeripheralServicesDiscover(noblePeripheral: NoblePeripheral, services: NobleService[]): Promise<void>;
+    onNobleServiceCharacteristicsDiscover(service: NobleService, characteristics: NobleCharacteristic[]): Promise<void>;
+    onNobleCharacteristicData(characteristic: NobleCharacteristic, data: Buffer, isNotification: boolean): void;
+    onNobleCharacteristicWrite(characteristic: NobleCharacteristic): void;
+    onNobleCharacteristicNotify(characteristic: NobleCharacteristic, isSubscribed: boolean): void;
+}
+export default NobleConnectionManager;

package/build/dts/connection/bluetooth/WebBluetoothConnectionManager.d.ts

@@ -0,0 +1,20 @@
+import BluetoothConnectionManager from "./BluetoothConnectionManager.ts";
+import { BluetoothCharacteristicName } from "./bluetoothUUIDs.ts";
+import { ConnectionType } from "../BaseConnectionManager.ts";
+/** BROWSER_END */
+declare class WebBluetoothConnectionManager extends BluetoothConnectionManager {
+    #private;
+    get bluetoothId(): string;
+    static get isSupported(): boolean;
+    static get type(): ConnectionType;
+    get device(): BluetoothDevice | undefined;
+    set device(newDevice: BluetoothDevice | undefined);
+    get server(): BluetoothRemoteGATTServer | undefined;
+    get isConnected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    writeCharacteristic(characteristicName: BluetoothCharacteristicName, data: ArrayBuffer): Promise<void>;
+    get canReconnect(): boolean;
+    reconnect(): Promise<void>;
+}
+export default WebBluetoothConnectionManager;

package/build/dts/connection/bluetooth/bluetoothUUIDs.d.ts

@@ -0,0 +1,14 @@
+export type BluetoothServiceName = "deviceInformation" | "battery" | "main" | "smp";
+import { DeviceInformationMessageType } from "../../DeviceInformationManager.ts";
+export type BluetoothCharacteristicName = DeviceInformationMessageType | "batteryLevel" | "rx" | "tx" | "smp";
+export declare const serviceUUIDs: BluetoothServiceUUID[];
+export declare const optionalServiceUUIDs: BluetoothServiceUUID[];
+export declare const allServiceUUIDs: BluetoothServiceUUID[];
+export declare function getServiceNameFromUUID(serviceUUID: BluetoothServiceUUID): BluetoothServiceName | undefined;
+export declare const characteristicUUIDs: BluetoothCharacteristicUUID[];
+export declare const allCharacteristicUUIDs: BluetoothCharacteristicUUID[];
+export declare const characteristicNames: BluetoothCharacteristicName[];
+export declare const allCharacteristicNames: BluetoothCharacteristicName[];
+export declare function getCharacteristicNameFromUUID(characteristicUUID: BluetoothCharacteristicUUID): BluetoothCharacteristicName | undefined;
+export declare function getCharacteristicProperties(characteristicName: BluetoothCharacteristicName): BluetoothCharacteristicProperties;
+export declare const serviceDataUUID = "0000";

package/build/dts/connection/webSocket/ClientConnectionManager.d.ts

@@ -0,0 +1,23 @@
+import BaseConnectionManager, { ConnectionType } from "../BaseConnectionManager.ts";
+import { ClientDeviceMessage } from "../../server/ServerUtils.ts";
+export type SendClientMessageCallback = (...messages: ClientDeviceMessage[]) => void;
+declare class ClientConnectionManager extends BaseConnectionManager {
+    #private;
+    static get isSupported(): boolean;
+    static get type(): ConnectionType;
+    get bluetoothId(): string;
+    set bluetoothId(newBluetoothId: string);
+    get isConnected(): boolean;
+    set isConnected(newIsConnected: boolean);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    get canReconnect(): boolean;
+    reconnect(): Promise<void>;
+    sendClientMessage: SendClientMessageCallback;
+    sendClientConnectMessage: Function;
+    sendClientDisconnectMessage: Function;
+    sendSmpMessage(data: ArrayBuffer): Promise<void>;
+    sendTxData(data: ArrayBuffer): Promise<void>;
+    onClientMessage(dataView: DataView): void;
+}
+export default ClientConnectionManager;

package/build/dts/connection/webSocket/WebSocketClientConnectionManager.d.ts

@@ -0,0 +1,23 @@
+import BaseConnectionManager, { ConnectionType } from "../BaseConnectionManager.ts";
+import { ClientDeviceMessage } from "../../server/ServerUtils.ts";
+export type SendWebSocketMessageCallback = (...messages: ClientDeviceMessage[]) => void;
+declare class WebSocketClientConnectionManager extends BaseConnectionManager {
+    #private;
+    static get isSupported(): boolean;
+    static get type(): ConnectionType;
+    get bluetoothId(): string;
+    set bluetoothId(newBluetoothId: string);
+    get isConnected(): boolean;
+    set isConnected(newIsConnected: boolean);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    get canReconnect(): boolean;
+    reconnect(): Promise<void>;
+    sendWebSocketMessage: SendWebSocketMessageCallback;
+    sendWebSocketConnectMessage: Function;
+    sendWebSocketDisconnectMessage: Function;
+    sendSmpMessage(data: ArrayBuffer): Promise<void>;
+    sendTxData(data: ArrayBuffer): Promise<void>;
+    onWebSocketMessage(dataView: DataView): void;
+}
+export default WebSocketClientConnectionManager;

package/build/dts/devicePair/DevicePair.d.ts

@@ -0,0 +1,60 @@
+import EventDispatcher, { BoundEventListeners, Event, EventListenerMap, EventMap } from "../utils/EventDispatcher.ts";
+import Device, { DeviceEventType, DeviceEventMessages } from "../Device.ts";
+import { InsoleSide } from "../InformationManager.ts";
+import { VibrationConfiguration } from "../vibration/VibrationManager.ts";
+import { SensorConfiguration } from "../sensor/SensorConfigurationManager.ts";
+import { DevicePairSensorDataEventMessages } from "./DevicePairSensorDataManager.ts";
+import { AddPrefixToInterfaceKeys, ExtendInterfaceValues } from "../utils/TypeScriptUtils.ts";
+interface BaseDevicePairDeviceEventMessage {
+    device: Device;
+    side: InsoleSide;
+}
+type DevicePairDeviceEventMessages = ExtendInterfaceValues<AddPrefixToInterfaceKeys<DeviceEventMessages, "device">, BaseDevicePairDeviceEventMessage>;
+export declare const DevicePairConnectionEventTypes: readonly ["isConnected"];
+export type DevicePairConnectionEventType = (typeof DevicePairConnectionEventTypes)[number];
+export interface DevicePairConnectionEventMessages {
+    isConnected: {
+        isConnected: boolean;
+    };
+}
+export declare const DevicePairEventTypes: readonly ["isConnected", "pressure", "sensorData", ...("deviceOrientation" | "deviceConnected" | "deviceIsConnected" | "deviceMaxFileLength" | "deviceGetFileType" | "deviceGetFileLength" | "deviceGetFileChecksum" | "deviceFileTransferStatus" | "deviceGetFileBlock" | "deviceFileTransferProgress" | "deviceFileTransferComplete" | "deviceFileReceived" | "devicePressure" | "deviceAcceleration" | "deviceGravity" | "deviceLinearAcceleration" | "deviceGyroscope" | "deviceMagnetometer" | "deviceGameRotation" | "deviceRotation" | "deviceActivity" | "deviceStepCounter" | "deviceStepDetector" | "deviceDeviceOrientation" | "deviceBarometer" | "deviceSensorData" | "deviceGetSensorConfiguration" | "deviceGetTfliteName" | "deviceGetTfliteTask" | "deviceGetTfliteSampleRate" | "deviceGetTfliteSensorTypes" | "deviceTfliteIsReady" | "deviceGetTfliteCaptureDelay" | "deviceGetTfliteThreshold" | "deviceGetTfliteInferencingEnabled" | "deviceTfliteInference" | "deviceManufacturerName" | "deviceModelNumber" | "deviceSoftwareRevision" | "deviceHardwareRevision" | "deviceFirmwareRevision" | "devicePnpId" | "deviceSerialNumber" | "deviceDeviceInformation" | "deviceIsCharging" | "deviceGetBatteryCurrent" | "deviceGetMtu" | "deviceGetId" | "deviceGetName" | "deviceGetType" | "deviceGetCurrentTime" | "deviceNotConnected" | "deviceConnecting" | "deviceDisconnecting" | "deviceConnectionStatus" | "deviceSmp" | "deviceBatteryLevel" | "deviceFirmwareImages" | "deviceFirmwareUploadProgress" | "deviceFirmwareStatus" | "deviceConnectionMessage")[]];
+export type DevicePairEventType = (typeof DevicePairEventTypes)[number];
+export type DevicePairEventMessages = DevicePairConnectionEventMessages & DevicePairSensorDataEventMessages & DevicePairDeviceEventMessages;
+export type DevicePairEventDispatcher = EventDispatcher<DevicePair, DevicePairEventType, DevicePairEventMessages>;
+export type DevicePairEventMap = EventMap<DevicePair, DeviceEventType, DevicePairEventMessages>;
+export type DevicePairEventListenerMap = EventListenerMap<DevicePair, DeviceEventType, DevicePairEventMessages>;
+export type DevicePairEvent = Event<DevicePair, DeviceEventType, DevicePairEventMessages>;
+export type BoundDevicePairEventListeners = BoundEventListeners<DevicePair, DeviceEventType, DevicePairEventMessages>;
+declare class DevicePair {
+    #private;
+    constructor();
+    get sides(): readonly ["left", "right"];
+    get addEventListener(): <T extends "pressure" | "deviceOrientation" | "sensorData" | "isConnected" | "deviceConnected" | "deviceIsConnected" | "deviceMaxFileLength" | "deviceGetFileType" | "deviceGetFileLength" | "deviceGetFileChecksum" | "deviceFileTransferStatus" | "deviceGetFileBlock" | "deviceFileTransferProgress" | "deviceFileTransferComplete" | "deviceFileReceived" | "devicePressure" | "deviceAcceleration" | "deviceGravity" | "deviceLinearAcceleration" | "deviceGyroscope" | "deviceMagnetometer" | "deviceGameRotation" | "deviceRotation" | "deviceActivity" | "deviceStepCounter" | "deviceStepDetector" | "deviceDeviceOrientation" | "deviceBarometer" | "deviceSensorData" | "deviceGetSensorConfiguration" | "deviceGetTfliteName" | "deviceGetTfliteTask" | "deviceGetTfliteSampleRate" | "deviceGetTfliteSensorTypes" | "deviceTfliteIsReady" | "deviceGetTfliteCaptureDelay" | "deviceGetTfliteThreshold" | "deviceGetTfliteInferencingEnabled" | "deviceTfliteInference" | "deviceManufacturerName" | "deviceModelNumber" | "deviceSoftwareRevision" | "deviceHardwareRevision" | "deviceFirmwareRevision" | "devicePnpId" | "deviceSerialNumber" | "deviceDeviceInformation" | "deviceIsCharging" | "deviceGetBatteryCurrent" | "deviceGetMtu" | "deviceGetId" | "deviceGetName" | "deviceGetType" | "deviceGetCurrentTime" | "deviceNotConnected" | "deviceConnecting" | "deviceDisconnecting" | "deviceConnectionStatus" | "deviceSmp" | "deviceBatteryLevel" | "deviceFirmwareImages" | "deviceFirmwareUploadProgress" | "deviceFirmwareStatus" | "deviceConnectionMessage">(type: T, listener: (event: {
+        type: T;
+        target: DevicePair;
+        message: DevicePairEventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }) => void;
+    get removeEventListener(): <T extends "pressure" | "deviceOrientation" | "sensorData" | "isConnected" | "deviceConnected" | "deviceIsConnected" | "deviceMaxFileLength" | "deviceGetFileType" | "deviceGetFileLength" | "deviceGetFileChecksum" | "deviceFileTransferStatus" | "deviceGetFileBlock" | "deviceFileTransferProgress" | "deviceFileTransferComplete" | "deviceFileReceived" | "devicePressure" | "deviceAcceleration" | "deviceGravity" | "deviceLinearAcceleration" | "deviceGyroscope" | "deviceMagnetometer" | "deviceGameRotation" | "deviceRotation" | "deviceActivity" | "deviceStepCounter" | "deviceStepDetector" | "deviceDeviceOrientation" | "deviceBarometer" | "deviceSensorData" | "deviceGetSensorConfiguration" | "deviceGetTfliteName" | "deviceGetTfliteTask" | "deviceGetTfliteSampleRate" | "deviceGetTfliteSensorTypes" | "deviceTfliteIsReady" | "deviceGetTfliteCaptureDelay" | "deviceGetTfliteThreshold" | "deviceGetTfliteInferencingEnabled" | "deviceTfliteInference" | "deviceManufacturerName" | "deviceModelNumber" | "deviceSoftwareRevision" | "deviceHardwareRevision" | "deviceFirmwareRevision" | "devicePnpId" | "deviceSerialNumber" | "deviceDeviceInformation" | "deviceIsCharging" | "deviceGetBatteryCurrent" | "deviceGetMtu" | "deviceGetId" | "deviceGetName" | "deviceGetType" | "deviceGetCurrentTime" | "deviceNotConnected" | "deviceConnecting" | "deviceDisconnecting" | "deviceConnectionStatus" | "deviceSmp" | "deviceBatteryLevel" | "deviceFirmwareImages" | "deviceFirmwareUploadProgress" | "deviceFirmwareStatus" | "deviceConnectionMessage">(type: T, listener: (event: {
+        type: T;
+        target: DevicePair;
+        message: DevicePairEventMessages[T];
+    }) => void) => void;
+    get waitForEvent(): <T extends "pressure" | "deviceOrientation" | "sensorData" | "isConnected" | "deviceConnected" | "deviceIsConnected" | "deviceMaxFileLength" | "deviceGetFileType" | "deviceGetFileLength" | "deviceGetFileChecksum" | "deviceFileTransferStatus" | "deviceGetFileBlock" | "deviceFileTransferProgress" | "deviceFileTransferComplete" | "deviceFileReceived" | "devicePressure" | "deviceAcceleration" | "deviceGravity" | "deviceLinearAcceleration" | "deviceGyroscope" | "deviceMagnetometer" | "deviceGameRotation" | "deviceRotation" | "deviceActivity" | "deviceStepCounter" | "deviceStepDetector" | "deviceDeviceOrientation" | "deviceBarometer" | "deviceSensorData" | "deviceGetSensorConfiguration" | "deviceGetTfliteName" | "deviceGetTfliteTask" | "deviceGetTfliteSampleRate" | "deviceGetTfliteSensorTypes" | "deviceTfliteIsReady" | "deviceGetTfliteCaptureDelay" | "deviceGetTfliteThreshold" | "deviceGetTfliteInferencingEnabled" | "deviceTfliteInference" | "deviceManufacturerName" | "deviceModelNumber" | "deviceSoftwareRevision" | "deviceHardwareRevision" | "deviceFirmwareRevision" | "devicePnpId" | "deviceSerialNumber" | "deviceDeviceInformation" | "deviceIsCharging" | "deviceGetBatteryCurrent" | "deviceGetMtu" | "deviceGetId" | "deviceGetName" | "deviceGetType" | "deviceGetCurrentTime" | "deviceNotConnected" | "deviceConnecting" | "deviceDisconnecting" | "deviceConnectionStatus" | "deviceSmp" | "deviceBatteryLevel" | "deviceFirmwareImages" | "deviceFirmwareUploadProgress" | "deviceFirmwareStatus" | "deviceConnectionMessage">(type: T) => Promise<{
+        type: T;
+        target: DevicePair;
+        message: DevicePairEventMessages[T];
+    }>;
+    get left(): Device | undefined;
+    get right(): Device | undefined;
+    get isConnected(): boolean;
+    get isPartiallyConnected(): boolean;
+    get isHalfConnected(): boolean;
+    assignInsole(device: Device): Device | undefined;
+    setSensorConfiguration(sensorConfiguration: SensorConfiguration): void;
+    resetPressureRange(): void;
+    triggerVibration(vibrationConfigurations: VibrationConfiguration[], sendImmediately?: boolean): Promise<PromiseSettledResult<void | undefined>[]>;
+    static get shared(): DevicePair;
+}
+export default DevicePair;

package/build/dts/devicePair/DevicePairPressureSensorDataManager.d.ts

@@ -0,0 +1,25 @@
+import { PressureData } from "../sensor/PressureSensorDataManager.ts";
+import { CenterOfPressure } from "../utils/CenterOfPressureHelper.ts";
+import { InsoleSide } from "../InformationManager.ts";
+import { DeviceEventMap } from "../Device.ts";
+export type DevicePairRawPressureData = {
+    [insoleSide in InsoleSide]: PressureData;
+};
+export interface DevicePairPressureData {
+    rawSum: number;
+    normalizedSum: number;
+    center?: CenterOfPressure;
+    normalizedCenter?: CenterOfPressure;
+}
+export interface DevicePairPressureDataEventMessage {
+    pressure: DevicePairPressureData;
+}
+export interface DevicePairPressureDataEventMessages {
+    pressure: DevicePairPressureDataEventMessage;
+}
+declare class DevicePairPressureSensorDataManager {
+    #private;
+    resetPressureRange(): void;
+    onDevicePressureData(event: DeviceEventMap["pressure"]): DevicePairPressureData | undefined;
+}
+export default DevicePairPressureSensorDataManager;

package/build/dts/devicePair/DevicePairSensorDataManager.d.ts

@@ -0,0 +1,33 @@
+import DevicePairPressureSensorDataManager, { DevicePairPressureDataEventMessages } from "./DevicePairPressureSensorDataManager.ts";
+import { InsoleSide } from "../InformationManager.ts";
+import { DeviceEventMap } from "../Device.ts";
+import EventDispatcher from "../utils/EventDispatcher.ts";
+import DevicePair from "./DevicePair.ts";
+import { AddKeysAsPropertyToInterface, ExtendInterfaceValues, ValueOf } from "../utils/TypeScriptUtils.ts";
+export declare const DevicePairSensorTypes: readonly ["pressure", "sensorData"];
+export type DevicePairSensorType = (typeof DevicePairSensorTypes)[number];
+export declare const DevicePairSensorDataEventTypes: readonly ["pressure", "sensorData"];
+export type DevicePairSensorDataEventType = (typeof DevicePairSensorDataEventTypes)[number];
+export type DevicePairSensorDataTimestamps = {
+    [insoleSide in InsoleSide]: number;
+};
+interface BaseDevicePairSensorDataEventMessage {
+    timestamps: DevicePairSensorDataTimestamps;
+}
+type BaseDevicePairSensorDataEventMessages = DevicePairPressureDataEventMessages;
+type _DevicePairSensorDataEventMessages = ExtendInterfaceValues<AddKeysAsPropertyToInterface<BaseDevicePairSensorDataEventMessages, "sensorType">, BaseDevicePairSensorDataEventMessage>;
+export type DevicePairSensorDataEventMessage = ValueOf<_DevicePairSensorDataEventMessages>;
+interface AnyDevicePairSensorDataEventMessages {
+    sensorData: DevicePairSensorDataEventMessage;
+}
+export type DevicePairSensorDataEventMessages = _DevicePairSensorDataEventMessages & AnyDevicePairSensorDataEventMessages;
+export type DevicePairSensorDataEventDispatcher = EventDispatcher<DevicePair, DevicePairSensorDataEventType, DevicePairSensorDataEventMessages>;
+declare class DevicePairSensorDataManager {
+    #private;
+    eventDispatcher: DevicePairSensorDataEventDispatcher;
+    get dispatchEvent(): <T extends "pressure" | "sensorData">(type: T, message: DevicePairSensorDataEventMessages[T]) => void;
+    pressureSensorDataManager: DevicePairPressureSensorDataManager;
+    resetPressureRange(): void;
+    onDeviceSensorData(event: DeviceEventMap["sensorData"]): void;
+}
+export default DevicePairSensorDataManager;

package/build/dts/scanner/BaseScanner.d.ts

@@ -0,0 +1,66 @@
+import EventDispatcher, { BoundEventListeners, Event, EventMap } from "../utils/EventDispatcher.ts";
+import { DeviceType } from "../InformationManager.ts";
+export declare const ScannerEventTypes: readonly ["isScanningAvailable", "isScanning", "discoveredDevice", "expiredDiscoveredDevice"];
+export type ScannerEventType = (typeof ScannerEventTypes)[number];
+export interface DiscoveredDevice {
+    bluetoothId: string;
+    name: string;
+    deviceType: DeviceType;
+    rssi: number;
+}
+interface ScannerDiscoveredDeviceEventMessage {
+    discoveredDevice: DiscoveredDevice;
+}
+export interface ScannerEventMessages {
+    discoveredDevice: ScannerDiscoveredDeviceEventMessage;
+    expiredDiscoveredDevice: ScannerDiscoveredDeviceEventMessage;
+    isScanningAvailable: {
+        isScanningAvailable: boolean;
+    };
+    isScanning: {
+        isScanning: boolean;
+    };
+}
+export type ScannerEventDispatcher = EventDispatcher<BaseScanner, ScannerEventType, ScannerEventMessages>;
+export type ScannerEventMap = EventMap<BaseScanner, ScannerEventType, ScannerEventMessages>;
+export type ScannerEvent = Event<BaseScanner, ScannerEventType, ScannerEventMessages>;
+export type BoundScannerEventListeners = BoundEventListeners<BaseScanner, ScannerEventType, ScannerEventMessages>;
+export type DiscoveredDevicesMap = {
+    [deviceId: string]: DiscoveredDevice;
+};
+declare abstract class BaseScanner {
+    #private;
+    protected get baseConstructor(): typeof BaseScanner;
+    static get isSupported(): boolean;
+    get isSupported(): boolean;
+    constructor();
+    get addEventListener(): <T extends "isScanningAvailable" | "isScanning" | "discoveredDevice" | "expiredDiscoveredDevice">(type: T, listener: (event: {
+        type: T;
+        target: BaseScanner;
+        message: ScannerEventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }) => void;
+    protected get dispatchEvent(): <T extends "isScanningAvailable" | "isScanning" | "discoveredDevice" | "expiredDiscoveredDevice">(type: T, message: ScannerEventMessages[T]) => void;
+    get removeEventListener(): <T extends "isScanningAvailable" | "isScanning" | "discoveredDevice" | "expiredDiscoveredDevice">(type: T, listener: (event: {
+        type: T;
+        target: BaseScanner;
+        message: ScannerEventMessages[T];
+    }) => void) => void;
+    get waitForEvent(): <T extends "isScanningAvailable" | "isScanning" | "discoveredDevice" | "expiredDiscoveredDevice">(type: T) => Promise<{
+        type: T;
+        target: BaseScanner;
+        message: ScannerEventMessages[T];
+    }>;
+    get isScanningAvailable(): boolean;
+    get isScanning(): boolean;
+    startScan(): void;
+    stopScan(): void;
+    get discoveredDevices(): Readonly<DiscoveredDevicesMap>;
+    get discoveredDevicesArray(): DiscoveredDevice[];
+    static get DiscoveredDeviceExpirationTimeout(): number;
+    connectToDevice(deviceId: string): Promise<void>;
+    get canReset(): boolean;
+    reset(): void;
+}
+export default BaseScanner;

package/build/dts/scanner/NobleScanner.d.ts

@@ -0,0 +1,17 @@
+import BaseScanner from "./BaseScanner.ts";
+/** NODE_END */
+export declare const NobleStates: readonly ["unknown", "resetting", "unsupported", "unauthorized", "poweredOff", "poweredOn"];
+export type NobleState = (typeof NobleStates)[number];
+declare class NobleScanner extends BaseScanner {
+    #private;
+    static get isSupported(): boolean;
+    get isScanning(): boolean;
+    constructor();
+    get isScanningAvailable(): boolean;
+    startScan(): void;
+    stopScan(): void;
+    get canReset(): boolean;
+    reset(): void;
+    connectToDevice(deviceId: string): Promise<void>;
+}
+export default NobleScanner;

package/build/dts/scanner/Scanner.d.ts

@@ -0,0 +1,3 @@
+import BaseScanner from "./BaseScanner.ts";
+declare let scanner: BaseScanner | undefined;
+export default scanner;

package/build/dts/sensor/BarometerSensorDataManager.d.ts

@@ -0,0 +1,16 @@
+export declare const BarometerSensorTypes: readonly ["barometer"];
+export type BarometerSensorType = (typeof BarometerSensorTypes)[number];
+export declare const ContinuousBarometerSensorTypes: readonly ["barometer"];
+export type ContinuousBarometerSensorType = (typeof ContinuousBarometerSensorTypes)[number];
+export interface BarometerSensorDataEventMessages {
+    barometer: {
+        barometer: number;
+    };
+}
+declare class BarometerSensorDataManager {
+    #private;
+    parseData(dataView: DataView, scalar: number): {
+        pressure: number;
+    };
+}
+export default BarometerSensorDataManager;

package/build/dts/sensor/MotionSensorDataManager.d.ts

@@ -0,0 +1,69 @@
+export declare const MotionSensorTypes: readonly ["acceleration", "gravity", "linearAcceleration", "gyroscope", "magnetometer", "gameRotation", "rotation", "orientation", "activity", "stepCounter", "stepDetector", "deviceOrientation"];
+export type MotionSensorType = (typeof MotionSensorTypes)[number];
+export declare const ContinuousMotionTypes: readonly ["acceleration", "gravity", "linearAcceleration", "gyroscope", "magnetometer", "gameRotation", "rotation"];
+export type ContinuousMotionType = (typeof ContinuousMotionTypes)[number];
+import { Vector3, Quaternion, Euler } from "../utils/MathUtils.ts";
+import { ValueOf } from "../utils/TypeScriptUtils.ts";
+export declare const Vector2Size: number;
+export declare const Vector3Size: number;
+export declare const QuaternionSize: number;
+export declare const ActivityTypes: readonly ["still", "walking", "running", "bicycle", "vehicle", "tilting"];
+export type ActivityType = (typeof ActivityTypes)[number];
+export interface Activity {
+    still: boolean;
+    walking: boolean;
+    running: boolean;
+    bicycle: boolean;
+    vehicle: boolean;
+    tilting: boolean;
+}
+export declare const DeviceOrientations: readonly ["portraitUpright", "landscapeLeft", "portraitUpsideDown", "landscapeRight", "unknown"];
+export type DeviceOrientation = (typeof DeviceOrientations)[number];
+export interface MotionSensorDataEventMessages {
+    acceleration: {
+        acceleration: Vector3;
+    };
+    gravity: {
+        gravity: Vector3;
+    };
+    linearAcceleration: {
+        linearAcceleration: Vector3;
+    };
+    gyroscope: {
+        gyroscope: Vector3;
+    };
+    magnetometer: {
+        magnetometer: Vector3;
+    };
+    gameRotation: {
+        gameRotation: Quaternion;
+    };
+    rotation: {
+        rotation: Quaternion;
+    };
+    orientation: {
+        orientation: Euler;
+    };
+    stepDetector: {
+        stepDetector: Object;
+    };
+    stepCounter: {
+        stepCounter: number;
+    };
+    activity: {
+        activity: Activity;
+    };
+    deviceOrientation: {
+        deviceOrientation: DeviceOrientation;
+    };
+}
+export type MotionSensorDataEventMessage = ValueOf<MotionSensorDataEventMessages>;
+declare class MotionSensorDataManager {
+    parseVector3(dataView: DataView, scalar: number): Vector3;
+    parseQuaternion(dataView: DataView, scalar: number): Quaternion;
+    parseEuler(dataView: DataView, scalar: number): Euler;
+    parseStepCounter(dataView: DataView): number;
+    parseActivity(dataView: DataView): Activity;
+    parseDeviceOrientation(dataView: DataView): "portraitUpright" | "landscapeLeft" | "portraitUpsideDown" | "landscapeRight" | "unknown";
+}
+export default MotionSensorDataManager;

package/build/dts/sensor/PressureSensorDataManager.d.ts

@@ -0,0 +1,36 @@
+export declare const PressureSensorTypes: readonly ["pressure"];
+export type PressureSensorType = (typeof PressureSensorTypes)[number];
+export declare const ContinuousPressureSensorTypes: readonly ["pressure"];
+export type ContinuousPressureSensorType = (typeof ContinuousPressureSensorTypes)[number];
+import { Vector2 } from "../utils/MathUtils.ts";
+export type PressureSensorPosition = Vector2;
+import { CenterOfPressure } from "../utils/CenterOfPressureHelper.ts";
+export interface PressureSensorValue {
+    position: PressureSensorPosition;
+    rawValue: number;
+    scaledValue: number;
+    normalizedValue: number;
+    weightedValue: number;
+}
+export interface PressureData {
+    sensors: PressureSensorValue[];
+    scaledSum: number;
+    normalizedSum: number;
+    center?: CenterOfPressure;
+    normalizedCenter?: CenterOfPressure;
+}
+export interface PressureDataEventMessages {
+    pressure: {
+        pressure: PressureData;
+    };
+}
+export declare const DefaultNumberOfPressureSensors = 8;
+declare class PressureSensorDataManager {
+    #private;
+    get positions(): Vector2[];
+    get numberOfSensors(): number;
+    parsePositions(dataView: DataView): void;
+    resetRange(): void;
+    parseData(dataView: DataView, scalar: number): PressureData;
+}
+export default PressureSensorDataManager;