brilliantsole 0.0.1

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

@@ -0,0 +1,44 @@
+import { SensorType } from "./SensorDataManager.ts";
+import EventDispatcher from "../utils/EventDispatcher.ts";
+import Device, { SendMessageCallback } from "../Device.ts";
+export type SensorConfiguration = {
+    [sensorType in SensorType]?: number;
+};
+export declare const MaxSensorRate: number;
+export declare const SensorRateStep = 5;
+export declare const SensorConfigurationMessageTypes: readonly ["getSensorConfiguration", "setSensorConfiguration"];
+export type SensorConfigurationMessageType = (typeof SensorConfigurationMessageTypes)[number];
+export declare const SensorConfigurationEventTypes: readonly ["getSensorConfiguration", "setSensorConfiguration"];
+export type SensorConfigurationEventType = (typeof SensorConfigurationEventTypes)[number];
+export interface SensorConfigurationEventMessages {
+    getSensorConfiguration: {
+        sensorConfiguration: SensorConfiguration;
+    };
+}
+export type SensorConfigurationEventDispatcher = EventDispatcher<Device, SensorConfigurationEventType, SensorConfigurationEventMessages>;
+export type SendSensorConfigurationMessageCallback = SendMessageCallback<SensorConfigurationMessageType>;
+declare class SensorConfigurationManager {
+    #private;
+    constructor();
+    sendMessage: SendSensorConfigurationMessageCallback;
+    eventDispatcher: SensorConfigurationEventDispatcher;
+    get addEventListener(): <T extends "getSensorConfiguration" | "setSensorConfiguration">(type: T, listener: (event: {
+        type: T;
+        target: Device;
+        message: SensorConfigurationEventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }) => void;
+    get waitForEvent(): <T extends "getSensorConfiguration" | "setSensorConfiguration">(type: T) => Promise<{
+        type: T;
+        target: Device;
+        message: SensorConfigurationEventMessages[T];
+    }>;
+    get configuration(): SensorConfiguration;
+    setConfiguration(newSensorConfiguration: SensorConfiguration, clearRest?: boolean): Promise<void>;
+    static get ZeroSensorConfiguration(): SensorConfiguration;
+    get zeroSensorConfiguration(): SensorConfiguration;
+    clearSensorConfiguration(): Promise<void>;
+    parseMessage(messageType: SensorConfigurationMessageType, dataView: DataView): void;
+}
+export default SensorConfigurationManager;

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

@@ -0,0 +1,40 @@
+import PressureSensorDataManager, { PressureDataEventMessages } from "./PressureSensorDataManager.ts";
+import MotionSensorDataManager, { MotionSensorDataEventMessages } from "./MotionSensorDataManager.ts";
+import BarometerSensorDataManager, { BarometerSensorDataEventMessages } from "./BarometerSensorDataManager.ts";
+import EventDispatcher from "../utils/EventDispatcher.ts";
+import Device from "../Device.ts";
+import { AddKeysAsPropertyToInterface, ExtendInterfaceValues, ValueOf } from "../utils/TypeScriptUtils.ts";
+export declare const SensorTypes: readonly ["pressure", "acceleration", "gravity", "linearAcceleration", "gyroscope", "magnetometer", "gameRotation", "rotation", "orientation", "activity", "stepCounter", "stepDetector", "deviceOrientation", "barometer"];
+export type SensorType = (typeof SensorTypes)[number];
+export declare const ContinuousSensorTypes: readonly ["pressure", "acceleration", "gravity", "linearAcceleration", "gyroscope", "magnetometer", "gameRotation", "rotation", "barometer"];
+export type ContinuousSensorType = (typeof ContinuousSensorTypes)[number];
+export declare const SensorDataMessageTypes: readonly ["getPressurePositions", "getSensorScalars", "sensorData"];
+export type SensorDataMessageType = (typeof SensorDataMessageTypes)[number];
+export declare const SensorDataEventTypes: readonly ["getPressurePositions", "getSensorScalars", "sensorData", "pressure", "acceleration", "gravity", "linearAcceleration", "gyroscope", "magnetometer", "gameRotation", "rotation", "orientation", "activity", "stepCounter", "stepDetector", "deviceOrientation", "barometer"];
+export type SensorDataEventType = (typeof SensorDataEventTypes)[number];
+interface BaseSensorDataEventMessage {
+    timestamp: number;
+}
+type BaseSensorDataEventMessages = BarometerSensorDataEventMessages & MotionSensorDataEventMessages & PressureDataEventMessages;
+type _SensorDataEventMessages = ExtendInterfaceValues<AddKeysAsPropertyToInterface<BaseSensorDataEventMessages, "sensorType">, BaseSensorDataEventMessage>;
+export type SensorDataEventMessage = ValueOf<_SensorDataEventMessages>;
+interface AnySensorDataEventMessages {
+    sensorData: SensorDataEventMessage;
+}
+export type SensorDataEventMessages = _SensorDataEventMessages & AnySensorDataEventMessages;
+export type SensorDataEventDispatcher = EventDispatcher<Device, SensorDataEventType, SensorDataEventMessages>;
+declare class SensorDataManager {
+    #private;
+    pressureSensorDataManager: PressureSensorDataManager;
+    motionSensorDataManager: MotionSensorDataManager;
+    barometerSensorDataManager: BarometerSensorDataManager;
+    static AssertValidSensorType(sensorType: SensorType): void;
+    static AssertValidSensorTypeEnum(sensorTypeEnum: number): void;
+    eventDispatcher: SensorDataEventDispatcher;
+    get dispatchEvent(): <T extends "pressure" | "acceleration" | "gravity" | "linearAcceleration" | "gyroscope" | "magnetometer" | "gameRotation" | "rotation" | "orientation" | "activity" | "stepCounter" | "stepDetector" | "deviceOrientation" | "barometer" | "getPressurePositions" | "getSensorScalars" | "sensorData">(type: T, message: SensorDataEventMessages[T]) => void;
+    parseMessage(messageType: SensorDataMessageType, dataView: DataView): void;
+    parseScalars(dataView: DataView): void;
+    private parseData;
+    private parseDataCallback;
+}
+export default SensorDataManager;

package/build/dts/server/BaseClient.d.ts

@@ -0,0 +1,85 @@
+import { ServerMessage, ClientDeviceMessage } from "./ServerUtils.ts";
+import EventDispatcher, { BoundEventListeners, Event } from "../utils/EventDispatcher.ts";
+import Device from "../Device.ts";
+import { DiscoveredDevice, DiscoveredDevicesMap, ScannerEventMessages } from "../scanner/BaseScanner.ts";
+export declare const ClientConnectionStatuses: readonly ["notConnected", "connecting", "connected", "disconnecting"];
+export type ClientConnectionStatus = (typeof ClientConnectionStatuses)[number];
+export declare const ClientEventTypes: readonly ["notConnected", "connecting", "connected", "disconnecting", "connectionStatus", "isConnected", "isScanningAvailable", "isScanning", "discoveredDevice", "expiredDiscoveredDevice"];
+export type ClientEventType = (typeof ClientEventTypes)[number];
+interface ClientConnectionEventMessages {
+    connectionStatus: {
+        connectionStatus: ClientConnectionStatus;
+    };
+    isConnected: {
+        isConnected: boolean;
+    };
+}
+export type ClientEventMessages = ClientConnectionEventMessages & ScannerEventMessages;
+export type ClientEventDispatcher = EventDispatcher<BaseClient, ClientEventType, ClientEventMessages>;
+export type ClientEvent = Event<BaseClient, ClientEventType, ClientEventMessages>;
+export type BoundClientEventListeners = BoundEventListeners<BaseClient, ClientEventType, ClientEventMessages>;
+export type ServerURL = string | URL;
+type DevicesMap = {
+    [deviceId: string]: Device;
+};
+declare abstract class BaseClient {
+    #private;
+    protected get baseConstructor(): typeof BaseClient;
+    get devices(): Readonly<DevicesMap>;
+    get addEventListener(): <T extends "notConnected" | "connecting" | "connected" | "disconnecting" | "connectionStatus" | "isConnected" | "isScanningAvailable" | "isScanning" | "discoveredDevice" | "expiredDiscoveredDevice">(type: T, listener: (event: {
+        type: T;
+        target: BaseClient;
+        message: ClientEventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }) => void;
+    protected get dispatchEvent(): <T extends "notConnected" | "connecting" | "connected" | "disconnecting" | "connectionStatus" | "isConnected" | "isScanningAvailable" | "isScanning" | "discoveredDevice" | "expiredDiscoveredDevice">(type: T, message: ClientEventMessages[T]) => void;
+    get removeEventListener(): <T extends "notConnected" | "connecting" | "connected" | "disconnecting" | "connectionStatus" | "isConnected" | "isScanningAvailable" | "isScanning" | "discoveredDevice" | "expiredDiscoveredDevice">(type: T, listener: (event: {
+        type: T;
+        target: BaseClient;
+        message: ClientEventMessages[T];
+    }) => void) => void;
+    get waitForEvent(): <T extends "notConnected" | "connecting" | "connected" | "disconnecting" | "connectionStatus" | "isConnected" | "isScanningAvailable" | "isScanning" | "discoveredDevice" | "expiredDiscoveredDevice">(type: T) => Promise<{
+        type: T;
+        target: BaseClient;
+        message: ClientEventMessages[T];
+    }>;
+    abstract isConnected: boolean;
+    protected assertConnection(): void;
+    abstract isDisconnected: boolean;
+    protected assertDisconnection(): void;
+    abstract connect(): void;
+    abstract disconnect(): void;
+    abstract reconnect(): void;
+    abstract toggleConnection(url?: ServerURL): void;
+    static _reconnectOnDisconnection: boolean;
+    static get ReconnectOnDisconnection(): boolean;
+    static set ReconnectOnDisconnection(newReconnectOnDisconnection: boolean);
+    protected _reconnectOnDisconnection: boolean;
+    get reconnectOnDisconnection(): boolean;
+    set reconnectOnDisconnection(newReconnectOnDisconnection: boolean);
+    abstract sendServerMessage(...messages: ServerMessage[]): void;
+    protected get _connectionStatus(): "notConnected" | "connecting" | "connected" | "disconnecting";
+    protected set _connectionStatus(newConnectionStatus: "notConnected" | "connecting" | "connected" | "disconnecting");
+    get connectionStatus(): "notConnected" | "connecting" | "connected" | "disconnecting";
+    protected parseMessage(dataView: DataView): void;
+    get isScanningAvailable(): boolean;
+    protected requestIsScanningAvailable(): void;
+    get isScanning(): boolean;
+    startScan(): void;
+    stopScan(): void;
+    toggleScan(): void;
+    get discoveredDevices(): Readonly<DiscoveredDevicesMap>;
+    protected onDiscoveredDevice(discoveredDevice: DiscoveredDevice): void;
+    requestDiscoveredDevices(): void;
+    connectToDevice(bluetoothId: string): Device;
+    protected requestConnectionToDevice(bluetoothId: string): Device;
+    protected sendConnectToDeviceMessage(bluetoothId: string): void;
+    createDevice(bluetoothId: string): Device;
+    protected onConnectedBluetoothDeviceIds(bluetoothIds: string[]): void;
+    disconnectFromDevice(bluetoothId: string): void;
+    protected requestDisconnectionFromDevice(bluetoothId: string): Device;
+    protected sendDisconnectFromDeviceMessage(bluetoothId: string): void;
+    protected sendDeviceMessage(bluetoothId: string, ...messages: ClientDeviceMessage[]): void;
+}
+export default BaseClient;

package/build/dts/server/BaseServer.d.ts

@@ -0,0 +1,48 @@
+import EventDispatcher, { BoundEventListeners, Event, EventMap } from "../utils/EventDispatcher.ts";
+import Device from "../Device.ts";
+export declare const ServerEventTypes: readonly ["clientConnected", "clientDisconnected"];
+export type ServerEventType = (typeof ServerEventTypes)[number];
+interface ServerEventMessages {
+    clientConnected: {
+        client: any;
+    };
+    clientDisconnected: {
+        client: any;
+    };
+}
+export type ServerEventDispatcher = EventDispatcher<BaseServer, ServerEventType, ServerEventMessages>;
+export type ServerEvent = Event<BaseServer, ServerEventType, ServerEventMessages>;
+export type ServerEventMap = EventMap<BaseServer, ServerEventType, ServerEventMessages>;
+export type BoundServerEventListeners = BoundEventListeners<BaseServer, ServerEventType, ServerEventMessages>;
+declare abstract class BaseServer {
+    #private;
+    protected eventDispatcher: ServerEventDispatcher;
+    get addEventListener(): <T extends "clientConnected" | "clientDisconnected">(type: T, listener: (event: {
+        type: T;
+        target: BaseServer;
+        message: ServerEventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }) => void;
+    protected get dispatchEvent(): <T extends "clientConnected" | "clientDisconnected">(type: T, message: ServerEventMessages[T]) => void;
+    get removeEventListener(): <T extends "clientConnected" | "clientDisconnected">(type: T, listener: (event: {
+        type: T;
+        target: BaseServer;
+        message: ServerEventMessages[T];
+    }) => void) => void;
+    get waitForEvent(): <T extends "clientConnected" | "clientDisconnected">(type: T) => Promise<{
+        type: T;
+        target: BaseServer;
+        message: ServerEventMessages[T];
+    }>;
+    constructor();
+    get numberOfClients(): number;
+    static get ClearSensorConfigurationsWhenNoClients(): boolean;
+    static set ClearSensorConfigurationsWhenNoClients(newValue: boolean);
+    get clearSensorConfigurationsWhenNoClients(): boolean;
+    set clearSensorConfigurationsWhenNoClients(newValue: boolean);
+    broadcastMessage(message: ArrayBuffer): void;
+    protected parseClientMessage(dataView: DataView): ArrayBuffer | undefined;
+    protected parseClientDeviceMessage(device: Device, dataView: DataView): ArrayBuffer | undefined;
+}
+export default BaseServer;

package/build/dts/server/ServerUtils.d.ts

@@ -0,0 +1,23 @@
+import { ConnectionMessageType } from "../connection/BaseConnectionManager.ts";
+import { DeviceEventType } from "../Device.ts";
+export declare const ServerMessageTypes: readonly ["isScanningAvailable", "isScanning", "startScan", "stopScan", "discoveredDevice", "discoveredDevices", "expiredDiscoveredDevice", "connectToDevice", "disconnectFromDevice", "connectedDevices", "deviceMessage"];
+export type ServerMessageType = (typeof ServerMessageTypes)[number];
+export declare const DeviceMessageTypes: readonly ["connectionStatus", "batteryLevel", "deviceInformation", "rx", "smp"];
+export type DeviceMessageType = (typeof DeviceMessageTypes)[number];
+export type MessageLike = number | number[] | ArrayBufferLike | DataView | boolean | string | any;
+export interface Message<MessageType extends string> {
+    type: MessageType;
+    data?: MessageLike | MessageLike[];
+}
+export declare function createMessage<MessageType extends string>(enumeration: readonly MessageType[], ...messages: (Message<MessageType> | MessageType)[]): ArrayBuffer;
+export type ServerMessage = ServerMessageType | Message<ServerMessageType>;
+export declare function createServerMessage(...messages: ServerMessage[]): ArrayBuffer;
+export type DeviceMessage = DeviceEventType | Message<DeviceEventType>;
+export declare function createDeviceMessage(...messages: DeviceMessage[]): ArrayBuffer;
+export type ClientDeviceMessage = ConnectionMessageType | Message<ConnectionMessageType>;
+export declare function createClientDeviceMessage(...messages: ClientDeviceMessage[]): ArrayBuffer;
+export declare const isScanningAvailableRequestMessage: ArrayBuffer;
+export declare const isScanningRequestMessage: ArrayBuffer;
+export declare const startScanRequestMessage: ArrayBuffer;
+export declare const stopScanRequestMessage: ArrayBuffer;
+export declare const discoveredDevicesMessage: ArrayBuffer;

package/build/dts/server/udp/UDPServer.d.ts

@@ -0,0 +1,11 @@
+import BaseServer from "../BaseServer.ts";
+/** NODE_START */
+import type * as dgram from "dgram";
+declare class UDPServer extends BaseServer {
+    #private;
+    get numberOfClients(): number;
+    get socket(): dgram.Socket | undefined;
+    set socket(newSocket: dgram.Socket | undefined);
+    broadcastMessage(message: ArrayBuffer): void;
+}
+export default UDPServer;

package/build/dts/server/udp/UDPUtils.d.ts

@@ -0,0 +1,9 @@
+import { Message } from "../ServerUtils.ts";
+export declare const pongUDPClientTimeout = 2000;
+export declare const removeUDPClientTimeout = 3000;
+export declare const UDPServerMessageTypes: readonly ["ping", "pong", "setRemoteReceivePort", "serverMessage"];
+export type UDPServerMessageType = (typeof UDPServerMessageTypes)[number];
+export type UDPServerMessage = UDPServerMessageType | Message<UDPServerMessageType>;
+export declare function createUDPServerMessage(...messages: UDPServerMessage[]): ArrayBuffer;
+export declare const udpPingMessage: ArrayBuffer;
+export declare const udpPongMessage: ArrayBuffer;

package/build/dts/server/websocket/WebSocketClient.d.ts

@@ -0,0 +1,17 @@
+import { MessageLike, ServerMessage } from "../ServerUtils.ts";
+import BaseClient, { ServerURL } from "../BaseClient.ts";
+declare class WebSocketClient extends BaseClient {
+    #private;
+    get webSocket(): WebSocket | undefined;
+    set webSocket(newWebSocket: WebSocket | undefined);
+    get readyState(): number | undefined;
+    get isConnected(): boolean;
+    get isDisconnected(): boolean;
+    connect(url?: string | URL): void;
+    disconnect(): void;
+    reconnect(): void;
+    toggleConnection(url?: ServerURL): void;
+    sendMessage(message: MessageLike): void;
+    sendServerMessage(...messages: ServerMessage[]): void;
+}
+export default WebSocketClient;

package/build/dts/server/websocket/WebSocketServer.d.ts

@@ -0,0 +1,13 @@
+import BaseServer from "../BaseServer.ts";
+/** NODE_START */
+import type * as ws from "ws";
+interface WebSocketServer extends ws.WebSocketServer {
+}
+declare class WebSocketServer extends BaseServer {
+    #private;
+    get numberOfClients(): number;
+    get server(): WebSocketServer | undefined;
+    set server(newServer: WebSocketServer | undefined);
+    broadcastMessage(message: ArrayBuffer): void;
+}
+export default WebSocketServer;

package/build/dts/server/websocket/WebSocketUtils.d.ts

@@ -0,0 +1,9 @@
+import { Message } from "../ServerUtils.ts";
+export declare const webSocketPingTimeout = 30000000;
+export declare const webSocketReconnectTimeout = 3000;
+export declare const WebSocketMessageTypes: readonly ["ping", "pong", "serverMessage"];
+export type WebSocketMessageType = (typeof WebSocketMessageTypes)[number];
+export type WebSocketMessage = WebSocketMessageType | Message<WebSocketMessageType>;
+export declare function createWebSocketMessage(...messages: WebSocketMessage[]): ArrayBuffer;
+export declare const webSocketPingMessage: ArrayBuffer;
+export declare const webSocketPongMessage: ArrayBuffer;

package/build/dts/utils/ArrayBufferUtils.d.ts

@@ -0,0 +1,7 @@
+export declare function concatenateArrayBuffers(...arrayBuffers: any[]): ArrayBuffer;
+export declare function dataToArrayBuffer(data: Buffer): ArrayBuffer;
+export declare function stringToArrayBuffer(string: string): ArrayBuffer;
+export declare function objectToArrayBuffer(object: object): ArrayBuffer;
+export declare function sliceDataView(dataView: DataView, begin: number, length?: number): DataView;
+export type FileLike = number[] | ArrayBuffer | DataView | URL | string | File;
+export declare function getFileBuffer(file: FileLike): Promise<ArrayBuffer>;

package/build/dts/utils/ArrayUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function createArray(arrayLength: number, objectOrCallback: ((index: number) => any) | object): any[];
+export declare function arrayWithoutDuplicates(array: any[]): any[];

package/build/dts/utils/CenterOfPressureHelper.d.ts

@@ -0,0 +1,15 @@
+import RangeHelper from "./RangeHelper.ts";
+import { Vector2 } from "./MathUtils.ts";
+export type CenterOfPressure = Vector2;
+export interface CenterOfPressureRange {
+    x: RangeHelper;
+    y: RangeHelper;
+}
+declare class CenterOfPressureHelper {
+    #private;
+    reset(): void;
+    update(centerOfPressure: CenterOfPressure): void;
+    getNormalization(centerOfPressure: CenterOfPressure): CenterOfPressure;
+    updateAndGetNormalization(centerOfPressure: CenterOfPressure): Vector2;
+}
+export default CenterOfPressureHelper;

package/build/dts/utils/Console.d.ts

@@ -0,0 +1,34 @@
+export type LogFunction = (...data: any[]) => void;
+export type AssertLogFunction = (condition: boolean, ...data: any[]) => void;
+export interface ConsoleLevelFlags {
+    log?: boolean;
+    warn?: boolean;
+    error?: boolean;
+    assert?: boolean;
+    table?: boolean;
+}
+declare class Console {
+    #private;
+    constructor(type: string);
+    setLevelFlags(levelFlags: ConsoleLevelFlags): void;
+    /** @throws {Error} if no console with type "type" is found */
+    static setLevelFlagsForType(type: string, levelFlags: ConsoleLevelFlags): void;
+    static setAllLevelFlags(levelFlags: ConsoleLevelFlags): void;
+    static create(type: string, levelFlags?: ConsoleLevelFlags): Console;
+    get log(): LogFunction;
+    get warn(): LogFunction;
+    get error(): LogFunction;
+    get assert(): AssertLogFunction;
+    get table(): LogFunction;
+    /** @throws {Error} if condition is not met */
+    assertWithError(condition: any, message: string): void;
+    /** @throws {Error} if value's type doesn't match */
+    assertTypeWithError(value: any, type: string): void;
+    /** @throws {Error} if value's type doesn't match */
+    assertEnumWithError(value: string, enumeration: readonly string[]): void;
+}
+export declare function createConsole(type: string, levelFlags?: ConsoleLevelFlags): Console;
+/** @throws {Error} if no console with type is found */
+export declare function setConsoleLevelFlagsForType(type: string, levelFlags: ConsoleLevelFlags): void;
+export declare function setAllConsoleLevelFlags(levelFlags: ConsoleLevelFlags): void;
+export {};

package/build/dts/utils/EventDispatcher.d.ts

@@ -0,0 +1,50 @@
+export type EventMap<Target extends any, EventType extends string, EventMessages extends Partial<Record<EventType, any>>> = {
+    [T in keyof EventMessages]: {
+        type: T;
+        target: Target;
+        message: EventMessages[T];
+    };
+};
+export type EventListenerMap<Target extends any, EventType extends string, EventMessages extends Partial<Record<EventType, any>>> = {
+    [T in keyof EventMessages]: (event: {
+        type: T;
+        target: Target;
+        message: EventMessages[T];
+    }) => void;
+};
+export type Event<Target extends any, EventType extends string, EventMessages extends Partial<Record<EventType, any>>> = EventMap<Target, EventType, EventMessages>[keyof EventMessages];
+type SpecificEvent<Target extends any, EventType extends string, EventMessages extends Partial<Record<EventType, any>>, SpecificEventType extends EventType> = {
+    type: SpecificEventType;
+    target: Target;
+    message: EventMessages[SpecificEventType];
+};
+export type BoundEventListeners<Target extends any, EventType extends string, EventMessages extends Partial<Record<EventType, any>>> = {
+    [SpecificEventType in keyof EventMessages]?: (event: SpecificEvent<Target, EventType, EventMessages, SpecificEventType>) => void;
+};
+declare class EventDispatcher<Target extends any, EventType extends string, EventMessages extends Partial<Record<EventType, any>>> {
+    private target;
+    private validEventTypes;
+    private listeners;
+    constructor(target: Target, validEventTypes: readonly EventType[]);
+    private isValidEventType;
+    private updateEventListeners;
+    addEventListener<T extends EventType>(type: T, listener: (event: {
+        type: T;
+        target: Target;
+        message: EventMessages[T];
+    }) => void, options?: {
+        once?: boolean;
+    }): void;
+    removeEventListener<T extends EventType>(type: T, listener: (event: {
+        type: T;
+        target: Target;
+        message: EventMessages[T];
+    }) => void): void;
+    dispatchEvent<T extends EventType>(type: T, message: EventMessages[T]): void;
+    waitForEvent<T extends EventType>(type: T): Promise<{
+        type: T;
+        target: Target;
+        message: EventMessages[T];
+    }>;
+}
+export default EventDispatcher;

package/build/dts/utils/EventUtils.d.ts

@@ -0,0 +1,6 @@
+export type BoundGenericEventListeners = {
+    [eventType: string]: Function;
+};
+export declare function bindEventListeners(eventTypes: readonly string[], boundEventListeners: BoundGenericEventListeners, target: any): void;
+export declare function addEventListeners(target: any, boundEventListeners: BoundGenericEventListeners): void;
+export declare function removeEventListeners(target: any, boundEventListeners: BoundGenericEventListeners): void;

package/build/dts/utils/MathUtils.d.ts

@@ -0,0 +1,21 @@
+export declare function getInterpolation(value: number, min: number, max: number, span: number): number;
+export declare const Uint16Max: number;
+export declare function parseTimestamp(dataView: DataView, byteOffset: number): number;
+export interface Vector2 {
+    x: number;
+    y: number;
+}
+export interface Vector3 extends Vector2 {
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface Euler {
+    heading: number;
+    pitch: number;
+    roll: number;
+}

package/build/dts/utils/ParseUtils.d.ts

@@ -0,0 +1,5 @@
+export declare function parseStringFromDataView(dataView: DataView, byteOffset?: number): {
+    string: string;
+    byteOffset: number;
+};
+export declare function parseMessage<MessageType extends string>(dataView: DataView, messageTypes: readonly MessageType[], callback: (messageType: MessageType, dataView: DataView, context?: any) => void, context?: any, parseMessageLengthAsUint16?: boolean): void;

package/build/dts/utils/RangeHelper.d.ts

@@ -0,0 +1,8 @@
+declare class RangeHelper {
+    #private;
+    reset(): void;
+    update(value: number): void;
+    getNormalization(value: number, weightByRange: boolean): number;
+    updateAndGetNormalization(value: number, weightByRange: boolean): number;
+}
+export default RangeHelper;

package/build/dts/utils/Text.d.ts

@@ -0,0 +1,6 @@
+export declare const textEncoder: {
+    encode(string: string): Uint8Array;
+};
+export declare const textDecoder: {
+    decode(data: ArrayBuffer): string;
+} | TextDecoder;

package/build/dts/utils/Timer.d.ts

@@ -0,0 +1,14 @@
+export declare function wait(delay: number): Promise<unknown>;
+declare class Timer {
+    #private;
+    get callback(): Function;
+    set callback(newCallback: Function);
+    get interval(): number;
+    set interval(newInterval: number);
+    constructor(callback: Function, interval: number);
+    get isRunning(): boolean;
+    start(): void;
+    stop(): void;
+    restart(): void;
+}
+export default Timer;

package/build/dts/utils/TypeScriptUtils.d.ts

@@ -0,0 +1,19 @@
+export type ValueOf<T> = T[keyof T];
+export type KeyOf<T> = keyof T;
+export type AddProperty<T, Key extends string, Value> = T & {
+    [K in Key]: Value;
+};
+export type AddPropertyToInterfaceValues<Interface, Key extends string, Value> = {
+    [_ in keyof Interface]: AddProperty<Interface[_], Key, Value>;
+};
+export type AddKeysAsPropertyToInterface<Interface, Key extends string> = {
+    [Value in keyof Interface]: AddProperty<Interface[Value], Key, Value>;
+};
+export type ExtendInterfaceValues<Interface, T> = {
+    [Key in keyof Interface]: Interface[Key] & T;
+};
+export type CapitalizeFirstLetter<S extends string> = S extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${Rest}` : S;
+export type AddPrefix<P extends string, S extends string> = `${P}${CapitalizeFirstLetter<S>}`;
+export type AddPrefixToInterfaceKeys<Interface, P extends string> = {
+    [Key in keyof Interface as `${AddPrefix<P, Key & string>}`]: Interface[Key];
+};

package/build/dts/utils/cbor.d.ts

@@ -0,0 +1,6 @@
+export function encode(value: any): ArrayBuffer;
+export function decode(data: any, tagger: any, simpleValue: any): any;
+export namespace CBOR {
+    export { encode };
+    export { decode };
+}

package/build/dts/utils/checksum.d.ts

@@ -0,0 +1,3 @@
+export declare function crc32ForByte(r: number): number;
+export declare function crc32(dataIterable: ArrayBuffer | number[]): number;
+export declare function testCrc32(): void;

package/build/dts/utils/environment.d.ts

@@ -0,0 +1,13 @@
+declare const isInProduction: boolean;
+declare const isInDev: boolean;
+declare const isInBrowser: boolean;
+declare const isInNode: boolean;
+declare let isBluetoothSupported: boolean;
+declare const isInBluefy: boolean;
+declare const isInWebBLE: boolean;
+declare const isAndroid: boolean;
+declare const isSafari: boolean;
+declare const isIOS: boolean;
+declare const isMac: boolean;
+declare const isInLensStudio: boolean;
+export { isInDev, isInProduction, isInBrowser, isInNode, isAndroid, isInBluefy, isInWebBLE, isSafari, isInLensStudio, isIOS, isMac, isBluetoothSupported, };

package/build/dts/utils/mcumgr.d.ts

@@ -0,0 +1,88 @@
+export namespace constants {
+    let MGMT_OP_READ: number;
+    let MGMT_OP_READ_RSP: number;
+    let MGMT_OP_WRITE: number;
+    let MGMT_OP_WRITE_RSP: number;
+    let MGMT_GROUP_ID_OS: number;
+    let MGMT_GROUP_ID_IMAGE: number;
+    let MGMT_GROUP_ID_STAT: number;
+    let MGMT_GROUP_ID_CONFIG: number;
+    let MGMT_GROUP_ID_LOG: number;
+    let MGMT_GROUP_ID_CRASH: number;
+    let MGMT_GROUP_ID_SPLIT: number;
+    let MGMT_GROUP_ID_RUN: number;
+    let MGMT_GROUP_ID_FS: number;
+    let MGMT_GROUP_ID_SHELL: number;
+    let OS_MGMT_ID_ECHO: number;
+    let OS_MGMT_ID_CONS_ECHO_CTRL: number;
+    let OS_MGMT_ID_TASKSTAT: number;
+    let OS_MGMT_ID_MPSTAT: number;
+    let OS_MGMT_ID_DATETIME_STR: number;
+    let OS_MGMT_ID_RESET: number;
+    let IMG_MGMT_ID_STATE: number;
+    let IMG_MGMT_ID_UPLOAD: number;
+    let IMG_MGMT_ID_FILE: number;
+    let IMG_MGMT_ID_CORELIST: number;
+    let IMG_MGMT_ID_CORELOAD: number;
+    let IMG_MGMT_ID_ERASE: number;
+    let FS_MGMT_ID_FILE: number;
+}
+export class MCUManager {
+    _mtu: number;
+    _messageCallback: any;
+    _imageUploadProgressCallback: any;
+    _imageUploadNextCallback: any;
+    _fileUploadProgressCallback: any;
+    _fileUploadNextCallback: any;
+    _uploadIsInProgress: boolean;
+    _downloadIsInProgress: boolean;
+    _buffer: Uint8Array;
+    _seq: number;
+    onMessage(callback: any): this;
+    onImageUploadNext(callback: any): this;
+    onImageUploadProgress(callback: any): this;
+    onImageUploadFinished(callback: any): this;
+    _imageUploadFinishedCallback: any;
+    onFileUploadNext(callback: any): this;
+    onFileUploadProgress(callback: any): this;
+    onFileUploadFinished(callback: any): this;
+    _fileUploadFinishedCallback: any;
+    onFileDownloadNext(callback: any): this;
+    _fileDownloadNextCallback: any;
+    onFileDownloadProgress(callback: any): this;
+    _fileDownloadProgressCallback: any;
+    onFileDownloadFinished(callback: any): this;
+    _fileDownloadFinishedCallback: any;
+    _getMessage(op: any, group: any, id: any, data: any): any[];
+    _notification(buffer: any): void;
+    _processMessage(message: any): void;
+    _uploadOffset: any;
+    _uploadFileOffset: any;
+    _downloadFileLength: any;
+    cmdReset(): any[];
+    smpEcho(message: any): any[];
+    cmdImageState(): any[];
+    cmdImageErase(): any[];
+    cmdImageTest(hash: any): any[];
+    cmdImageConfirm(hash: any): any[];
+    _hash(image: any): Promise<ArrayBuffer>;
+    _uploadNext(): Promise<void>;
+    reset(): Promise<void>;
+    cmdUpload(image: any, slot?: number): Promise<void>;
+    _uploadImage: any;
+    _uploadSlot: number | undefined;
+    cmdUploadFile(filebuf: any, destFilename: any): Promise<void>;
+    _uploadFile: any;
+    _uploadFilename: any;
+    _uploadFileNext(): Promise<void>;
+    cmdDownloadFile(filename: any, destFilename: any): Promise<void>;
+    _downloadFileOffset: number | undefined;
+    _downloadRemoteFilename: any;
+    _downloadLocalFilename: any;
+    _downloadFileNext(): Promise<void>;
+    imageInfo(image: any): Promise<{
+        imageSize: number;
+        version: string;
+        hash: string;
+    }>;
+}

package/build/dts/utils/stringUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function spacesToPascalCase(string: string): string;
+export declare function capitalizeFirstCharacter(string: string): string;