@opendisplay/opendisplay 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,780 @@
+import { ColorScheme, DitherMode } from '@opendisplay/epaper-dithering';
+export { ColorScheme, DitherMode } from '@opendisplay/epaper-dithering';
+
+/**
+ * Device capabilities model.
+ */
+
+/**
+ * Minimal device information needed for image upload.
+ */
+interface DeviceCapabilities {
+    /** Display width in pixels */
+    width: number;
+    /** Display height in pixels */
+    height: number;
+    /** Display color scheme */
+    colorScheme: ColorScheme;
+    /** Display rotation in degrees (0, 90, 180, 270) */
+    rotation?: number;
+}
+
+/**
+ * Enums for OpenDisplay device configuration.
+ */
+/**
+ * Display refresh modes.
+ */
+declare enum RefreshMode {
+    FULL = 0,
+    FAST = 1,
+    PARTIAL = 2,
+    PARTIAL2 = 3
+}
+/**
+ * Microcontroller IC types.
+ */
+declare enum ICType {
+    NRF52840 = 1,
+    ESP32_S3 = 2,
+    ESP32_C3 = 3,
+    ESP32_C6 = 4
+}
+/**
+ * Power source types.
+ */
+declare enum PowerMode {
+    BATTERY = 1,
+    USB = 2,
+    SOLAR = 3
+}
+/**
+ * Data bus types for sensors.
+ */
+declare enum BusType {
+    I2C = 0,
+    SPI = 1
+}
+/**
+ * Display rotation angles in degrees.
+ */
+declare enum Rotation {
+    ROTATE_0 = 0,
+    ROTATE_90 = 90,
+    ROTATE_180 = 180,
+    ROTATE_270 = 270
+}
+
+/**
+ * TLV configuration data structures.
+ *
+ * These interfaces map directly to the firmware's TLV packet structures.
+ * Reference: OpenDisplayFirmware/src/structs.h
+ */
+
+/**
+ * System configuration (TLV packet type 0x01).
+ *
+ * Size: 22 bytes (packed struct from firmware)
+ */
+interface SystemConfig {
+    /** uint16 - IC type identifier */
+    icType: number;
+    /** uint8 bitfield - Supported communication modes */
+    communicationModes: number;
+    /** uint8 bitfield - Device capability flags */
+    deviceFlags: number;
+    /** uint8 - External power pin (0xFF = none) */
+    pwrPin: number;
+    /** 17 bytes - Reserved for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Helper functions for SystemConfig
+ */
+declare namespace SystemConfig {
+    const SIZE = 22;
+    /**
+     * Check if device has external power management pin (DEVICE_FLAG_PWR_PIN).
+     */
+    function hasPwrPin(config: SystemConfig): boolean;
+    /**
+     * Check if xiaoinit() should be called after config load - nRF52840 only (DEVICE_FLAG_XIAOINIT).
+     */
+    function needsXiaoinit(config: SystemConfig): boolean;
+    /**
+     * Get IC type as enum, or raw int if unknown.
+     */
+    function icTypeEnum(config: SystemConfig): ICType | number;
+    /**
+     * Parse SystemConfig from TLV packet data.
+     */
+    function fromBytes(data: Uint8Array): SystemConfig;
+}
+/**
+ * Manufacturer data (TLV packet type 0x02).
+ *
+ * Size: 22 bytes (packed struct from firmware)
+ */
+interface ManufacturerData {
+    /** uint16 - Manufacturer identifier */
+    manufacturerId: number;
+    /** uint8 - Board type */
+    boardType: number;
+    /** uint8 - Board revision */
+    boardRevision: number;
+    /** 18 bytes - Reserved for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Helper functions for ManufacturerData
+ */
+declare namespace ManufacturerData {
+    const SIZE = 22;
+    /**
+     * Parse ManufacturerData from TLV packet data.
+     */
+    function fromBytes(data: Uint8Array): ManufacturerData;
+}
+/**
+ * Power configuration (TLV packet type 0x04).
+ *
+ * Size: 30 bytes (packed struct from firmware - corrected from 32)
+ */
+interface PowerOption {
+    /** uint8 - Power mode identifier */
+    powerMode: number;
+    /** 3 bytes (24-bit value) - Battery capacity in mAh */
+    batteryCapacityMah: number;
+    /** uint16 - Sleep timeout in milliseconds */
+    sleepTimeoutMs: number;
+    /** uint8 - TX power level */
+    txPower: number;
+    /** uint8 bitfield - Sleep configuration flags */
+    sleepFlags: number;
+    /** uint8 - Battery sense pin (0xFF = none) */
+    batterySensePin: number;
+    /** uint8 - Battery sense enable pin (0xFF = none) */
+    batterySenseEnablePin: number;
+    /** uint8 bitfield - Battery sense flags */
+    batterySenseFlags: number;
+    /** uint8 - Capacity estimator type */
+    capacityEstimator: number;
+    /** uint16 - Voltage scaling factor */
+    voltageScalingFactor: number;
+    /** uint32 - Deep sleep current in microamps */
+    deepSleepCurrentUa: number;
+    /** uint16 - Deep sleep time in seconds */
+    deepSleepTimeSeconds: number;
+    /** 10 bytes - Reserved for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Helper functions for PowerOption
+ */
+declare namespace PowerOption {
+    const SIZE = 30;
+    /**
+     * Get battery capacity in mAh (already converted from 3-byte array).
+     */
+    function batteryMah(config: PowerOption): number;
+    /**
+     * Get power mode as enum, or raw int if unknown.
+     */
+    function powerModeEnum(config: PowerOption): PowerMode | number;
+    /**
+     * Parse PowerOption from TLV packet data.
+     */
+    function fromBytes(data: Uint8Array): PowerOption;
+}
+/**
+ * Display configuration (TLV packet type 0x20, repeatable max 4).
+ *
+ * Size: 46 bytes (packed struct from firmware - corrected from 66)
+ */
+interface DisplayConfig {
+    /** uint8 - Display instance number (0-3) */
+    instanceNumber: number;
+    /** uint8 - Display technology type */
+    displayTechnology: number;
+    /** uint16 - Panel IC type */
+    panelIcType: number;
+    /** uint16 - Display width in pixels */
+    pixelWidth: number;
+    /** uint16 - Display height in pixels */
+    pixelHeight: number;
+    /** uint16 - Active area width in millimeters */
+    activeWidthMm: number;
+    /** uint16 - Active area height in millimeters */
+    activeHeightMm: number;
+    /** uint16 - Tag type (legacy) */
+    tagType: number;
+    /** uint8 - Display rotation in degrees */
+    rotation: number;
+    /** uint8 - Reset pin (0xFF = none) */
+    resetPin: number;
+    /** uint8 - Busy pin (0xFF = none) */
+    busyPin: number;
+    /** uint8 - Data/Command pin (0xFF = none) */
+    dcPin: number;
+    /** uint8 - Chip select pin (0xFF = none) */
+    csPin: number;
+    /** uint8 - Data pin */
+    dataPin: number;
+    /** uint8 - Partial update support level */
+    partialUpdateSupport: number;
+    /** uint8 - Color scheme identifier */
+    colorScheme: number;
+    /** uint8 bitfield - Supported transmission modes */
+    transmissionModes: number;
+    /** uint8 - Clock pin */
+    clkPin: number;
+    /** 7 bytes - Reserved pin slots */
+    reservedPins: Uint8Array;
+    /** 15 bytes - Reserved for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Helper functions for DisplayConfig
+ */
+declare namespace DisplayConfig {
+    const SIZE = 46;
+    /**
+     * Check if display supports raw image transmission (TRANSMISSION_MODE_RAW).
+     */
+    function supportsRaw(config: DisplayConfig): boolean;
+    /**
+     * Check if display supports ZIP compressed transmission (TRANSMISSION_MODE_ZIP).
+     */
+    function supportsZip(config: DisplayConfig): boolean;
+    /**
+     * Check if display supports Group 5 compression (TRANSMISSION_MODE_G5).
+     */
+    function supportsG5(config: DisplayConfig): boolean;
+    /**
+     * Check if display supports direct write mode - bufferless (TRANSMISSION_MODE_DIRECT_WRITE).
+     */
+    function supportsDirectWrite(config: DisplayConfig): boolean;
+    /**
+     * Check if display should clear screen at bootup (TRANSMISSION_MODE_CLEAR_ON_BOOT).
+     */
+    function clearOnBoot(config: DisplayConfig): boolean;
+    /**
+     * Get color scheme as enum, or raw int if unknown.
+     */
+    function colorSchemeEnum(config: DisplayConfig): ColorScheme | number;
+    /**
+     * Get rotation as enum, or raw int if unknown.
+     */
+    function rotationEnum(config: DisplayConfig): Rotation | number;
+    /**
+     * Parse DisplayConfig from TLV packet data.
+     */
+    function fromBytes(data: Uint8Array): DisplayConfig;
+}
+/**
+ * LED configuration (TLV packet type 0x21, repeatable max 4).
+ *
+ * Size: 22 bytes (packed struct from firmware)
+ */
+interface LedConfig {
+    /** uint8 - LED instance number */
+    instanceNumber: number;
+    /** uint8 - LED type */
+    ledType: number;
+    /** uint8 - Red channel pin */
+    led1R: number;
+    /** uint8 - Green channel pin */
+    led2G: number;
+    /** uint8 - Blue channel pin */
+    led3B: number;
+    /** uint8 - 4th channel pin */
+    led4: number;
+    /** uint8 bitfield - LED configuration flags */
+    ledFlags: number;
+    /** 15 bytes - Reserved for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Helper functions for LedConfig
+ */
+declare namespace LedConfig {
+    const SIZE = 22;
+    /**
+     * Parse LedConfig from TLV packet data.
+     */
+    function fromBytes(data: Uint8Array): LedConfig;
+}
+/**
+ * Sensor configuration (TLV packet type 0x23, repeatable max 4).
+ *
+ * Size: 30 bytes (packed struct from firmware)
+ */
+interface SensorData {
+    /** uint8 - Sensor instance number */
+    instanceNumber: number;
+    /** uint16 - Sensor type identifier */
+    sensorType: number;
+    /** uint8 - Data bus ID */
+    busId: number;
+    /** 26 bytes - Reserved for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Helper functions for SensorData
+ */
+declare namespace SensorData {
+    const SIZE = 30;
+    /**
+     * Parse SensorData from TLV packet data.
+     */
+    function fromBytes(data: Uint8Array): SensorData;
+}
+/**
+ * Data bus configuration (TLV packet type 0x24, repeatable max 4).
+ *
+ * Size: 30 bytes (packed struct from firmware - corrected from 28)
+ */
+interface DataBus {
+    /** uint8 - Bus instance number */
+    instanceNumber: number;
+    /** uint8 - Bus type identifier */
+    busType: number;
+    /** uint8 - Pin 1 (SCL for I2C) */
+    pin1: number;
+    /** uint8 - Pin 2 (SDA for I2C) */
+    pin2: number;
+    /** uint8 - Pin 3 */
+    pin3: number;
+    /** uint8 - Pin 4 */
+    pin4: number;
+    /** uint8 - Pin 5 */
+    pin5: number;
+    /** uint8 - Pin 6 */
+    pin6: number;
+    /** uint8 - Pin 7 */
+    pin7: number;
+    /** uint32 - Bus speed in Hz */
+    busSpeedHz: number;
+    /** uint8 bitfield - Bus configuration flags */
+    busFlags: number;
+    /** uint8 bitfield - Pullup resistors configuration */
+    pullups: number;
+    /** uint8 bitfield - Pulldown resistors configuration */
+    pulldowns: number;
+    /** 14 bytes - Reserved for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Helper functions for DataBus
+ */
+declare namespace DataBus {
+    const SIZE = 30;
+    /**
+     * Get bus type as enum, or raw int if unknown.
+     */
+    function busTypeEnum(config: DataBus): BusType | number;
+    /**
+     * Parse DataBus from TLV packet data.
+     */
+    function fromBytes(data: Uint8Array): DataBus;
+}
+/**
+ * Binary inputs configuration (TLV packet type 0x25, repeatable max 4).
+ *
+ * Size: 30 bytes (packed struct from firmware - corrected from 29)
+ */
+interface BinaryInputs {
+    /** uint8 - Input instance number */
+    instanceNumber: number;
+    /** uint8 - Input type */
+    inputType: number;
+    /** uint8 - Display representation type */
+    displayAs: number;
+    /** 8 bytes - Reserved pin slots */
+    reservedPins: Uint8Array;
+    /** uint8 bitfield - Input configuration flags */
+    inputFlags: number;
+    /** uint8 bitfield - Invert flags */
+    invert: number;
+    /** uint8 bitfield - Pullup resistors configuration */
+    pullups: number;
+    /** uint8 bitfield - Pulldown resistors configuration */
+    pulldowns: number;
+    /** 15 bytes - Reserved for future use */
+    reserved: Uint8Array;
+}
+/**
+ * Helper functions for BinaryInputs
+ */
+declare namespace BinaryInputs {
+    const SIZE = 30;
+    /**
+     * Parse BinaryInputs from TLV packet data.
+     */
+    function fromBytes(data: Uint8Array): BinaryInputs;
+}
+/**
+ * Complete device configuration parsed from TLV data.
+ *
+ * Corresponds to GlobalConfig struct in firmware.
+ */
+interface GlobalConfig {
+    /** System configuration (single instance) */
+    system?: SystemConfig;
+    /** Manufacturer data (single instance) */
+    manufacturer?: ManufacturerData;
+    /** Power configuration (single instance) */
+    power?: PowerOption;
+    /** Display configurations (max 4) */
+    displays: DisplayConfig[];
+    /** LED configurations (max 4) */
+    leds: LedConfig[];
+    /** Sensor configurations (max 4) */
+    sensors: SensorData[];
+    /** Data bus configurations (max 4) */
+    dataBuses: DataBus[];
+    /** Binary input configurations (max 4) */
+    binaryInputs: BinaryInputs[];
+    /** Configuration version from device */
+    version: number;
+    /** Minor version (not stored in device) */
+    minorVersion: number;
+    /** Whether config was successfully loaded */
+    loaded: boolean;
+}
+
+/**
+ * Firmware version data structure.
+ */
+interface FirmwareVersion {
+    /**
+     * Major version number (0-255)
+     */
+    major: number;
+    /**
+     * Minor version number (0-255)
+     */
+    minor: number;
+    /**
+     * Git commit SHA hash
+     */
+    sha: string;
+}
+
+/**
+ * Web Bluetooth connection wrapper for OpenDisplay devices.
+ *
+ * Provides a clean interface for BLE operations:
+ * - Device discovery and connection
+ * - Command transmission
+ * - Response reception with queuing
+ * - Automatic reconnection handling
+ */
+/**
+ * Connection options for BLE device.
+ */
+interface BLEConnectionOptions {
+    /**
+     * Name prefix to filter devices (e.g., "OpenDisplay")
+     * If not provided, user will see all devices with the OpenDisplay service
+     */
+    namePrefix?: string;
+    /**
+     * Optional BluetoothDevice to connect to directly
+     */
+    device?: BluetoothDevice;
+}
+
+/**
+ * Main OpenDisplay BLE device class.
+ */
+
+/**
+ * OpenDisplay BLE e-paper device.
+ *
+ * Main API for communicating with OpenDisplay BLE tags.
+ *
+ * @example
+ * ```typescript
+ * // Auto-interrogate on first connect
+ * const device = new OpenDisplayDevice();
+ * await device.connect();
+ * await device.uploadImage(imageData);
+ * await device.disconnect();
+ *
+ * // Skip interrogation with cached config
+ * const device = new OpenDisplayDevice({ config: cachedConfig });
+ * await device.connect();
+ *
+ * // Skip interrogation with minimal capabilities
+ * const caps: DeviceCapabilities = { width: 296, height: 128, colorScheme: ColorScheme.BWR };
+ * const device = new OpenDisplayDevice({ capabilities: caps });
+ * ```
+ */
+declare class OpenDisplayDevice {
+    private options;
+    static readonly TIMEOUT_FIRST_CHUNK = 10000;
+    static readonly TIMEOUT_CHUNK = 2000;
+    static readonly TIMEOUT_ACK = 5000;
+    static readonly TIMEOUT_REFRESH = 90000;
+    private connection;
+    private _config;
+    private _capabilities;
+    private _fwVersion;
+    /**
+     * Initialize OpenDisplay device.
+     *
+     * @param options - Device initialization options
+     */
+    constructor(options?: {
+        config?: GlobalConfig;
+        capabilities?: DeviceCapabilities;
+        device?: BluetoothDevice;
+        namePrefix?: string;
+    });
+    /**
+     * Get full device configuration (if interrogated).
+     */
+    get config(): GlobalConfig | null;
+    /**
+     * Get device capabilities (width, height, color scheme, rotation).
+     */
+    get capabilities(): DeviceCapabilities | null;
+    /**
+     * Get display width in pixels.
+     */
+    get width(): number;
+    /**
+     * Get display height in pixels.
+     */
+    get height(): number;
+    /**
+     * Get display color scheme.
+     */
+    get colorScheme(): ColorScheme;
+    /**
+     * Get display rotation in degrees.
+     */
+    get rotation(): number;
+    /**
+     * Check if currently connected to a device.
+     */
+    get isConnected(): boolean;
+    /**
+     * Connect to an OpenDisplay device and optionally interrogate.
+     *
+     * @param connectionOptions - Optional connection parameters
+     * @throws {BLEConnectionError} If connection fails
+     */
+    connect(connectionOptions?: BLEConnectionOptions): Promise<void>;
+    /**
+     * Disconnect from the device.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Read device configuration from device.
+     *
+     * @returns GlobalConfig with complete device configuration
+     * @throws {ProtocolError} If interrogation fails
+     */
+    interrogate(): Promise<GlobalConfig>;
+    /**
+     * Read firmware version from device.
+     *
+     * @returns FirmwareVersion with major, minor, and sha fields
+     */
+    readFirmwareVersion(): Promise<FirmwareVersion>;
+    /**
+     * Reboot the device.
+     *
+     * Sends a reboot command to the device, which will cause an immediate
+     * system reset. The device will NOT send an ACK response - it simply
+     * resets after a 100ms delay.
+     *
+     * Warning: The BLE connection will be forcibly terminated when the device
+     * resets. This is expected behavior. The device will restart and begin
+     * advertising again after the reset completes (typically within a few seconds).
+     *
+     * @throws {BLEConnectionError} If command cannot be sent
+     */
+    reboot(): Promise<void>;
+    /**
+     * Write configuration to device.
+     *
+     * Serializes the GlobalConfig to TLV binary format and writes it
+     * to the device using the WRITE_CONFIG (0x0041) command with
+     * automatic chunking for large configs.
+     *
+     * @param config - GlobalConfig to write to device
+     * @throws {Error} If config serialization fails or exceeds size limit
+     * @throws {BLEConnectionError} If write fails
+     * @throws {ProtocolError} If device returns error response
+     *
+     * @example
+     * ```typescript
+     * // Read current config
+     * const config = device.config;
+     *
+     * // Modify config
+     * config.displays[0].rotation = 180;
+     *
+     * // Write back to device
+     * await device.writeConfig(config);
+     *
+     * // Reboot to apply changes
+     * await device.reboot();
+     * ```
+     */
+    writeConfig(config: GlobalConfig): Promise<void>;
+    /**
+     * Upload image to device display.
+     *
+     * Automatically handles:
+     * - Image resizing to display dimensions
+     * - Dithering based on color scheme
+     * - Encoding to device format
+     * - Compression
+     * - Direct write protocol
+     *
+     * @param imageData - Image as ImageData (from canvas or OffscreenCanvas)
+     * @param options - Upload options
+     * @throws {Error} If device not interrogated/configured
+     * @throws {ProtocolError} If upload fails
+     *
+     * @example
+     * ```typescript
+     * const canvas = document.getElementById('myCanvas') as HTMLCanvasElement;
+     * const ctx = canvas.getContext('2d')!;
+     * const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+     *
+     * await device.uploadImage(imageData, {
+     *   refreshMode: RefreshMode.FULL,
+     *   ditherMode: DitherMode.BURKES,
+     *   compress: true
+     * });
+     * ```
+     */
+    uploadImage(imageData: ImageData, options?: {
+        refreshMode?: RefreshMode;
+        ditherMode?: DitherMode;
+        compress?: boolean;
+    }): Promise<void>;
+    /**
+     * Execute image upload using compressed or uncompressed protocol.
+     */
+    private executeUpload;
+    /**
+     * Send image data chunks with ACK handling.
+     *
+     * Sends image data in chunks via 0x0071 DATA commands. Handles:
+     * - Timeout recovery when firmware starts display refresh
+     * - Auto-completion detection (firmware sends 0x0072 END early)
+     * - Progress logging
+     *
+     * @param imageData - Data to send in chunks
+     * @returns True if device auto-completed (sent 0x0072 END early), false if all chunks sent normally
+     * @throws {ProtocolError} If unexpected response received
+     * @throws {BLETimeoutError} If no response within timeout
+     */
+    private sendDataChunks;
+    /**
+     * Extract DeviceCapabilities from GlobalConfig.
+     */
+    private extractCapabilitiesFromConfig;
+    /**
+     * Ensure device capabilities are available.
+     */
+    private ensureCapabilities;
+    /**
+     * Ensure device is connected.
+     */
+    private ensureConnected;
+}
+
+/**
+ * BLE device discovery for OpenDisplay devices.
+ *
+ * Note: Web Bluetooth API does not provide general scanning like Python's Bleak.
+ * Instead, we use requestDevice() which shows a browser picker dialog.
+ */
+/**
+ * Discover OpenDisplay BLE devices using browser picker.
+ *
+ * Shows the browser's device picker dialog filtered to OpenDisplay devices.
+ * User selects a device, and we return it for connection.
+ *
+ * @param namePrefix - Optional name prefix filter (e.g., "OpenDisplay")
+ * @returns Selected BluetoothDevice
+ * @throws {Error} If Web Bluetooth not supported or user cancels
+ *
+ * @example
+ * ```typescript
+ * const device = await discoverDevices();
+ * // or with name filter:
+ * const device = await discoverDevices('OpenDisplay');
+ * ```
+ */
+declare function discoverDevices(namePrefix?: string): Promise<BluetoothDevice>;
+
+/**
+ * BLE advertisement data structures.
+ */
+/**
+ * Parsed BLE advertisement manufacturer data.
+ *
+ * Advertisement format (11 bytes, manufacturer ID already stripped by Web Bluetooth):
+ *
+ * - [0-6]: Fixed protocol bytes
+ * - [7-8]: Battery voltage in millivolts (little-endian uint16)
+ * - [9]: Chip temperature in Celsius (signed int8)
+ * - [10]: Loop counter (uint8, increments each advertisement)
+ *
+ * Note: Web Bluetooth provides manufacturer data without the manufacturer ID prefix.
+ */
+interface AdvertisementData {
+    /** Battery voltage in millivolts */
+    batteryMv: number;
+    /** Chip temperature in Celsius */
+    temperatureC: number;
+    /** Incrementing counter for each advertisement */
+    loopCounter: number;
+}
+/**
+ * Parse BLE advertisement manufacturer data.
+ *
+ * Note: The manufacturer ID (0x2446) is already stripped by Web Bluetooth
+ * and provided as the key in manufacturerData.
+ *
+ * @param data - Raw manufacturer data (11 bytes, without the manufacturer ID prefix)
+ * @returns AdvertisementData with parsed values
+ * @throws {Error} If data is too short
+ */
+declare function parseAdvertisement(data: Uint8Array): AdvertisementData;
+
+/**
+ * Exception classes for OpenDisplay library.
+ */
+declare class OpenDisplayError extends Error {
+    constructor(message: string);
+}
+declare class BLEConnectionError extends OpenDisplayError {
+    constructor(message: string);
+}
+declare class BLETimeoutError extends OpenDisplayError {
+    constructor(message: string);
+}
+declare class ProtocolError extends OpenDisplayError {
+    constructor(message: string);
+}
+declare class ConfigParseError extends ProtocolError {
+    constructor(message: string);
+}
+declare class InvalidResponseError extends ProtocolError {
+    constructor(message: string);
+}
+declare class ImageEncodingError extends OpenDisplayError {
+    constructor(message: string);
+}
+
+export { type AdvertisementData, BLEConnectionError, BLETimeoutError, BinaryInputs, BusType, ConfigParseError, DataBus, type DeviceCapabilities, DisplayConfig, type FirmwareVersion, type GlobalConfig, ICType, ImageEncodingError, InvalidResponseError, LedConfig, ManufacturerData, OpenDisplayDevice, OpenDisplayError, PowerMode, PowerOption, ProtocolError, RefreshMode, Rotation, SensorData, SystemConfig, discoverDevices, parseAdvertisement };