@busy-app/busy-lib 0.12.0 → 0.13.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { Client } from 'openapi-fetch';
+import { Client as Client_2 } from 'openapi-fetch';
+import Long_2 = require('long');
 
 export declare type AccountInfo = components['schemas']['AccountInfo'];
 
@@ -154,8 +155,117 @@ export declare interface AudioVolumeParams extends TimeoutOptions, AudioVolumeQu
 
 declare type AudioVolumeQuery = operations['setAudioVolume']['parameters']['query'];
 
+/**
+ * Authentication progress (Handshake/Token refresh)
+ */
+export declare enum AuthStatus {
+    UNAUTHENTICATED = "UNAUTHENTICATED",
+    AUTHENTICATING = "AUTHENTICATING",
+    AUTHENTICATED = "AUTHENTICATED",
+    FAILED = "FAILED"
+}
+
 export declare type AutoUpdateSettings = components['schemas']['AutoupdateSettings'];
 
+/**
+ * Base class for all StateStream connections.
+ * Orchestrates worker communication and callback management.
+ */
+declare abstract class BaseStateStream {
+    protected addr: string;
+    protected token?: string;
+    protected isBinary: boolean;
+    protected connectTimeout: number;
+    protected dataTimeout: number;
+    protected abstract streamMode: StreamMode;
+    private worker;
+    private connectionTimer;
+    private dataTimer;
+    private _status;
+    get status(): StreamStatus;
+    /** Static map to deduplicate token refresh requests across all instances in this JS context */
+    private static tokenRefreshPromises;
+    protected dataCallback?: DataCallback;
+    protected rawDataCallback?: RawDataCallback;
+    protected errorCallback?: ErrorCallback_2;
+    protected statusCallback?: StatusCallback;
+    constructor(options: StreamOptions, config?: StreamConfig);
+    /**
+     * Transforms http/https to ws/wss and prefixes with auto-inferred protocol if no protocol present.
+     */
+    protected resolveProtocol(addr: string): string;
+    /**
+     * Starts the stream connection.
+     * Throws an error if already running.
+     */
+    start({ dataCallback, rawDataCallback, errorCallback, statusCallback }: {
+        dataCallback?: DataCallback;
+        rawDataCallback?: RawDataCallback;
+        errorCallback?: ErrorCallback_2;
+        statusCallback?: StatusCallback;
+    }): void;
+    /**
+     * Stops the stream connection.
+     */
+    stop(): void;
+    /**
+     * Cleans up all resources.
+     */
+    destroy(): void;
+    /**
+     * Clears all registered callbacks.
+     */
+    private clearCallbacks;
+    /**
+     * Sends a new token to the worker (for auth or token refresh).
+     */
+    protected sendToken(token: string): void;
+    /**
+     * Subclasses must provide their own URL normalization.
+     */
+    protected abstract normalizeUrl(addr: string): string;
+    /**
+     * Sends a command to the worker port.
+     */
+    protected sendCommand(cmd: WorkerCommand): void;
+    private ensureWorker;
+    /**
+     * Processes messages from the worker.
+     */
+    protected handleWorkerMessage(event: WorkerEvent): void;
+    /**
+     * Maps an error code to the corresponding status component
+     */
+    private mapErrorToStatus;
+    /**
+     * Updates a single component of the status and notifies listeners
+     */
+    private updateStatusComponent;
+    /**
+     * Safe timer cleanup
+     */
+    private clearConnectionTimer;
+    /**
+     * Reset the data inactivity timer
+     */
+    private resetDataTimer;
+    private clearDataTimer;
+    /**
+     * Normalizes the raw state from the worker into a ProcessedState for the UI.
+     * Extracts the 'state' key for each update and merges bar_id for remote mode.
+     */
+    private normalizeState;
+    /**
+     * Internally deduplicates token refresh requests for the same address.
+     */
+    private handleTokenExpiredInternal;
+    /**
+     * Hook for handling token expiration.
+     * Return a promise with the new token to enable deduplication.
+     */
+    protected onTokenExpired?(): Promise<string> | void;
+}
+
 declare class BleMethods {
     /**
      * Enable BLE. Starts advertising.
@@ -195,6 +305,617 @@ export declare type BleStatusResponse = components['schemas']['BleStatusResponse
 
 declare type Brightness = number | 'auto';
 
+/** Namespace BSB_Error. */
+export declare namespace BSB_Error {
+
+    /** Cause enum. */
+    export enum Cause {
+        RESOURCE_LIMIT = 0
+    }
+
+    /** Severity enum. */
+    export enum Severity {
+        FATAL = 0,
+        ERROR = 1,
+        WARNING = 2
+    }
+
+    /** Properties of an Error. */
+    export interface Error {
+
+        /** Error cause */
+        cause?: (BSB_Error.Cause|null);
+
+        /** Error severity */
+        severity?: (BSB_Error.Severity|null);
+    }
+
+}
+
+/** Namespace BSB_Frame. */
+export declare namespace BSB_Frame {
+
+    /** Encoding enum. */
+    export enum Encoding {
+        PLAIN = 0,
+        RUN_LENGTH = 1,
+        DEFLATE = 2,
+        DEFLATE_RUN_LENGTH = 3
+    }
+
+    /** PixelFormat enum. */
+    export enum PixelFormat {
+        RGB888 = 0,
+        L8 = 1,
+        L4 = 2
+    }
+
+    /** Screen enum. */
+    export enum Screen {
+        FRONT = 0,
+        BACK = 1
+    }
+
+    /** Properties of a Frame. */
+    export interface Frame {
+
+        /** Frame screen */
+        screen?: (BSB_Frame.Screen|null);
+
+        /** Frame width */
+        width?: (number|null);
+
+        /** Frame height */
+        height?: (number|null);
+
+        /** Frame encoding */
+        encoding?: (BSB_Frame.Encoding|null);
+
+        /** Frame pixelFormat */
+        pixelFormat?: (BSB_Frame.PixelFormat|null);
+
+        /** Frame data */
+        data?: (Uint8Array|null);
+    }
+
+}
+
+/** Namespace BSB_Input. */
+export declare namespace BSB_Input {
+
+    /** Button enum. */
+    export enum Button {
+        OK = 0,
+        BACK = 1,
+        START = 2
+    }
+
+    /** ButtonAction enum. */
+    export enum ButtonAction {
+        PRESS = 0,
+        RELEASE = 1
+    }
+
+    /** SwitchPosition enum. */
+    export enum SwitchPosition {
+        BUSY = 0,
+        CUSTOM = 1,
+        OFF = 2,
+        APPS = 3,
+        SETTINGS = 4
+    }
+
+    /** Properties of a ButtonEvent. */
+    export interface ButtonEvent {
+
+        /** ButtonEvent button */
+        button?: (BSB_Input.Button|null);
+
+        /** ButtonEvent action */
+        action?: (BSB_Input.ButtonAction|null);
+    }
+
+
+    /** Properties of a SwitchEvent. */
+    export interface SwitchEvent {
+
+        /** SwitchEvent position */
+        position?: (BSB_Input.SwitchPosition|null);
+    }
+
+
+    /** Properties of an EncoderEvent. */
+    export interface EncoderEvent {
+
+        /** EncoderEvent delta */
+        delta?: (number|null);
+    }
+
+
+    /** Properties of an InputEvent. */
+    export interface InputEvent {
+
+        /** InputEvent buttonEvent */
+        buttonEvent?: (BSB_Input.ButtonEvent|null);
+
+        /** InputEvent switchEvent */
+        switchEvent?: (BSB_Input.SwitchEvent|null);
+
+        /** InputEvent encoderEvent */
+        encoderEvent?: (BSB_Input.EncoderEvent|null);
+    }
+
+}
+
+/** Namespace BSB_State. */
+export declare namespace BSB_State {
+
+    /** Properties of a StateUpdate. */
+    export interface StateUpdate {
+
+        /** StateUpdate deviceName */
+        deviceName?: (BSB_State.DeviceName|null);
+
+        /** StateUpdate power */
+        power?: (BSB_State.Power|null);
+
+        /** StateUpdate brightness */
+        brightness?: (BSB_State.Brightness|null);
+
+        /** StateUpdate audioVolume */
+        audioVolume?: (BSB_State.AudioVolume|null);
+
+        /** StateUpdate wifi */
+        wifi?: (BSB_State.Wifi|null);
+
+        /** StateUpdate updateState */
+        updateState?: (BSB_Update.UpdateState|null);
+
+        /** StateUpdate updateCheck */
+        updateCheck?: (BSB_Update.CheckState|null);
+
+        /** StateUpdate timezone */
+        timezone?: (BSB_State.Timezone|null);
+
+        /** StateUpdate matter */
+        matter?: (BSB_State.Matter|null);
+
+        /** StateUpdate frame */
+        frame?: (BSB_Frame.Frame|null);
+
+        /** StateUpdate input */
+        input?: (BSB_Input.InputEvent|null);
+
+        /** StateUpdate timer */
+        timer?: (BSB_Timer.Timer|null);
+
+        /** StateUpdate ble */
+        ble?: (BSB_State.Ble.Ble|null);
+
+        /** StateUpdate autoUpdateState */
+        autoUpdateState?: (BSB_Update.AutoUpdateState|null);
+    }
+
+
+    /** Properties of a State. */
+    export interface State {
+
+        /** State timestamp */
+        timestamp?: (number|Long_2|null);
+
+        /** State updates */
+        updates?: (BSB_State.StateUpdate[]|null);
+
+        /** State error */
+        error?: (BSB_Error.Error|null);
+    }
+
+
+    /** Properties of a DeviceName. */
+    export interface DeviceName {
+
+        /** DeviceName name */
+        name?: (string|null);
+    }
+
+
+    /** Properties of a BrightnessAutomatic. */
+    export interface BrightnessAutomatic {
+    }
+
+
+    /** Properties of a BrightnessManual. */
+    export interface BrightnessManual {
+
+        /** BrightnessManual brightness */
+        brightness?: (number|null);
+    }
+
+
+    /** Properties of a Brightness. */
+    export interface Brightness {
+
+        /** Brightness automatic */
+        automatic?: (BSB_State.BrightnessAutomatic|null);
+
+        /** Brightness manual */
+        manual?: (BSB_State.BrightnessManual|null);
+
+        /** Brightness actualBrightness */
+        actualBrightness?: (number|null);
+    }
+
+
+    /** BatteryStatus enum. */
+    export enum BatteryStatus {
+        DISCHARGING = 0,
+        CHARGING = 1,
+        CHARGED = 2
+    }
+
+    /** Properties of an UnknownPowerState. */
+    export interface UnknownPowerState {
+    }
+
+
+    /** Properties of a PowerState. */
+    export interface PowerState {
+
+        /** PowerState batteryStatus */
+        batteryStatus?: (BSB_State.BatteryStatus|null);
+
+        /** PowerState batteryChargePercent */
+        batteryChargePercent?: (number|null);
+
+        /** PowerState batteryVoltageMv */
+        batteryVoltageMv?: (number|null);
+
+        /** PowerState batteryCurrentMa */
+        batteryCurrentMa?: (number|null);
+
+        /** PowerState usbVoltageMv */
+        usbVoltageMv?: (number|null);
+    }
+
+
+    /** Properties of a Power. */
+    export interface Power {
+
+        /** Power unknown */
+        unknown?: (BSB_State.UnknownPowerState|null);
+
+        /** Power known */
+        known?: (BSB_State.PowerState|null);
+    }
+
+
+    /** Properties of an AudioVolume. */
+    export interface AudioVolume {
+
+        /** AudioVolume volume */
+        volume?: (number|null);
+    }
+
+
+    /** WifiConnectionStatus enum. */
+    export enum WifiConnectionStatus {
+        CONNECTED = 0,
+        CONNECTING = 1,
+        DISCONNECTING = 2,
+        RECONNECTING = 3
+    }
+
+    /** WifiSecurity enum. */
+    export enum WifiSecurity {
+        UNKNOWN = 0,
+        OPEN = 1,
+        WPA = 2,
+        WPA2 = 3,
+        WEP = 4,
+        WPA_WPA2 = 5,
+        WPA3 = 6,
+        WPA2_WPA3 = 7
+    }
+
+    /** IpConfigurationMethod enum. */
+    export enum IpConfigurationMethod {
+        DHCP = 0,
+        STATIC = 1
+    }
+
+    /** IpProtocol enum. */
+    export enum IpProtocol {
+        IPV4 = 0,
+        IPV6 = 1
+    }
+
+    /** Properties of a WifiStateUnknown. */
+    export interface WifiStateUnknown {
+    }
+
+
+    /** Properties of a WifiStateDisconnected. */
+    export interface WifiStateDisconnected {
+    }
+
+
+    /** Properties of a WifiStateConnected. */
+    export interface WifiStateConnected {
+
+        /** WifiStateConnected status */
+        status?: (BSB_State.WifiConnectionStatus|null);
+
+        /** WifiStateConnected ssid */
+        ssid?: (string|null);
+
+        /** WifiStateConnected bssid */
+        bssid?: (string|null);
+
+        /** WifiStateConnected channel */
+        channel?: (number|null);
+
+        /** WifiStateConnected rssi */
+        rssi?: (number|null);
+
+        /** WifiStateConnected security */
+        security?: (BSB_State.WifiSecurity|null);
+    }
+
+
+    /** Properties of an IpAddress. */
+    export interface IpAddress {
+
+        /** IpAddress protocol */
+        protocol?: (BSB_State.IpProtocol|null);
+
+        /** IpAddress method */
+        method?: (BSB_State.IpConfigurationMethod|null);
+
+        /** IpAddress address */
+        address?: (string|null);
+
+        /** IpAddress gateway */
+        gateway?: (string|null);
+
+        /** IpAddress netmask */
+        netmask?: (string|null);
+    }
+
+
+    /** Properties of a Wifi. */
+    export interface Wifi {
+
+        /** Wifi unknown */
+        unknown?: (BSB_State.WifiStateUnknown|null);
+
+        /** Wifi disconnected */
+        disconnected?: (BSB_State.WifiStateDisconnected|null);
+
+        /** Wifi connected */
+        connected?: (BSB_State.WifiStateConnected|null);
+
+        /** Wifi ipAddresses */
+        ipAddresses?: (BSB_State.IpAddress[]|null);
+    }
+
+
+    /** Properties of a Timezone. */
+    export interface Timezone {
+
+        /** Timezone name */
+        name?: (string|null);
+
+        /** Timezone offset */
+        offset?: (number|null);
+
+        /** Timezone abbr */
+        abbr?: (string|null);
+    }
+
+
+    /** MatterCommissioningStatus enum. */
+    export enum MatterCommissioningStatus {
+        NEVER_STARTED = 0,
+        STARTED = 1,
+        COMPLETED_SUCCESSFULLY = 2,
+        FAILED = 3
+    }
+
+    /** Properties of a MatterCommissioningState. */
+    export interface MatterCommissioningState {
+
+        /** MatterCommissioningState status */
+        status?: (BSB_State.MatterCommissioningStatus|null);
+
+        /** MatterCommissioningState timestamp */
+        timestamp?: (number|Long_2|null);
+    }
+
+
+    /** Properties of a Matter. */
+    export interface Matter {
+
+        /** Matter fabricCount */
+        fabricCount?: (number|null);
+
+        /** Matter state */
+        state?: (BSB_State.MatterCommissioningState|null);
+    }
+
+
+    /** Namespace Ble. */
+    export namespace Ble {
+
+        /** ServiceStatus enum. */
+        export enum ServiceStatus {
+            RESET = 0,
+            INITIALIZATION = 1,
+            READY = 2,
+            ADVERTISING = 3,
+            CONNECTABLE = 4,
+            CONNECTED = 5,
+            ERROR = 6
+        }
+
+        /** Properties of a Ble. */
+        export interface Ble {
+
+            /** Ble status */
+            status?: (BSB_State.Ble.ServiceStatus|null);
+
+            /** Ble remoteAddress */
+            remoteAddress?: (string|null);
+        }
+
+    }
+}
+
+/** Namespace BSB_Timer. */
+export declare namespace BSB_Timer {
+
+    /** Properties of a Timer. */
+    export interface Timer {
+
+        /** Timer json */
+        json?: (BSB_Util.Json|null);
+    }
+
+}
+
+/** Namespace BSB_Update. */
+export declare namespace BSB_Update {
+
+    /** UpdateEvent enum. */
+    export enum UpdateEvent {
+        SESSION_START = 0,
+        SESSION_STOP = 1,
+        ACTION_BEGIN = 2,
+        ACTION_DONE = 3,
+        DETAIL_CHANGE = 4,
+        ACTION_PROGRESS = 5,
+        EVENT_NONE = 6
+    }
+
+    /** UpdateAction enum. */
+    export enum UpdateAction {
+        DOWNLOAD = 0,
+        SHA_VERIFICATION = 1,
+        UNPACK = 2,
+        INSTALLATION_PREPARE = 3,
+        INSTALLATION_APPLY = 4,
+        ACTION_NONE = 5
+    }
+
+    /** UpdateStatus enum. */
+    export enum UpdateStatus {
+        OK = 0,
+        BATTERY_LOW = 1,
+        BUSY = 2,
+        DOWNLOAD_FAILURE = 3,
+        DOWNLOAD_ABORT = 4,
+        SHA_MISMATCH = 5,
+        UNPACK_CREATE_STAGING_DIRECTORY_FAILURE = 6,
+        UNPACK_ARCHIVE_OPEN_FAILURE = 7,
+        UNPACK_ARCHIVE_UNPACK_FAILURE = 8,
+        INSTALLATION_PREPARE_MANIFEST_NOT_FOUND = 9,
+        INSTALLATION_PREPARE_MANIFEST_INVALID = 10,
+        INSTALLATION_PREPARE_SESSION_CONFIG_SETUP_FAILURE = 11,
+        INSTALLATION_PREPARE_POINTER_SETUP_FAILURE = 12,
+        UNKNOWN_FAILURE = 13
+    }
+
+    /** CheckError enum. */
+    export enum CheckError {
+        NOT_AVAILABLE = 0,
+        FAILURE = 1,
+        IDLE = 2
+    }
+
+    /** Properties of an UpdateAvailable. */
+    export interface UpdateAvailable {
+
+        /** UpdateAvailable version */
+        version?: (string|null);
+    }
+
+
+    /** Properties of an UpdateUnavailable. */
+    export interface UpdateUnavailable {
+
+        /** UpdateUnavailable reason */
+        reason?: (BSB_Update.CheckError|null);
+    }
+
+
+    /** Properties of an UpdateState. */
+    export interface UpdateState {
+
+        /** UpdateState event */
+        event?: (BSB_Update.UpdateEvent|null);
+
+        /** UpdateState action */
+        action?: (BSB_Update.UpdateAction|null);
+
+        /** UpdateState status */
+        status?: (BSB_Update.UpdateStatus|null);
+    }
+
+
+    /** Properties of a CheckState. */
+    export interface CheckState {
+
+        /** CheckState available */
+        available?: (BSB_Update.UpdateAvailable|null);
+
+        /** CheckState unavailable */
+        unavailable?: (BSB_Update.UpdateUnavailable|null);
+    }
+
+
+    /** Properties of an AutoUpdateInterval. */
+    export interface AutoUpdateInterval {
+
+        /** AutoUpdateInterval start */
+        start?: (number|null);
+
+        /** AutoUpdateInterval end */
+        end?: (number|null);
+    }
+
+
+    /** Properties of an AutoUpdateState. */
+    export interface AutoUpdateState {
+
+        /** AutoUpdateState enabled */
+        enabled?: (boolean|null);
+
+        /** AutoUpdateState interval */
+        interval?: (BSB_Update.AutoUpdateInterval|null);
+    }
+
+}
+
+/** Namespace BSB_Util. */
+export declare namespace BSB_Util {
+
+    /** Compression enum. */
+    export enum Compression {
+        PLAIN = 0,
+        GZIP = 1
+    }
+
+    /** Properties of a Json. */
+    export interface Json {
+
+        /** Json compression */
+        compression?: (BSB_Util.Compression|null);
+
+        /** Json data */
+        data?: (Uint8Array|null);
+    }
+
+}
+
 export declare interface BusyBar extends SystemMethods, UpdateMethods, TimeMethods, AccountMethods, DisplayMethods, AudioMethods, WifiMethods, StorageMethods, SettingsMethods, BleMethods, InputMethods, AssetsMethods, SmartHomeMethods {
 }
 
@@ -268,7 +989,7 @@ export declare class BusyBar {
     setToken(token: string): void;
 }
 
-declare type BusyBarClient = Client<paths, `${string}/${string}`>;
+declare type BusyBarClient = Client_2<paths, `${string}/${string}`>;
 
 export declare type BusyBarConfig = {
     addr?: string;
@@ -1118,10 +1839,34 @@ declare interface components {
     pathItems: never;
 }
 
+/**
+ * Detailed WebSocket connection state
+ */
+export declare enum ConnectionStatus {
+    DISCONNECTED = "DISCONNECTED",
+    CONNECTING = "CONNECTING",
+    CONNECTED = "CONNECTED",
+    RECONNECTING = "RECONNECTING"
+}
+
 export declare type CountdownElement = components['schemas']['CountdownElement'];
 
+/**
+ * Callbacks for the main thread
+ */
+export declare type DataCallback = (data: ProcessedState) => void;
+
 declare type DataListener = (data: Uint8Array) => void;
 
+/**
+ * Data throughput state
+ */
+export declare enum DataStatus {
+    NONE = "NONE",
+    ACTIVE = "ACTIVE",
+    STALE = "STALE"
+}
+
 export declare enum DeviceScreen {
     FRONT = 0,
     BACK = 1
@@ -1196,6 +1941,9 @@ declare class DisplayMethods {
 declare type Error_2 = components['schemas']['Error'];
 export { Error_2 as Error }
 
+declare type ErrorCallback_2 = (error: StateStreamError) => void;
+export { ErrorCallback_2 as ErrorCallback }
+
 declare type ErrorListener = (payload: ErrorPayload) => void;
 
 declare interface ErrorPayload {
@@ -1265,6 +2013,58 @@ export declare type KeyName = operations['setInputKey']['parameters']['query']['
 
 export declare type KeyValue = 1 | 0;
 
+export declare const LEDRenderer: LEDRenderer_2;
+
+/**
+ * LEDRenderer - A singleton WebGL2-based engine for rendering pixel grids.
+ */
+declare class LEDRenderer_2 {
+    private static instance;
+    private gl;
+    private program;
+    private texture;
+    private vs;
+    private fs;
+    constructor();
+    /**
+     * Lazily initializes the WebGL context and resources.
+     * Only executes in a browser environment.
+     */
+    private init;
+    /**
+     * Internal WebGL rendering pass.
+     */
+    private render;
+    /**
+     * Public API: Renders the LED frame to a target 2D canvas.
+     */
+    renderFrame(targetCanvas: HTMLCanvasElement, data: Uint8Array | Uint8ClampedArray, width: number, height: number, options?: {
+        pixelSize?: number;
+        radius?: number;
+        darkThreshold?: number;
+    } | undefined): void;
+    private createProgram;
+}
+
+/**
+ * Connection for local BUSY Bar devices via direct IP.
+ * Uses ws:// and binary protobuf protocol.
+ */
+export declare class LocalStateStream extends BaseStateStream {
+    protected streamMode: StreamMode;
+    constructor(options?: LocalStreamOptions, config?: StreamConfig);
+    /**
+     * Normalizes the address to use ws:// protocol and adds default path if missing.
+     */
+    protected normalizeUrl(addr: string): string;
+}
+
+/**
+ * Options for local device connections
+ */
+export declare interface LocalStreamOptions extends StreamOptions {
+}
+
 export declare type NameInfo = components['schemas']['NameInfo'];
 
 export declare interface NameParams extends TimeoutOptions, NameInfo {
@@ -4489,6 +5289,89 @@ declare interface paths {
     };
 }
 
+/**
+ * Helper to force TypeScript to expand complex types in tooltips.
+ * It maps over each property and "flattens" the type.
+ */
+declare type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+/**
+ * Frame with RGBA support after worker processing
+ */
+export declare type ProcessedFrame = Prettify<Omit<BSB_Frame.Frame, 'data'> & {
+    data?: Uint8Array | Uint8ClampedArray | null;
+}>;
+
+/**
+ * Protobuf State with processed updates.
+ */
+export declare type ProcessedSchemaState = Prettify<Omit<BSB_State.State, 'updates'> & {
+    updates?: ProcessedUpdate[] | null;
+}>;
+
+/**
+ * Final state structure passed to callers.
+ */
+export declare type ProcessedState = Prettify<ProcessedSchemaState & {
+    bar_id?: string;
+}>;
+
+/**
+ * StateUpdate with an optional 'state' key identifying the active module.
+ * Also uses our ProcessedFrame for the 'frame' field.
+ */
+export declare type ProcessedUpdate = Prettify<Omit<BSB_State.StateUpdate, 'frame'> & {
+    state?: StateUpdateKey;
+    frame?: ProcessedFrame | null;
+}>;
+
+export declare type RawDataCallback = (data: Uint8Array | string) => void;
+
+/**
+ * Wrapped structure for Remote mode
+ */
+export declare type RemoteState = Prettify<{
+    bar_id: string;
+    state: ProcessedSchemaState;
+}>;
+
+/**
+ * Connection for remote BUSY Bar devices via Remote.
+ * Uses wss:// and provides subscription management.
+ */
+export declare class RemoteStateStream extends BaseStateStream {
+    protected streamMode: StreamMode;
+    private tokenProvider?;
+    constructor(options: RemoteStreamOptions, config?: StreamConfig);
+    /**
+     * Subscribes to updates for a specific device GUID.
+     */
+    subscribe(guid: string): void;
+    /**
+     * Unsubscribes from updates for a specific device GUID.
+     */
+    unsubscribe(guid: string): void;
+    /**
+     * Standardizes the address to use wss:// or ws:// protocol.
+     */
+    protected normalizeUrl(addr: string): string;
+    /**
+     * Handles token expiration by invoking the tokenProvider.
+     * Returns the promise for deduplication.
+     */
+    protected onTokenExpired(): Promise<string> | void;
+}
+
+/**
+ * Options for remote connections
+ */
+export declare interface RemoteStreamOptions extends StreamOptions {
+    addr: string;
+    tokenProvider?: () => Promise<string>;
+}
+
 declare type RequiredIpConfig = RequireKeys<NonNullable<WifiConnectRequestConfig['ip_config']>, 'ip_method'>;
 
 declare type RequireKeys<T, K extends keyof T> = Required<Pick<T, K>> & Omit<T, K>;
@@ -4627,8 +5510,50 @@ export declare type SmartHomePairingPayload = components['schemas']['SmartHomePa
 
 export declare type SmartHomeSwitchState = components['schemas']['SmartHomeSwitchState'];
 
+/**
+ * Custom error class for StateStream with machine-readable codes
+ */
+export declare class StateStreamError extends Error {
+    readonly code: StateStreamErrorCode;
+    readonly data?: any | undefined;
+    constructor(code: StateStreamErrorCode, message: string, data?: any | undefined);
+}
+
+/**
+ * Error codes for StateStream
+ */
+export declare enum StateStreamErrorCode {
+    CONNECTION_FAILED = "CONNECTION_FAILED",
+    RECONNECT_FAILED = "RECONNECT_FAILED",
+    CONNECTION_LOST = "CONNECTION_LOST",
+    CONNECTION_TIMEOUT = "CONNECTION_TIMEOUT",
+    AUTH_FAILED = "AUTH_FAILED",
+    AUTH_REFRESH_FAILED = "AUTH_REFRESH_FAILED",
+    DEVICE_ERROR = "DEVICE_ERROR",
+    DECODE_ERROR = "DECODE_ERROR",
+    FRAME_PROCESS_ERROR = "FRAME_PROCESS_ERROR",
+    STREAM_ALREADY_STARTED = "STREAM_ALREADY_STARTED",
+    WORKER_INIT_FAILED = "WORKER_INIT_FAILED",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+
+/**
+ * All possible keys in BSB_State.StateUpdate, automatically inferred from the schema.
+ */
+export declare type StateUpdateKey = keyof BSB_State.StateUpdate & string;
+
 export declare type Status = components['schemas']['Status'];
 
+export declare type StatusCallback = (status: StreamStatus) => void;
+
+/**
+ * Generic container for status and error, reused across components
+ */
+export declare interface StatusComponent<E> {
+    status: E;
+    lastError?: StateStreamError;
+}
+
 export declare type StatusDevice = components['schemas']['StatusDevice'];
 
 export declare type StatusFirmware = components['schemas']['StatusFirmware'];
@@ -4751,6 +5676,54 @@ export declare interface StorageUploadFileParams extends TimeoutOptions, Storage
 
 declare type StorageWriteQuery = operations['writeStorageFile']['parameters']['query'];
 
+/**
+ * Global configuration for the stream behavior
+ */
+export declare interface StreamConfig {
+    /** Connection timeout in milliseconds. Default: 5000ms */
+    timeout?: number;
+    /** Data inactivity timeout in milliseconds. Default: 15000ms */
+    dataTimeout?: number;
+}
+
+/**
+ * High-level lifecycle of the StateStream class instance
+ */
+export declare enum StreamLifecycle {
+    IDLE = "IDLE",
+    STARTING = "STARTING",
+    RUNNING = "RUNNING",
+    STOPPED = "STOPPED",
+    FAILED = "FAILED"
+}
+
+/**
+ * Generic container for status and error, reused across components
+ */
+declare type StreamMode = 'local' | 'remote';
+
+/**
+ * Base internal options for connections
+ */
+declare interface StreamOptions {
+    addr?: string;
+    token?: string;
+    isBinary?: boolean;
+}
+
+/**
+ * The unified StateStream status object
+ */
+export declare interface StreamStatus {
+    main: StatusComponent<StreamLifecycle>;
+    connection: StatusComponent<ConnectionStatus>;
+    auth: StatusComponent<AuthStatus>;
+    data: StatusComponent<DataStatus> & {
+        lastActivity?: number;
+    };
+    worker: StatusComponent<WorkerStatus>;
+}
+
 export declare type SuccessResponse = components['schemas']['SuccessResponse'];
 
 declare class SystemMethods {
@@ -5022,4 +5995,63 @@ export declare type WifiSecurityMethod = components['schemas']['WifiSecurityMeth
 
 export declare type WifiStatusResponse = components['schemas']['StatusResponse'];
 
+/**
+ * Worker Commands (Sent from main thread to worker)
+ */
+declare type WorkerCommand = {
+    type: 'START';
+    addr: string;
+    token?: string;
+    isBinary: boolean;
+    mode: StreamMode;
+} | {
+    type: 'STOP';
+} | {
+    type: 'UPDATE_TOKEN';
+    token: string;
+} | {
+    type: 'SUBSCRIBE';
+    guid: string;
+} | {
+    type: 'UNSUBSCRIBE';
+    guid: string;
+};
+
+/**
+ * Worker Events (Sent from worker to main thread)
+ */
+declare type WorkerEvent = {
+    type: 'CONNECTED';
+} | {
+    type: 'DISCONNECTED';
+} | {
+    type: 'TOKEN_EXPIRED';
+} | {
+    type: 'ERROR';
+    code: StateStreamErrorCode;
+    message: string;
+    data?: any;
+} | {
+    type: 'RAW_DATA';
+    data: Uint8Array | string;
+} | {
+    type: 'DATA';
+    data: ProcessedSchemaState | RemoteState;
+} | {
+    type: 'STATUS_UPDATE';
+    connection?: ConnectionStatus;
+    auth?: AuthStatus;
+    worker?: WorkerStatus;
+};
+
+/**
+ * Internal Worker/Infrastructure state
+ */
+export declare enum WorkerStatus {
+    OFF = "OFF",
+    INITIALIZING = "INITIALIZING",
+    READY = "READY",
+    ERROR = "ERROR"
+}
+
 export { }