@busy-app/busy-lib 0.11.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'];
 
@@ -18,9 +19,9 @@ declare class AccountMethods {
      *
      * @param {TimeoutOptions} [params] - Optional parameters.
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
-     * @returns {Promise<AccountState>} A promise that resolves to the account state.
+     * @returns {Promise<AccountStatus>} A promise that resolves to the account state.
      */
-    AccountStateGet(this: BusyBar, params?: TimeoutOptions): Promise<AccountState>;
+    AccountStateGet(this: BusyBar, params?: TimeoutOptions): Promise<AccountStatus>;
     /**
      * Get account profile.
      *
@@ -33,7 +34,8 @@ declare class AccountMethods {
      * Set account profile.
      *
      * @param {SetAccountProfileParams} params - Parameters for setting the account profile.
-     *   @param {string} params.profile - Profile data string.
+     *   @param {string} params.profile - Profile name.
+     *   @param {string} [params.custom_url] - Custom profile URL.
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<SuccessResponse>} A promise that resolves on success.
      */
@@ -58,29 +60,31 @@ declare class AccountMethods {
 
 export declare type AccountProfile = components['schemas']['AccountProfile'];
 
-export declare interface AccountProfileSetParams extends TimeoutOptions {
-    profile: operations['setAccountProfile']['parameters']['query']['profile'];
+export declare interface AccountProfileSetParams extends TimeoutOptions, AccountProfile {
 }
 
-export declare type AccountState = components['schemas']['AccountState'];
+export declare type AccountStatus = components['schemas']['AccountStatus'];
+
+export declare type AnimationElement = components['schemas']['AnimationElement'];
 
 declare type ApiKey = string;
 
 declare type ApiSemver = components['schemas']['VersionInfo']['api_semver'];
 
-export declare interface AssetsDeleteParams extends TimeoutOptions {
-    appId: paths['/assets/upload']['delete']['parameters']['query']['app_id'];
+export declare interface AssetsDeleteParams extends TimeoutOptions, AssetsDeleteQuery {
 }
 
+declare type AssetsDeleteQuery = operations['deleteAppAssets']['parameters']['query'];
+
 declare class AssetsMethods {
     /**
      * Upload asset file with app ID. Uploads a file to a specific app's assets directory.
      *
      * @param {UploadParams} params - Parameters for the upload.
-     *   @param {UploadParams['appId']} params.appId - Application ID for organizing assets.
-     *   @param {UploadParams['fileName']} params.fileName - Filename for the uploaded asset.
-     *   @param {UploadParams['file']} params.file - File data to upload.
-     *   @param {UploadParams['timeout']} [params.timeout] - Request timeout in milliseconds.
+     *   @param {string} params.application_name - Application name for organizing assets.
+     *   @param {string} params.file - Filename for the uploaded asset.
+     *   @param {BusyFile} params.data - File data to upload.
+     *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<SuccessResponse>} Result of the upload operation.
      */
     AssetsUpload(this: BusyBar, params: AssetsUploadParams): Promise<SuccessResponse>;
@@ -88,25 +92,25 @@ declare class AssetsMethods {
      * Delete app assets. Deletes all assets for a specific app ID.
      *
      * @param {DeleteParams} params - Parameters for the delete.
-     *   @param {DeleteParams['appId']} params.appId - Application ID whose assets should be deleted.
-     *   @param {DeleteParams['timeout']} [params.timeout] - Request timeout in milliseconds.
+     *   @param {string} params.application_name - Application name whose assets should be deleted.
+     *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<SuccessResponse>} Result of the delete operation.
      */
     AssetsDelete(this: BusyBar, params: AssetsDeleteParams): Promise<SuccessResponse>;
 }
 
-export declare interface AssetsUploadParams extends TimeoutOptions {
-    appId: paths['/assets/upload']['post']['parameters']['query']['app_id'];
-    fileName: paths['/assets/upload']['post']['parameters']['query']['file'];
-    file: BusyFile;
+export declare interface AssetsUploadParams extends TimeoutOptions, AssetsUploadQuery {
+    data: BusyFile_2;
 }
 
+declare type AssetsUploadQuery = operations['uploadAssetWithAppId']['parameters']['query'];
+
 declare class AudioMethods {
     /**
      * Play audio file. Plays a file from internal storage.
      *
      * @param {AudioPlayParams} params - Parameters for audio playback.
-     *   @param {string} params.appId - Application ID.
+     *   @param {string} params.application_name - Application name.
      *   @param {string} params.path - Path to the audio file.
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<SuccessResponse>} A promise that resolves on successful play command.
@@ -139,19 +143,129 @@ declare class AudioMethods {
     AudioVolumeSet(this: BusyBar, params: AudioVolumeParams): Promise<SuccessResponse>;
 }
 
-export declare interface AudioPlayParams extends TimeoutOptions {
-    appId: paths['/audio/play']['post']['parameters']['query']['app_id'];
-    path: paths['/audio/play']['post']['parameters']['query']['path'];
+export declare interface AudioPlayParams extends TimeoutOptions, AudioPlayQuery {
 }
 
+declare type AudioPlayQuery = operations['playAudio']['parameters']['query'];
+
 export declare type AudioVolumeInfo = components['schemas']['AudioVolumeInfo'];
 
-export declare interface AudioVolumeParams extends TimeoutOptions {
-    volume: operations['setAudioVolume']['parameters']['query']['volume'];
+export declare interface AudioVolumeParams extends TimeoutOptions, AudioVolumeQuery {
+}
+
+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.
@@ -191,7 +305,618 @@ export declare type BleStatusResponse = components['schemas']['BleStatusResponse
 
 declare type Brightness = number | 'auto';
 
-export declare interface BusyBar extends SystemMethods, UpdateMethods, TimeMethods, AccountMethods, DisplayMethods, AudioMethods, WifiMethods, StorageMethods, SettingsMethods, BleMethods, InputMethods, AssetsMethods, MatterMethods {
+/** 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 {
 }
 
 /**
@@ -264,16 +989,18 @@ 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;
     token?: string;
 };
 
-declare type BusyFile = Buffer | Blob | File | ArrayBuffer;
+export declare type BusyFile = Buffer | Blob | File | ArrayBuffer;
 
-declare type CamelizedRequest = DeepCamelize<components['schemas']['ConnectRequestConfig']>;
+declare type BusyFile_2 = Buffer | Blob | File | ArrayBuffer;
+
+declare type ClearDisplayQuery = NonNullable<operations['clearDisplay']['parameters']['query']>;
 
 declare interface components {
     schemas: {
@@ -476,7 +1203,7 @@ declare interface components {
             file: string;
         };
         /** @example {
-         *       "app_id": "my_app",
+         *       "application_name": "my_app",
          *       "elements": [
          *         {
          *           "id": "0",
@@ -520,14 +1247,14 @@ declare interface components {
              * @description Application ID for organizing assets
              * @example my_app
              */
-            app_id: string;
+            application_name: string;
             /**
-             * @description Draw requests with a lower priority than the currently active draw request will be ignored. Value is 1 through 10, inclusive, higher number means higher priority. Any built-in app is treated as priority level 5.
-             * @default 6
+             * @description Draw priority in the range [1, 100] inclusive. A draw request is accepted when its priority is greater than or equal to (>=) the priority of the currently running system app. Equal-priority requests from a different application_name override whatever is on screen. System app priority levels: stub/poweroff apps = 0 (always preemptable), any standard built-in app = 10, active BUSY/CUSTOM work session = 90. The draw API only accepts values 1–100; 0 is reserved for internal use.
+             * @default 50
              */
             priority: number;
             /** @description Array of elements to display */
-            elements: (components['schemas']['TextElement'] | components['schemas']['ImageElement'] | components['schemas']['AnimElement'] | components['schemas']['CountdownElement'])[];
+            elements: (components['schemas']['TextElement'] | components['schemas']['ImageElement'] | components['schemas']['AnimationElement'] | components['schemas']['CountdownElement'])[];
         };
         DisplayElement: {
             /** @description Unique identifier for the element */
@@ -540,11 +1267,17 @@ declare interface components {
              * @description Type of display element
              * @enum {string}
              */
-            type: 'text' | 'image' | 'anim' | 'countdown';
-            /** @description X coordinate of selected anchor point relative to top-left of display */
-            x?: number;
-            /** @description Y coordinate of selected anchor point relative to top-left of display */
-            y?: number;
+            type: 'text' | 'image' | 'animation' | 'countdown';
+            /**
+             * @description X coordinate of selected anchor point relative to top-left of display
+             * @default 0
+             */
+            x: number;
+            /**
+             * @description Y coordinate of selected anchor point relative to top-left of display
+             * @default 0
+             */
+            y: number;
             /**
              * @description Which display to show the element on (for dual-display devices)
              * @default front
@@ -562,7 +1295,6 @@ declare interface components {
             text: string;
             /**
              * @description One of the available fonts to display the text in
-             * @default tiny5_8
              * @enum {string}
              */
             font: 'small' | 'medium' | 'medium_condensed' | 'big';
@@ -584,10 +1316,10 @@ declare interface components {
         };
         ImageElement: Omit<components['schemas']['DisplayElement'], 'type'> & ({
             /** @description Path to the image file in the app's assets */
-            path?: string;
+            path: string;
         } | {
-            /** @description Identifier of builtin image */
-            builtin_image?: string;
+            /** @description Stock image file name */
+            stock_path: string;
         }) & {
             /**
              * @description discriminator enum property added by openapi-typescript
@@ -595,12 +1327,12 @@ declare interface components {
              */
             type: 'image';
         };
-        AnimElement: Omit<components['schemas']['DisplayElement'], 'type'> & (({
+        AnimationElement: Omit<components['schemas']['DisplayElement'], 'type'> & (({
             /** @description Path to the animation file in the app's assets */
             path?: string;
         } | {
-            /** @description Identifier of builtin animation */
-            builtin_anim?: string;
+            /** @description Stock animation file name */
+            stock_path?: string;
         }) & {
             /**
              * @description Whether to loop the requested part of the animation
@@ -612,14 +1344,14 @@ declare interface components {
              * @default false
              */
             await_previous_end: boolean;
-            /** @description Name of the section to play back. Specifying \"default\" selects the entire animation. */
-            section_name?: string;
+            /** @description Name of the section to play back. Specifying "default" selects the entire animation. */
+            section?: string;
         }) & {
             /**
              * @description discriminator enum property added by openapi-typescript
              * @enum {string}
              */
-            type: 'anim';
+            type: 'animation';
         };
         CountdownElement: Omit<components['schemas']['DisplayElement'], 'type'> & {
             /** @description Seconds-based Unix UTC timestamp to count down or up to. Note: it's a number in a string. */
@@ -669,10 +1401,20 @@ declare interface components {
         };
         TimezoneInfo: {
             /**
-             * @description Timezone name
-             * @example Berlin
+             * @description Time zone name
+             * @example Bangalore
              */
-            timezone: string;
+            name: string;
+            /**
+             * @description Time zone offset from UTC
+             * @example +05:30
+             */
+            offset: string;
+            /**
+             * @description Time zone abbreviation
+             * @example IST
+             */
+            abbr: string;
         };
         Status: {
             device?: components['schemas']['StatusDevice'];
@@ -798,7 +1540,7 @@ declare interface components {
          * @example WPA3
          * @enum {string}
          */
-        WifiSecurityMethod: 'Open' | 'WPA' | 'WPA2' | 'WEP' | 'WPA/WPA2' | 'WPA3' | 'WPA2/WPA3';
+        WifiSecurityMethod: 'Open' | 'WPA' | 'WPA2' | 'WEP' | 'WPA/WPA2' | 'WPA3' | 'WPA2/WPA3' | 'Unsupported';
         /**
          * @example dhcp
          * @enum {string}
@@ -816,21 +1558,38 @@ declare interface components {
             /** @example 58 */
             rssi?: number;
         };
+        /** @description Wi-Fi status. Only `state` is always present.
+         *     Fields `ssid`, `bssid`, `channel`, `rssi`, `security`, and `ip_config` are only included when state is "connected".
+         *      */
         StatusResponse: {
             /**
              * @example disconnected
              * @enum {string}
              */
-            state?: 'unknown' | 'disconnected' | 'connected' | 'connecting' | 'disconnecting' | 'reconnecting';
-            /** @example Your_WIFI_SSID */
+            state: 'unknown' | 'disconnected' | 'connected' | 'connecting' | 'disconnecting' | 'reconnecting';
+            /**
+             * @description Only present when connected
+             * @example Your_WIFI_SSID
+             */
             ssid?: string;
-            /** @example EC:5A:00:0B:55:1D */
+            /**
+             * @description Only present when connected
+             * @example EC:5A:00:0B:55:1D
+             */
             bssid?: string;
-            /** @example 3 */
+            /**
+             * @description Only present when connected
+             * @example 3
+             */
             channel?: number;
-            /** @example -43 */
+            /**
+             * @description Only present when connected
+             * @example -43
+             */
             rssi?: number;
+            /** @description Only present when connected */
             security?: components['schemas']['WifiSecurityMethod'];
+            /** @description Only present when connected */
             ip_config?: {
                 ip_method?: components['schemas']['WifiIpMethod'];
                 ip_type?: components['schemas']['WifiIpType'];
@@ -879,20 +1638,23 @@ declare interface components {
             /** @example 12345678-9abc-def0-1234-56789abcdef0 */
             user_id?: string;
         };
-        AccountState: {
+        AccountStatus: {
             /**
              * @example connected
              * @enum {string}
              */
-            state?: 'error' | 'disconnected' | 'connected';
+            status?: 'error' | 'disconnected' | 'connected';
         };
         AccountProfile: {
             /**
              * @example dev
              * @enum {string}
              */
-            state?: 'dev' | 'prod' | 'local' | 'custom';
-            /** @example mqtts://mqtt.example.com:8883 */
+            profile: 'dev' | 'prod' | 'local' | 'custom';
+            /**
+             * @description Only present when profile is "custom"
+             * @example mqtts://mqtt.example.com:8883
+             */
             custom_url?: string;
         };
         AccountLink: {
@@ -906,18 +1668,17 @@ declare interface components {
              * @example connected
              * @enum {string}
              */
-            state?: 'reset' | 'initialization' | 'disabled' | 'enabled' | 'connected' | 'internal error';
-            /** @example 50:DA:D6:FE:DD:A9 */
-            address?: string;
+            status: 'reset' | 'initialization' | 'disabled' | 'enabled' | 'connectable' | 'connected' | 'internal error';
             /**
-             * @example paired
-             * @enum {string}
+             * @description Remote device address. Only present when status is "connected".
+             * @example 50:DA:D6:FE:DD:A9
              */
-            pairing?: 'unknown' | 'not paired' | 'paired';
+            address?: string;
         };
         BusySnapshot: {
-            snapshot: components['schemas']['BusySnapshotNotStarted'] | components['schemas']['BusySnapshotInfinite'] | components['schemas']['BusySnapshotSimple'] | components['schemas']['BusySnapshotInterval'];
-            busy_bar_settings: components['schemas']['BusyBarSettings'];
+            snapshot: (components['schemas']['BusySnapshotNotStarted'] | components['schemas']['BusySnapshotInfinite'] | components['schemas']['BusySnapshotSimple'] | components['schemas']['BusySnapshotInterval']) & {
+                busy_bar_settings: components['schemas']['BusyBarSettings'];
+            };
             /** @example 1761582532251 */
             snapshot_timestamp_ms: number;
         };
@@ -1018,75 +1779,54 @@ declare interface components {
             trigger_smart_home: boolean;
         };
         TimezoneListResponse: {
-            list?: {
-                /**
-                 * @description Time zone name
-                 * @example Bangalore
-                 */
-                name?: string;
-                /**
-                 * @description Time zone offset from UTC
-                 * @example +05:30
-                 */
-                offset?: string;
-                /**
-                 * @description Time zone abbreviation
-                 * @example IST
-                 */
-                abbr?: string;
-            }[];
+            list?: components['schemas']['TimezoneInfo'][];
         };
-        MatterCommissionedFabrics: {
+        SmartHomePairingInfo: {
             /**
-             * @description Number of Matter smart homes ("fabrics") that this device is linked with ("commissioned into")
+             * @description Number of smart homes (Matter "fabrics") that this device is paired with ("commissioned into")
              * @example 1
              */
             fabric_count?: number;
-            latest_commissioning_status?: {
+            latest_pairing_status?: {
                 /**
-                 * @description Latest state of Matter smart home linking ("commissioning") process. Note: "never_started" only refers to the current power cycle of the device; this status is not recorded across reboots.
+                 * @description Latest state of smart home pairing (Matter "commissioning") process. Note: "never_started" only refers to the current power cycle of the device; this status is not recorded across reboots.
                  * @example completed_successfully
                  * @enum {string}
                  */
                 value?: 'never_started' | 'started' | 'completed_successfully' | 'failed';
                 /**
-                 * @description UTC Unix millisecond timestamp of latest state update. Note: it's a number in a string.
-                 * @example 1769436711000
+                 * @description UTC Unix second timestamp of latest state update. Only present when a status update has occurred.
+                 * @example 1769436711
                  */
-                timestamp?: string;
+                timestamp?: number;
             };
         };
-        MatterCommissioningPayload: {
+        /** @description Set of information for pairing with a Matter smart home */
+        SmartHomePairingPayload: {
             /**
-             * @description Linking with ("commissioning into") a Matter smart home using the provided payload is possible before this UTC Unix millisecond timestamp. Note: it's a number in a string.
+             * @description Pairing with ("commissioning into") a Matter smart home using the provided payload is possible before this UTC Unix millisecond timestamp. Note: it's a number in a string.
              * @example 1769437579000
              */
             available_until?: string;
             /**
-             * @description Payload of the QR code for linking with ("commissioning into") a Matter smart home
+             * @description Payload of the QR code for pairing with ("commissioning into") a smart home
              * @example MT:YNDA0-O913..VV7I000
              */
             qr_code?: string;
             /**
-             * @description Manual code for linking with ("commissioning into") a Matter smart home
+             * @description Manual code for pairing with ("commissioning into") a smart home
              * @example 1155-360-0377
              */
-            manual_code?: string;
-        };
-        MatterEndpointState: {
-            /**
-             * @description Type of device emulated by a Matter endpoint. Currently only "switch" is implemented.
-             * @example switch
-             * @enum {string}
-             */
-            type?: 'switch';
+            manual_code?: string;
+        };
+        SmartHomeSwitchState: {
             /**
-             * @description State of device emulated by a Matter endpoint. Boolean for "switch" device type.
+             * @description State of emulated switch.
              * @example false
              */
             state?: boolean;
             /**
-             * @description For the "switch" device type, specifies the value on startup. Never sent by the server, but can be specified by the client.
+             * @description State of emulated switch on startup. Never sent by the server, but can be specified by the client.
              * @enum {string}
              */
             startup?: 'off' | 'on' | 'toggle' | 'last';
@@ -1099,11 +1839,33 @@ 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;
 
-declare type DeepCamelize<T> = T extends (...args: any[]) => any ? T : T extends Array<infer U> ? Array<DeepCamelize<U>> : T extends object ? {
-    [K in keyof T as SnakeToCamel<K & string>]: DeepCamelize<T[K]>;
-} : T;
+/**
+ * Data throughput state
+ */
+export declare enum DataStatus {
+    NONE = "NONE",
+    ACTIVE = "ACTIVE",
+    STALE = "STALE"
+}
 
 export declare enum DeviceScreen {
     FRONT = 0,
@@ -1113,41 +1875,46 @@ export declare enum DeviceScreen {
 export declare type DisplayBrightnessInfo = components['schemas']['DisplayBrightnessInfo'];
 
 export declare interface DisplayBrightnessParams extends TimeoutOptions {
-    value?: Brightness;
+    value: Brightness;
+}
+
+export declare interface DisplayClearParams extends TimeoutOptions, Partial<ClearDisplayQuery> {
 }
 
-export declare interface DisplayDrawParams extends TimeoutOptions {
-    appId: components['schemas']['DisplayElements']['app_id'];
-    elements: components['schemas']['DisplayElements']['elements'];
-    /** @default 6 */
-    priority?: components['schemas']['DisplayElements']['priority'];
+export declare interface DisplayDrawParams extends TimeoutOptions, DisplayElements {
 }
 
+export declare type DisplayElement = components['schemas']['DisplayElement'];
+
+export declare type DisplayElements = components['schemas']['DisplayElements'];
+
 declare class DisplayMethods {
     /**
-     * Draw on display. Starts the Canvas application if not running.
+     * Draw on display. Sends drawing data to the display. Supports JSON-defined display elements.
      *
      * @param {DrawParams} params - Parameters for the draw operation.
-     *   @param {DrawParams['appId']} params.appId - Application ID.
-     *   @param {DrawParams['elements']} params.elements - Display elements to draw.
-     *   @param {DrawParams['priority']} [params.priority=6] - Priority for the draw request (1-10).
+     *   @param {string} params.application_name - Application ID for organizing assets.
+     *   @param {Array} params.elements - Display elements to draw.
+     *   @param {number} [params.priority=50] - Draw priority in the range [1, 100].
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<SuccessResponse>} A promise that resolves on successful draw command.
      */
     DisplayDraw(this: BusyBar, params: DisplayDrawParams): Promise<SuccessResponse>;
     /**
-     * Clear display. Clears the display and stops the Canvas application if running.
+     * Clear display. Deletes display elements drawn by the Canvas application.
+     * If application_name is specified, only elements for that app are removed.
      *
-     * @param {TimeoutOptions} [params] - Optional parameters.
+     * @param {ClearParams} [params] - Optional parameters.
+     *   @param {string} [params.application_name] - Application identifier.
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<SuccessResponse>} A promise that resolves on successful clear command.
      */
-    DisplayClear(this: BusyBar, params?: TimeoutOptions): Promise<SuccessResponse>;
+    DisplayClear(this: BusyBar, params?: DisplayClearParams): Promise<SuccessResponse>;
     /**
      * Get single frame for requested screen.
      *
      * @param {GetScreenFrameParams} params - Parameters for the frame request.
-     *   @param {string} params.display - Display identifier.
+     *   @param {number} params.display - Type of the display (Front = 0, Back = 1).
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<Blob>} A promise that resolves to the screen frame as a Blob.
      */
@@ -1163,8 +1930,8 @@ declare class DisplayMethods {
     /**
      * Set display brightness.
      *
-     * @param {BrightnessParams} params - Brightness parameters:
-     *   @param {BrightnessParams['value']} [params.value] - Brightness (0-100 or "auto").
+     * @param {BrightnessParams} params - Brightness parameters.
+     *   @param {number | 'auto'} params.value - Brightness (0-100 or "auto").
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<SuccessResponse>} A promise that resolves on success.
      */
@@ -1174,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 {
@@ -1184,11 +1954,13 @@ declare interface ErrorPayload {
 
 export declare type HttpAccessInfo = components['schemas']['HttpAccessInfo'];
 
-export declare interface HttpAccessParams extends TimeoutOptions {
-    mode: operations['setHttpAccess']['parameters']['query']['mode'];
-    key: operations['setHttpAccess']['parameters']['query']['key'];
+export declare interface HttpAccessParams extends TimeoutOptions, HttpAccessQuery {
 }
 
+declare type HttpAccessQuery = operations['setHttpAccess']['parameters']['query'];
+
+export declare type ImageElement = components['schemas']['ImageElement'];
+
 export declare class Input {
     readonly addr: string;
     connected: boolean;
@@ -1220,16 +1992,17 @@ export declare interface InputConfig {
     apiSemver?: ApiSemver;
 }
 
-export declare interface InputKeyParams extends TimeoutOptions {
-    keyName: KeyName;
+export declare interface InputKeyParams extends TimeoutOptions, InputKeyQuery {
 }
 
+declare type InputKeyQuery = operations['setInputKey']['parameters']['query'];
+
 declare class InputMethods {
     /**
      * Send input event. Send single key press event.
      *
      * @param {InputKeyParams} params - Button press parameters:
-     *   @param {KeyName} params.keyName - Name of the key to press.
+     *   @param {KeyName} params.key - Key name.
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<SuccessResponse>} A promise that resolves on success.
      */
@@ -1240,41 +2013,61 @@ export declare type KeyName = operations['setInputKey']['parameters']['query']['
 
 export declare type KeyValue = 1 | 0;
 
-declare class MatterMethods {
+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();
     /**
-     * Get Matter status.
-     *
-     * @param {TimeoutOptions} [params] - Optional parameters.
-     *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
-     * @returns {Promise<MatterStatus>} A promise that resolves to the Matter status.
+     * Lazily initializes the WebGL context and resources.
+     * Only executes in a browser environment.
      */
-    MatterStatusGet(this: BusyBar, params?: TimeoutOptions): Promise<MatterStatus>;
+    private init;
     /**
-     * Pair Matter device.
-     *
-     * @param {TimeoutOptions} [params] - Optional parameters.
-     *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
-     * @returns {Promise<MatterPairingInfo>} A promise that resolves on success.
+     * Internal WebGL rendering pass.
      */
-    MatterPair(this: BusyBar, params?: TimeoutOptions): Promise<MatterPairingInfo>;
+    private render;
     /**
-     * Erase Matter devices.
-     *
-     * @param {TimeoutOptions} [params] - Optional parameters.
-     *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
-     * @returns {Promise<SuccessResponse>} A promise that resolves on success.
+     * Public API: Renders the LED frame to a target 2D canvas.
      */
-    MatterErase(this: BusyBar, params?: TimeoutOptions): Promise<SuccessResponse>;
+    renderFrame(targetCanvas: HTMLCanvasElement, data: Uint8Array | Uint8ClampedArray, width: number, height: number, options?: {
+        pixelSize?: number;
+        radius?: number;
+        darkThreshold?: number;
+    } | undefined): void;
+    private createProgram;
 }
 
-export declare type MatterPairingInfo = components['schemas']['MatterCommissioningPayload'];
+/**
+ * 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;
+}
 
-export declare type MatterStatus = components['schemas']['MatterCommissionedFabrics'];
+/**
+ * Options for local device connections
+ */
+export declare interface LocalStreamOptions extends StreamOptions {
+}
 
 export declare type NameInfo = components['schemas']['NameInfo'];
 
-export declare interface NameParams extends TimeoutOptions {
-    name: NameInfo['name'];
+export declare interface NameParams extends TimeoutOptions, NameInfo {
 }
 
 declare interface operations {
@@ -1336,10 +2129,10 @@ declare interface operations {
                  */
                 mode: 'disabled' | 'enabled' | 'key';
                 /**
-                 * @description Access key (4-10 digits length)
+                 * @description Access key (4-10 digits length). Required when mode is "key".
                  * @example 12345678
                  */
-                key: string;
+                key?: string;
             };
             header?: never;
             path?: never;
@@ -1674,7 +2467,7 @@ declare interface operations {
                  * @description Application ID for organizing assets
                  * @example my_app
                  */
-                app_id: string;
+                application_name: string;
                 /**
                  * @description Filename for the uploaded asset
                  * @example data.png
@@ -1727,7 +2520,7 @@ declare interface operations {
                  * @description Application ID whose assets should be deleted
                  * @example my_app
                  */
-                app_id: string;
+                application_name: string;
             };
             header?: never;
             path?: never;
@@ -2061,8 +2854,8 @@ declare interface operations {
                     'application/json': components['schemas']['Error'];
                 };
             };
-            /** @description Display error */
-            500: {
+            /** @description Failed to load canvas app */
+            503: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -2079,7 +2872,7 @@ declare interface operations {
                  * @description Application identifier
                  * @example my_app
                  */
-                app_id?: string;
+                application_name?: string;
             };
             header?: never;
             path?: never;
@@ -2096,15 +2889,6 @@ declare interface operations {
                     'application/json': components['schemas']['SuccessResponse'];
                 };
             };
-            /** @description Display error */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    'application/json': components['schemas']['Error'];
-                };
-            };
         };
     };
     getDisplayBrightness: {
@@ -2129,12 +2913,12 @@ declare interface operations {
     };
     setDisplayBrightness: {
         parameters: {
-            query?: {
+            query: {
                 /**
                  * @description Displays brightness (0-100/auto)
                  * @example 50
                  */
-                value?: string;
+                value: string;
             };
             header?: never;
             path?: never;
@@ -2169,7 +2953,7 @@ declare interface operations {
                  * @description Application ID for organizing assets
                  * @example my_app
                  */
-                app_id: string;
+                application_name: string;
                 /**
                  * @description Path to audio file within app's assets directory
                  * @example data.snd
@@ -2538,7 +3322,7 @@ declare interface operations {
             };
         };
     };
-    getTime: {
+    connectScreenWebSocket: {
         parameters: {
             query?: never;
             header?: never;
@@ -2547,16 +3331,14 @@ declare interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description Timestamp retrieved successfully */
-            200: {
+            /** @description WebSocket connection established */
+            101: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    'application/json': components['schemas']['TimestampInfo'];
-                };
+                content?: never;
             };
-            /** @description Bad request */
+            /** @description Exceed max clients count */
             400: {
                 headers: {
                     [name: string]: unknown;
@@ -2567,6 +3349,26 @@ declare interface operations {
             };
         };
     };
+    getTime: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Timestamp retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['TimestampInfo'];
+                };
+            };
+        };
+    };
     unlinkAccount: {
         parameters: {
             query?: never;
@@ -2636,7 +3438,7 @@ declare interface operations {
             };
         };
     };
-    getAccountState: {
+    getAccountStatus: {
         parameters: {
             query?: never;
             header?: never;
@@ -2651,7 +3453,7 @@ declare interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    'application/json': components['schemas']['AccountState'];
+                    'application/json': components['schemas']['AccountStatus'];
                 };
             };
         };
@@ -2965,7 +3767,7 @@ declare interface operations {
             };
         };
     };
-    getMatterCommissioningStatus: {
+    getSmartHomeCommissioningStatus: {
         parameters: {
             query?: never;
             header?: never;
@@ -2974,18 +3776,18 @@ declare interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description Successfully got Matter commissioning status */
+            /** @description Successfully got smart home commissioning status */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    'application/json': components['schemas']['MatterCommissionedFabrics'];
+                    'application/json': components['schemas']['SmartHomePairingInfo'];
                 };
             };
         };
     };
-    startMatterCommissioning: {
+    startSmartHomePairing: {
         parameters: {
             query?: never;
             header?: never;
@@ -2994,16 +3796,16 @@ declare interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description Successfully started Matter commissioning */
+            /** @description Successfully started smart home pairing */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    'application/json': components['schemas']['MatterCommissioningPayload'];
+                    'application/json': components['schemas']['SmartHomePairingPayload'];
                 };
             };
-            /** @description Internal Matter service is broken */
+            /** @description Internal smart home service is broken */
             503: {
                 headers: {
                     [name: string]: unknown;
@@ -3463,7 +4265,7 @@ declare interface paths {
         post: operations['drawOnDisplay'];
         /**
          * Clear display
-         * @description Clears the display and stops the Canvas application if running
+         * @description Deletes display elements drawn by the Canvas application. If application_name is specified, only elements for that app are removed.
          */
         delete: operations['clearDisplay'];
         options?: never;
@@ -3670,6 +4472,29 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
+    '/status/ws': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Device status streaming WebSocket endpoint
+         * @description WebSocket connection for real-time device status and screen streaming.
+         *     Upgrade from HTTP to WebSocket protocol is required.
+         *     After connection, client must enable streaming by sending JSON: {"enable": true}
+         *
+         */
+        get: operations['connectWebSocket'];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     '/wifi/status': {
         parameters: {
             query?: never;
@@ -3911,7 +4736,7 @@ declare interface paths {
          *     as JSON {"display": 0}
          *
          */
-        get: operations['connectWebSocket'];
+        get: operations['connectScreenWebSocket'];
         put?: never;
         post?: never;
         delete?: never;
@@ -3951,6 +4776,15 @@ declare interface paths {
                         'application/json': components['schemas']['SuccessResponse'];
                     };
                 };
+                /** @description Unable to start BLE */
+                503: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        'application/json': components['schemas']['Error'];
+                    };
+                };
             };
         };
         delete?: never;
@@ -3990,6 +4824,15 @@ declare interface paths {
                         'application/json': components['schemas']['SuccessResponse'];
                     };
                 };
+                /** @description Unable to stop BLE */
+                503: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        'application/json': components['schemas']['Error'];
+                    };
+                };
             };
         };
         delete?: never;
@@ -4173,7 +5016,7 @@ declare interface paths {
          * Get MQTT status info
          * @description Retrieves MQTT status
          */
-        get: operations['getAccountState'];
+        get: operations['getAccountStatus'];
         put?: never;
         post?: never;
         delete?: never;
@@ -4319,7 +5162,7 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
-    '/matter/commissioning': {
+    '/smart_home/pairing': {
         parameters: {
             query?: never;
             header?: never;
@@ -4327,10 +5170,10 @@ declare interface paths {
             cookie?: never;
         };
         /** Smart home commissioning status */
-        get: operations['getMatterCommissioningStatus'];
+        get: operations['getSmartHomeCommissioningStatus'];
         put?: never;
         /** Link device to a smart home */
-        post: operations['startMatterCommissioning'];
+        post: operations['startSmartHomePairing'];
         /** Erase all smart home links */
         delete: {
             parameters: {
@@ -4341,7 +5184,7 @@ declare interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Successfully erased all Matter commissioning info, device restart is needed */
+                /** @description Successfully erased all smart home pairing info, device restart is needed */
                 200: {
                     headers: {
                         [name: string]: unknown;
@@ -4350,7 +5193,7 @@ declare interface paths {
                         'application/json': components['schemas']['SuccessResponse'];
                     };
                 };
-                /** @description Internal Matter service is broken */
+                /** @description Internal smart home service is broken */
                 503: {
                     headers: {
                         [name: string]: unknown;
@@ -4366,14 +5209,14 @@ declare interface paths {
         patch?: never;
         trace?: never;
     };
-    '/matter/endpoint/1': {
+    '/smart_home/switch': {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Get Matter endpoint 1 state */
+        /** Get state of emulated smart home switch */
         get: {
             parameters: {
                 query?: never;
@@ -4383,16 +5226,16 @@ declare interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Successfully got Matter endpoint 1 state */
+                /** @description Successfully got state of emulated smart home switch */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        'application/json': components['schemas']['MatterEndpointState'];
+                        'application/json': components['schemas']['SmartHomeSwitchState'];
                     };
                 };
-                /** @description Internal Matter service is broken */
+                /** @description Internal smart home service is broken */
                 503: {
                     headers: {
                         [name: string]: unknown;
@@ -4404,7 +5247,7 @@ declare interface paths {
             };
         };
         put?: never;
-        /** Set Matter endpoint 1 state */
+        /** Set state of emulated smart home switch */
         post: {
             parameters: {
                 query?: never;
@@ -4414,11 +5257,11 @@ declare interface paths {
             };
             requestBody: {
                 content: {
-                    'application/json': components['schemas']['MatterEndpointState'];
+                    'application/json': components['schemas']['SmartHomeSwitchState'];
                 };
             };
             responses: {
-                /** @description Successfully set Matter endpoint 1 state */
+                /** @description Successfully set state of emulated smart home switch */
                 200: {
                     headers: {
                         [name: string]: unknown;
@@ -4427,7 +5270,7 @@ declare interface paths {
                         'application/json': components['schemas']['SuccessResponse'];
                     };
                 };
-                /** @description Internal Matter service is broken */
+                /** @description Internal smart home service is broken */
                 503: {
                     headers: {
                         [name: string]: unknown;
@@ -4446,16 +5289,100 @@ declare interface paths {
     };
 }
 
-declare type RenameQuery = operations['RenameStorageFile']['parameters']['query'];
+/**
+ * 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<CamelizedRequest['ipConfig']>, 'ipMethod'>;
+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>;
 
-export declare interface ScreenFrameGetParams extends TimeoutOptions {
-    display: paths['/screen']['get']['parameters']['query']['display'];
+export declare interface ScreenFrameGetParams extends TimeoutOptions, ScreenQuery {
 }
 
+declare type ScreenQuery = paths['/screen']['get']['parameters']['query'];
+
+export declare type ScreenResponse = components['schemas']['ScreenResponse'];
+
 export declare class ScreenStream {
     private config;
     readonly addr: string;
@@ -4484,6 +5411,8 @@ export declare interface ScreenStreamConfig {
     apiSemver?: ApiSemver;
 }
 
+declare type SetTimezoneQuery = operations['setTimeTimezone']['parameters']['query'];
+
 declare class SettingsMethods {
     /**
      * Get HTTP API access over Wi-Fi configuration.
@@ -4498,7 +5427,7 @@ declare class SettingsMethods {
      *
      * @param {HttpAccessParams} params - Access parameters:
      *   @param {boolean} params.mode - Enable/disable access.
-     *   @param {string} params.key - Access key (4-10 digits).
+     *   @param {string} [params.key] - Access key (4-10 digits).
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<SuccessResponse>} A promise that resolves on success.
      */
@@ -4522,10 +5451,109 @@ declare class SettingsMethods {
     SettingsNameSet(this: BusyBar, params: NameParams): Promise<SuccessResponse>;
 }
 
-declare type SnakeToCamel<S extends string> = S extends `${infer Head}_${infer Tail}` ? `${Head}${Capitalize<SnakeToCamel<Tail>>}` : S;
+declare class SmartHomeMethods {
+    /**
+     * Smart home commissioning status.
+     *
+     * @param {TimeoutOptions} [params] - Optional parameters.
+     *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
+     * @returns {Promise<SmartHomePairingInfo>} A promise that resolves to the pairing info.
+     */
+    SmartHomePairingGet(this: BusyBar, params?: TimeoutOptions): Promise<SmartHomePairingInfo>;
+    /**
+     * Link device to a smart home.
+     *
+     * @param {TimeoutOptions} [params] - Optional timeout.
+     * @returns {Promise<SmartHomePairingPayload>} A promise that resolves to the pairing payload.
+     */
+    SmartHomePair(this: BusyBar, params?: TimeoutOptions): Promise<SmartHomePairingPayload>;
+    /**
+     * Erase all smart home links.
+     *
+     * @param {TimeoutOptions} [params] - Optional parameters.
+     *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
+     * @returns {Promise<SuccessResponse>} A promise that resolves on success.
+     */
+    SmartHomeErase(this: BusyBar, params?: TimeoutOptions): Promise<SuccessResponse>;
+    /**
+     * Get state of emulated smart home switch.
+     *
+     * @param {TimeoutOptions} [params] - Optional parameters.
+     *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
+     * @returns {Promise<SmartHomeSwitchState>} A promise that resolves to the switch state.
+     */
+    SmartHomeSwitchStateGet(this: BusyBar, params?: TimeoutOptions): Promise<SmartHomeSwitchState>;
+    /**
+     * Set state of emulated smart home switch.
+     *
+     * @param {SmartHomeSwitchState & TimeoutOptions} params - Switch state and optional timeout.
+     * @returns {Promise<SuccessResponse>} A promise that resolves on success.
+     */
+    SmartHomeSwitchStateSet(this: BusyBar, params: SmartHomeSwitchState & TimeoutOptions): Promise<SuccessResponse>;
+    /**
+     * @deprecated Use SmartHomePairingGet instead.
+     */
+    MatterStatusGet(this: BusyBar, params?: TimeoutOptions): Promise<SmartHomePairingInfo>;
+    /**
+     * @deprecated Use SmartHomePair instead.
+     */
+    MatterPair(this: BusyBar, params?: TimeoutOptions): Promise<SmartHomePairingPayload>;
+    /**
+     * @deprecated Use SmartHomeErase instead.
+     */
+    MatterErase(this: BusyBar, params?: TimeoutOptions): Promise<SuccessResponse>;
+}
+
+export declare type SmartHomePairingInfo = components['schemas']['SmartHomePairingInfo'];
+
+export declare type SmartHomePairingPayload = components['schemas']['SmartHomePairingPayload'];
+
+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'];
@@ -4536,15 +5564,15 @@ export declare type StatusSystem = components['schemas']['StatusSystem'];
 
 declare type StopListener = () => void;
 
-export declare interface StorageCreateDirectoryParams extends TimeoutOptions {
-    path: operations['createStorageDir']['parameters']['query']['path'];
+export declare interface StorageCreateDirectoryParams extends TimeoutOptions, StorageCreateDirQuery {
 }
 
+declare type StorageCreateDirQuery = operations['createStorageDir']['parameters']['query'];
+
 export declare type StorageDirElement = components['schemas']['StorageDirElement'];
 
-export declare interface StorageDownloadFileParams extends TimeoutOptions {
-    path: operations['readStorageFile']['parameters']['query']['path'];
-    asArrayBuffer?: boolean;
+export declare interface StorageDownloadFileParams extends TimeoutOptions, StorageReadQuery {
+    as_array_buffer?: boolean;
 }
 
 export declare type StorageFileElement = components['schemas']['StorageFileElement'];
@@ -4553,6 +5581,8 @@ export declare type StorageList = components['schemas']['StorageList'];
 
 export declare type StorageListElement = components['schemas']['StorageListElement'];
 
+declare type StorageListQuery = operations['listStorageFiles']['parameters']['query'];
+
 declare class StorageMethods {
     /**
      * Upload file to internal storage. Uploads a file to a specified path.
@@ -4569,7 +5599,7 @@ declare class StorageMethods {
      *
      * @param {DownloadFileParams} params - Download parameters:
      *   @param {string} params.path - Path to the file.
-     *   @param {boolean} [params.asArrayBuffer] - Whether to return ArrayBuffer instead of Blob.
+     *   @param {boolean} [params.as_array_buffer] - Whether to return ArrayBuffer instead of Blob.
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<StorageReadResponse>} A promise that resolves to the file content (Blob or ArrayBuffer).
      */
@@ -4621,24 +5651,77 @@ declare class StorageMethods {
     StorageRename(this: BusyBar, params: StorageRenameParams): Promise<SuccessResponse>;
 }
 
-export declare interface StorageReadDirectoryParams extends TimeoutOptions {
-    path: operations['listStorageFiles']['parameters']['query']['path'];
+export declare interface StorageReadDirectoryParams extends TimeoutOptions, StorageListQuery {
 }
 
+declare type StorageReadQuery = operations['readStorageFile']['parameters']['query'];
+
 export declare type StorageReadResponse = ArrayBuffer | Blob;
 
-export declare interface StorageRemoveParams extends TimeoutOptions {
-    path: operations['removeStorageFile']['parameters']['query']['path'];
+export declare interface StorageRemoveParams extends TimeoutOptions, StorageRemoveQuery {
 }
 
-export declare interface StorageRenameParams extends TimeoutOptions, RenameQuery {
+declare type StorageRemoveQuery = operations['removeStorageFile']['parameters']['query'];
+
+export declare interface StorageRenameParams extends TimeoutOptions, StorageRenameQuery {
 }
 
+declare type StorageRenameQuery = operations['RenameStorageFile']['parameters']['query'];
+
 export declare type StorageStatus = components['schemas']['StorageStatus'];
 
-export declare interface StorageUploadFileParams extends TimeoutOptions {
-    path: operations['writeStorageFile']['parameters']['query']['path'];
-    file: BusyFile;
+export declare interface StorageUploadFileParams extends TimeoutOptions, StorageWriteQuery {
+    file: BusyFile_2;
+}
+
+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'];
@@ -4694,6 +5777,8 @@ declare class SystemMethods {
     SystemStatusFirmwareGet(this: BusyBar, params?: TimeoutOptions): Promise<StatusFirmware>;
 }
 
+export declare type TextElement = components['schemas']['TextElement'];
+
 declare class TimeMethods {
     /**
      * Get current timestamp info.
@@ -4745,12 +5830,10 @@ export declare interface TimeoutOptions {
 
 export declare type TimestampInfo = components['schemas']['TimestampInfo'];
 
-export declare interface TimeTimestampParams extends TimeoutOptions {
-    timestamp: operations['setTimeTimestamp']['parameters']['query']['timestamp'];
+export declare interface TimeTimestampParams extends TimeoutOptions, TimestampInfo {
 }
 
-export declare interface TimeTimezoneParams extends TimeoutOptions {
-    timezone: operations['setTimeTimezone']['parameters']['query']['timezone'];
+export declare interface TimeTimezoneParams extends TimeoutOptions, SetTimezoneQuery {
 }
 
 export declare type TimezoneInfo = components['schemas']['TimezoneInfo'];
@@ -4764,18 +5847,20 @@ export declare interface UpdateAutoUpdateParams extends TimeoutOptions, AutoUpda
 
 export declare type UpdateChangelog = operations['getUpdateChangelog']['responses']['200']['content']['application/json'];
 
-export declare interface UpdateChangelogParams extends TimeoutOptions {
-    version: string;
+export declare interface UpdateChangelogParams extends TimeoutOptions, UpdateChangelogQuery {
 }
 
+declare type UpdateChangelogQuery = operations['getUpdateChangelog']['parameters']['query'];
+
 export declare interface UpdateFromFileParams extends TimeoutOptions {
-    file: BusyFile;
+    file: BusyFile_2;
 }
 
-export declare interface UpdateInstallParams extends TimeoutOptions {
-    version: string;
+export declare interface UpdateInstallParams extends TimeoutOptions, UpdateInstallQuery {
 }
 
+declare type UpdateInstallQuery = operations['installFirmwareUpdate']['parameters']['query'];
+
 declare class UpdateMethods {
     /**
      * Upload firmware update package.
@@ -4853,9 +5938,9 @@ export declare type UpdateStatus = components['schemas']['UpdateStatus'];
 
 export declare type VersionInfo = components['schemas']['VersionInfo'];
 
-export declare type WifiConnectParams = RequireKeys<Omit<CamelizedRequest, 'ipConfig'> & {
-    ipConfig: RequiredIpConfig;
-}, 'ssid' | 'security' | 'ipConfig'> & TimeoutOptions;
+export declare type WifiConnectParams = RequireKeys<Omit<WifiConnectRequestConfig, 'ip_config'> & {
+    ip_config: RequiredIpConfig;
+}, 'ssid' | 'security' | 'ip_config'> & TimeoutOptions;
 
 export declare type WifiConnectRequestConfig = components['schemas']['ConnectRequestConfig'];
 
@@ -4879,7 +5964,7 @@ declare class WifiMethods {
      *   @param {string} params.ssid - Network SSID.
      *   @param {string} params.password - Network password.
      *   @param {WifiSecurityMethod} params.security - Security method.
-     *   @param {object} params.ipConfig - IP configuration.
+     *   @param {object} [params.ip_config] - IP configuration.
      *   @param {TimeoutOptions['timeout']} [params.timeout] - Request timeout in milliseconds.
      * @returns {Promise<SuccessResponse>} A promise that resolves on successful connection initiation.
      */
@@ -4910,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 { }