@bridgething/lib 0.1.2

package/dist/bindings/client.d.ts

@@ -0,0 +1,1904 @@
+import type { AcceptCallAction, BridgeThingMeta, BrightnessMode, BrightnessState, BrowseResult, CallEndReason, Capabilities, CommunicationsState, ConfigEntry, CurrentlyActiveApplication, Device, Diagnostics, DismissReason, DtmfTone, EndCallAction, FavoritesPage, ForwardMessage, GeoAccuracy, GeoError, HardwareState, HttpHeader, InitiateCallType, ItemKind, ItemRef, LibraryError, LogEntry, LogLevel, LogSource, NetError, NetFetchRequest, NetFetchResponse, Notification, NowPlayingUpdate, OtaError, OtaProgress, Peer, PhoneCall, PhoneCallService, PhoneError, PhoneState, PlayContext, PlayerError, PlayerState, Position, QueueItem, QueuePosition, RecommendationsResult, RepeatMode, SearchResult, StreamBegin, StreamChunk, StreamEnd, StreamError, TimeInfo, WebappError, WebappInfo, WsError, WsFrame } from './shared';
+import type { MsgMeta, WireError } from './wire';
+/**
+ * 0..=100 ambient-brightness indicator derived from the on-board ALS +
+ * backlight curve. Low = dark room, high = bright room.
+ */
+export type AmbientLightUpdate = {
+    ambientLevel: number;
+};
+/**
+ * An asset was evicted from the cache; webapps should drop any cached
+ * Blob URL for it and refetch on next use.
+ */
+export type AssetCleared = {
+    id: string;
+};
+/**
+ * Webapp request: read an asset by id. Bridge replies with `Got` on hit
+ * or `NotFound` (domain) when neither cache nor companion has it.
+ */
+export type AssetGet = {
+    /**
+     * Opaque asset id, e.g. `iap2/art/<persistent-hex>/<n>` for iAP2 art or a
+     * companion-defined shape like `spotify/img/<id>`.
+     */
+    id: string;
+    /**
+     * Correlates the `Got` or `NotFound` reply back to this request.
+     */
+    requestId: string;
+};
+/**
+ * Successful reply to `AssetGet`: the requested bytes.
+ */
+export type AssetGot = {
+    /**
+     * Echoes the `AssetGet.request_id` this reply resolves.
+     */
+    requestId: string;
+    /**
+     * Echoes the requested asset id.
+     */
+    id: string;
+    /**
+     * Raw asset bytes, already reassembled if the companion sent them as a
+     * chunked BT transfer.
+     */
+    bytes: Uint8Array;
+    /**
+     * Best-effort content type; `None` when the source didn't provide one.
+     */
+    mime: string | null;
+};
+/**
+ * Domain-error reply to `AssetGet`: neither the cache nor a connected
+ * companion has an asset for this id.
+ */
+export type AssetNotFound = {
+    /**
+     * Echoes the `AssetGet.request_id` this reply resolves.
+     */
+    requestId: string;
+    /**
+     * Echoes the requested asset id.
+     */
+    id: string;
+};
+/**
+ * Webapp hint to warm the asset cache for a set of ids so subsequent
+ * `Get` calls hit cache. Fire-and-forget; webapps observe completion
+ * via `Asset.Ready` events.
+ */
+export type AssetPreload = {
+    /**
+     * Ids to prefetch, capped at 64 per call. Ids already cached and ids
+     * under the `iap2/art/` prefix are skipped, since iAP2 art only ever
+     * arrives via a push from the phone, not a pull request.
+     */
+    ids: Array<string>;
+};
+/**
+ * An asset became fetchable in the cache; a subsequent `AssetGet` for this
+ * id will resolve without a companion round trip.
+ */
+export type AssetReady = {
+    id: string;
+};
+/**
+ * Describes the device's own bluetooth adapter. `interface` is the
+ * host-side interface name (e.g. `hci0`).
+ */
+export type BluetoothInterface = {
+    mac: string;
+    name: string;
+    interface: string;
+};
+/**
+ * Outcome of an in-flight pairing attempt initiated by a peer device.
+ */
+export type BluetoothPairingResult = {
+    success: boolean;
+};
+/**
+ * A pairing PIN a peer device is displaying, for a webapp to show as
+ * on-screen confirmation.
+ */
+export type BluetoothPin = {
+    mac: string;
+    name: string;
+    pin: string;
+};
+/**
+ * Whether a companion phone is currently connected over bluetooth.
+ */
+export type BluetoothStatus = {
+    connected: boolean;
+};
+/**
+ * Daemon-side asset events. `Got` and `NotFound` resolve a webapp `Get`
+ * (correlated by request_id). `Ready` broadcasts to all connected
+ * webapps whenever the cache gains an asset, regardless of source
+ * (companion push, iAP2 FileTransfer, request fulfilment, lazy disk
+ * load). `Cleared` broadcasts on every eviction path - LRU pressure,
+ * TTL expiry, companion-issued Clear, daemon shutdown - so SDK
+ * consumers can drop Blob URLs and refetch as needed.
+ */
+export type BridgeToClientAssetMsg = {
+    event: 'got';
+    data: AssetGot;
+} | {
+    event: 'notFound';
+    data: AssetNotFound;
+} | {
+    event: 'ready';
+    data: AssetReady;
+} | {
+    event: 'cleared';
+    data: AssetCleared;
+};
+/**
+ * Daemon -> webapp audio events: TTS lifecycle notifications and
+ * volume/mute changes.
+ */
+export type BridgeToClientAudioMsg = {
+    event: 'ttsStarted';
+    data: TtsStarted;
+} | {
+    event: 'ttsEnded';
+    data: TtsEnded;
+} | {
+    event: 'volumeChanged';
+    data: VolumeChanged;
+};
+/**
+ * Daemon -> webapp bluetooth surface: connection status/events,
+ * in-flight pairing feedback, and the reply to `bluetooth.list`.
+ */
+export type BridgeToClientBluetoothMsg = {
+    event: 'status';
+    data: BluetoothStatus;
+} | {
+    event: 'connectedDevice';
+    data: ConnectedDevice;
+} | {
+    event: 'interface';
+    data: BluetoothInterface;
+} | {
+    event: 'pairingResult';
+    data: BluetoothPairingResult;
+} | {
+    event: 'pin';
+    data: BluetoothPin;
+} | {
+    event: 'pairedDevices';
+    data: PairedDevicesMap;
+};
+/**
+ * Daemon -> webapp capabilities surface. `Update` is the broadcast event
+ * fired on connect + on every change; `Snapshot` is the typed reply to
+ * `CapabilitiesGet`. Webapps that auto-react to capability change
+ * listen on `Update` and don't need to call `Get`.
+ */
+export type BridgeToClientCapabilitiesMsg = {
+    event: 'update';
+    data: CapabilitiesSnapshot;
+} | {
+    event: 'snapshot';
+    data: CapabilitiesSnapshot;
+};
+/**
+ * Daemon -> webapp config replies and events. `Get` / `List` reply to
+ * the matching requests. `Changed` broadcasts whenever the gateway
+ * writes or deletes a value for the active webapp.
+ */
+export type BridgeToClientConfigMsg = {
+    event: 'get';
+    data: ConfigGetReply;
+} | {
+    event: 'list';
+    data: ConfigListReply;
+} | {
+    event: 'changed';
+    data: ConfigChanged;
+};
+/**
+ * Daemon -> webapp location surface: the `Position` stream a watch
+ * produces, plus replies to `geo.watch` and `geo.getOnce`.
+ */
+export type BridgeToClientGeoMsg = {
+    event: 'position';
+    data: Position;
+} | {
+    event: 'watchReply';
+    data: GeoWatchReply;
+} | {
+    event: 'getOnceReply';
+    data: GeoGetOnceReply;
+} | {
+    event: 'errorReply';
+    data: GeoErrorReply;
+};
+/**
+ * Daemon -> webapp hardware surface: ambient-light and backlight
+ * change events, plus the reply to `hardware.stateGet`.
+ */
+export type BridgeToClientHardwareMsg = {
+    event: 'ambientLightUpdate';
+    data: AmbientLightUpdate;
+} | {
+    event: 'brightnessChanged';
+    data: BrightnessState;
+} | {
+    event: 'stateReply';
+    data: HardwareStateReply;
+};
+/**
+ * Daemon -> webapp replies and events for the library surface. `BrowseReply`, `SearchReply`,
+ * `RecommendationsReply`, `FavoritesListReply`, and `FavoritesContainsReply` answer the
+ * matching `ClientToBridgeLibraryMsg` request; `LibraryErrorReply` replaces the reply on
+ * failure. `FavoriteChanged` is a live event broadcast to every connected webapp whenever a
+ * favorite's status changes.
+ */
+export type BridgeToClientLibraryMsg = {
+    event: 'browseReply';
+    data: LibraryBrowseReply;
+} | {
+    event: 'searchReply';
+    data: LibrarySearchReply;
+} | {
+    event: 'recommendationsReply';
+    data: LibraryRecommendationsReply;
+} | {
+    event: 'favoritesListReply';
+    data: LibraryFavoritesListReply;
+} | {
+    event: 'favoritesContainsReply';
+    data: LibraryFavoritesContainsReply;
+} | {
+    event: 'libraryErrorReply';
+    data: LibraryErrorReply;
+} | {
+    event: 'favoriteChanged';
+    data: FavoriteChanged;
+};
+/**
+ * bridgething -> client
+ * messages from bridgething to the client (webapp).
+ *
+ * these messages travel over the local websocket on port 8891.
+ */
+export type BridgeToClientMsg = {
+    id: string;
+    meta: MsgMeta;
+    data: BridgeToClientMsgData;
+};
+export type BridgeToClientMsgData = {
+    type: 'asset';
+    data: BridgeToClientAssetMsg;
+} | {
+    type: 'audio';
+    data: BridgeToClientAudioMsg;
+} | {
+    type: 'bluetooth';
+    data: BridgeToClientBluetoothMsg;
+} | {
+    type: 'capabilities';
+    data: BridgeToClientCapabilitiesMsg;
+} | {
+    type: 'config';
+    data: BridgeToClientConfigMsg;
+} | {
+    type: 'geo';
+    data: BridgeToClientGeoMsg;
+} | {
+    type: 'hardware';
+    data: BridgeToClientHardwareMsg;
+} | {
+    type: 'library';
+    data: BridgeToClientLibraryMsg;
+} | {
+    type: 'net';
+    data: BridgeToClientNetMsg;
+} | {
+    type: 'notifications';
+    data: BridgeToClientNotificationsMsg;
+} | {
+    type: 'peer';
+    data: BridgeToClientPeerMsg;
+} | {
+    type: 'phone';
+    data: BridgeToClientPhoneMsg;
+} | {
+    type: 'player';
+    data: BridgeToClientPlayerMsg;
+} | {
+    type: 'store';
+    data: BridgeToClientStoreMsg;
+} | {
+    type: 'system';
+    data: BridgeToClientSystemMsg;
+} | {
+    type: 'time';
+    data: BridgeToClientTimeMsg;
+} | {
+    type: 'voice';
+    data: BridgeToClientVoiceMsg;
+} | {
+    type: 'webapp';
+    data: BridgeToClientWebappMsg;
+} | {
+    type: 'forward';
+    data: ForwardMessage;
+} | {
+    type: 'error';
+    data: WireError;
+} | {
+    type: 'ack';
+} | {
+    type: 'done';
+};
+/**
+ * Daemon -> webapp network surface: replies to `fetch` and `ws.open`,
+ * WebSocket frame/close/error events, and the `Stream*` event trio
+ * driven by `net.stream.open`.
+ */
+export type BridgeToClientNetMsg = {
+    event: 'fetchReply';
+    data: NetFetchReply;
+} | {
+    event: 'fetchErrorReply';
+    data: NetFetchErrorReply;
+} | {
+    event: 'wsOpenReply';
+    data: NetWsOpenReply;
+} | {
+    event: 'wsErrorReply';
+    data: NetWsErrorReply;
+} | {
+    event: 'wsMessage';
+    data: NetWsMessage;
+} | {
+    event: 'wsClosed';
+    data: NetWsClosed;
+} | {
+    event: 'wsErrorEvent';
+    data: NetWsErrorEvent;
+} | {
+    event: 'streamBegin';
+    data: StreamBegin;
+} | {
+    event: 'streamChunk';
+    data: StreamChunk;
+} | {
+    event: 'streamEnd';
+    data: StreamEnd;
+} | {
+    event: 'streamError';
+    data: StreamError;
+};
+/**
+ * Daemon -> webapp notification mirror. `Posted` fires for a new
+ * notification, `Updated` when an existing one's content changes, and
+ * `Removed` when it is dismissed, acted on, or cleared remotely.
+ */
+export type BridgeToClientNotificationsMsg = {
+    event: 'posted';
+    data: Notification;
+} | {
+    event: 'updated';
+    data: Notification;
+} | {
+    event: 'removed';
+    data: NotificationRemoved;
+};
+/**
+ * Daemon -> webapp peer surface: a full snapshot of every known peer
+ * (paired, iAP2, and companion-gateway state), re-sent whenever any
+ * peer changes. There is no per-webapp request; a fresh snapshot
+ * arrives on connect and after every change.
+ */
+export type BridgeToClientPeerMsg = {
+    event: 'snapshot';
+    data: PeerSnapshotMap;
+};
+/**
+ * Daemon -> webapp telephony surface. `CallStarted`/`CallUpdated`/
+ * `CallEnded`/`CommunicationsChanged` are unsolicited broadcasts driven by
+ * the connected companion's telephony state; `StateReply`/`ErrorReply`
+ * answer webapp-issued requests and commands.
+ */
+export type BridgeToClientPhoneMsg = {
+    event: 'callStarted';
+    data: PhoneCall;
+} | {
+    event: 'callUpdated';
+    data: PhoneCall;
+} | {
+    event: 'callEnded';
+    data: PhoneCallEnded;
+} | {
+    event: 'communicationsChanged';
+    data: PhoneCommunicationsReply;
+} | {
+    event: 'stateReply';
+    data: PhoneStateReply;
+} | {
+    event: 'errorReply';
+    data: PhoneErrorReply;
+};
+/**
+ * Daemon -> webapp player surface. `Snapshot` lands on connect with the
+ * current player state; `Delta` is the `NowPlayingUpdate` stream the
+ * SDK auto-merges; `QueueChanged` fires when the queue mutates without
+ * a track change. `StateReply`/`QueueReply` are the typed responses
+ * to the matching webapp queries.
+ */
+export type BridgeToClientPlayerMsg = {
+    event: 'snapshot';
+    data: PlayerStateReply;
+} | {
+    event: 'delta';
+    data: NowPlayingUpdate;
+} | {
+    event: 'queueChanged';
+    data: PlayerQueueReply;
+} | {
+    event: 'stateReply';
+    data: PlayerStateReply;
+} | {
+    event: 'queueReply';
+    data: PlayerQueueReply;
+} | {
+    event: 'errorReply';
+    data: PlayerErrorReply;
+};
+/**
+ * Daemon -> webapp KV storage replies. `Response` answers all three
+ * `client.store` requests (`Get` / `Put` / `Delete`).
+ */
+export type BridgeToClientStoreMsg = {
+    event: 'response';
+    data: StorageResponse;
+};
+/**
+ * Daemon -> webapp system events and replies. `Version` replies to
+ * `VersionRequest` with the daemon's `BridgeThingMeta`. `DiagnosticsReply`,
+ * `LogsTailReply`, `LogsSubscribeReply`, and `DeviceNickname` are replies
+ * to their matching requests. `LogEntry` streams matching lines to a live
+ * `LogsSubscribe` subscription. `OtaProgress` / `OtaError` report OTA
+ * orchestrator state. `DeviceNicknameChanged` broadcasts whenever the
+ * nickname mutates, including from another surface.
+ */
+export type BridgeToClientSystemMsg = {
+    event: 'version';
+    data: BridgeThingMeta;
+} | {
+    event: 'diagnosticsReply';
+    data: DiagnosticsReply;
+} | {
+    event: 'logsTailReply';
+    data: LogsTailReply;
+} | {
+    event: 'logsSubscribeReply';
+    data: LogsSubscribeReply;
+} | {
+    event: 'logEntry';
+    data: LogEntry;
+} | {
+    event: 'otaProgress';
+    data: OtaProgress;
+} | {
+    event: 'otaError';
+    data: OtaError;
+} | {
+    event: 'deviceNickname';
+    data: DeviceNicknameReply;
+} | {
+    event: 'deviceNicknameChanged';
+    data: DeviceNicknameReply;
+};
+/**
+ * Daemon -> webapp wall-clock surface: an initial snapshot at
+ * announce, `Changed` events on tz/locale/clock updates, and the
+ * reply to `time.get`.
+ */
+export type BridgeToClientTimeMsg = {
+    event: 'changed';
+    data: TimeSnapshot;
+} | {
+    event: 'snapshot';
+    data: TimeSnapshot;
+};
+/**
+ * Daemon -> webapp voice/NLU surface: mic state-change events and the
+ * reply to `voice.stateGet`.
+ */
+export type BridgeToClientVoiceMsg = {
+    event: 'stateChanged';
+    data: VoiceState;
+} | {
+    event: 'stateReply';
+    data: VoiceStateReply;
+};
+/**
+ * Daemon -> webapp replies and events for the webapp-management surface. `ListReply`,
+ * `CurrentReply`, `ActiveReply`, and `IconReply` answer the matching `ClientToBridgeWebappMsg`
+ * request; `WebappError` replaces the reply on failure. `WebappInstalled` is a live event
+ * broadcast to every connected webapp whenever an installed-webapp transfer completes.
+ */
+export type BridgeToClientWebappMsg = {
+    event: 'listReply';
+    data: WebappListReply;
+} | {
+    event: 'currentReply';
+    data: WebappCurrentReply;
+} | {
+    event: 'activeReply';
+    data: WebappActiveReply;
+} | {
+    event: 'iconReply';
+    data: WebappIconReply;
+} | {
+    event: 'webappError';
+    data: WebappError;
+} | {
+    event: 'activeChanged';
+    data: WebappActiveChanged;
+} | {
+    event: 'webappInstalled';
+    data: WebappInfo;
+} | {
+    event: 'webappUninstalled';
+    data: WebappUninstalled;
+};
+/**
+ * Wrapper carrying one `Capabilities` snapshot; reply to `CapabilitiesGet`
+ * and payload of the `Update` broadcast event.
+ */
+export type CapabilitiesSnapshot = {
+    capabilities: Capabilities;
+};
+/**
+ * Webapp-side asset operations: `get` fetches bytes by id, `preload` warms
+ * the cache ahead of time so a later `get` resolves instantly.
+ */
+export type ClientToBridgeAssetMsg = {
+    event: 'get';
+    data: AssetGet;
+} | {
+    event: 'preload';
+    data: AssetPreload;
+};
+/**
+ * Webapp -> daemon audio control surface: volume/mute, TTS playback, and
+ * earcons. All fire-and-forget; `setVolume`/`setMute` broadcast a
+ * `VolumeChanged` event, and TTS lifecycle is reported via
+ * `TtsStarted`/`TtsEnded`.
+ */
+export type ClientToBridgeAudioMsg = {
+    event: 'volumeUp';
+} | {
+    event: 'volumeDown';
+} | {
+    event: 'setVolume';
+    data: SetVolume;
+} | {
+    event: 'muteToggle';
+} | {
+    event: 'setMute';
+    data: SetMute;
+} | {
+    event: 'tts';
+    data: Tts;
+} | {
+    event: 'ttsCancel';
+    data: TtsCancel;
+} | {
+    event: 'ttsCancelAll';
+} | {
+    event: 'earcon';
+    data: Earcon;
+};
+/**
+ * Webapp -> daemon bluetooth surface: adapter alias, discoverable
+ * state, and paired-device management. The device is the peripheral
+ * during pairing (it never scans for new devices); `connect` only
+ * re-establishes a link to an already-paired device.
+ */
+export type ClientToBridgeBluetoothMsg = {
+    event: 'list';
+} | {
+    event: 'connect';
+    data: ConnectBluetooth;
+} | {
+    event: 'enableDiscoverable';
+} | {
+    event: 'disableDiscoverable';
+} | {
+    event: 'forget';
+    data: ForgetBluetooth;
+} | {
+    event: 'setAlias';
+    data: SetBluetoothAlias;
+};
+/**
+ * Webapp -> daemon capabilities surface. `Get` is the one-shot pull;
+ * most webapps instead listen for `BridgeToClientCapabilitiesMsg::Update`.
+ */
+export type ClientToBridgeCapabilitiesMsg = {
+    event: 'get';
+};
+/**
+ * Webapp -> daemon read-only config surface (`client.config`). Config
+ * values are user-tunable settings the gateway pushes down for the
+ * active webapp; webapps cannot write here. `Get` reads a single key,
+ * `List` reads every set key. The daemon also broadcasts
+ * `BridgeToClientConfigMsg::Changed` whenever the gateway writes a
+ * value, so most webapps don't need to poll `Get`.
+ */
+export type ClientToBridgeConfigMsg = {
+    event: 'get';
+    data: ConfigGet;
+} | {
+    event: 'list';
+};
+/**
+ * Webapp -> daemon location surface: `watch`/`unwatch` register and
+ * release a standing subscription, `getOnce` fetches a single fix.
+ * Every fix originates from the connected phone; the device has no
+ * GPS of its own.
+ */
+export type ClientToBridgeGeoMsg = {
+    event: 'watch';
+    data: GeoWatch;
+} | {
+    event: 'unwatch';
+    data: GeoUnwatch;
+} | {
+    event: 'getOnce';
+    data: GeoGetOnce;
+};
+/**
+ * Webapp -> daemon hardware surface: display backlight control. Wheel
+ * / button / touch input never crosses this wire; the kiosk delivers
+ * those directly to the active webapp as chromium keypresses.
+ */
+export type ClientToBridgeHardwareMsg = {
+    event: 'displaySetMode';
+    data: DisplaySetMode;
+} | {
+    event: 'displaySetLevel';
+    data: DisplaySetLevel;
+} | {
+    event: 'stateGet';
+};
+/**
+ * Webapp -> daemon library surface: browse/search/recommend across the connected gateway's
+ * library, and read or mutate favorites. `Browse`, `Search`, `Recommendations`,
+ * `FavoritesList`, and `FavoritesContains` are request/reply and fail with
+ * `LibraryErrorReply` when no gateway is connected. `FavoritesToggle`, `FavoritesSet`, and
+ * `FavoritesSetMany` are fire-and-forget commands with no completion reply; if no gateway is
+ * connected they are silently dropped, and on success their effect surfaces later as a
+ * `FavoriteChanged` event.
+ */
+export type ClientToBridgeLibraryMsg = {
+    event: 'browse';
+    data: LibraryBrowse;
+} | {
+    event: 'search';
+    data: LibrarySearch;
+} | {
+    event: 'recommendations';
+    data: LibraryRecommendations;
+} | {
+    event: 'favoritesList';
+    data: LibraryFavoritesList;
+} | {
+    event: 'favoritesContains';
+    data: LibraryFavoritesContains;
+} | {
+    event: 'favoritesToggle';
+    data: FavoritesToggle;
+} | {
+    event: 'favoritesSet';
+    data: FavoritesSet;
+} | {
+    event: 'favoritesSetMany';
+    data: FavoritesSetMany;
+};
+/**
+ * client -> bridgething
+ * messages from the client (webapp) to bridgething.
+ *
+ * these messages travel over the local websocket on port 8891.
+ */
+export type ClientToBridgeMsg = {
+    id: string;
+    meta: MsgMeta;
+    data: ClientToBridgeMsgData;
+};
+export type ClientToBridgeMsgData = {
+    type: 'asset';
+    data: ClientToBridgeAssetMsg;
+} | {
+    type: 'audio';
+    data: ClientToBridgeAudioMsg;
+} | {
+    type: 'bluetooth';
+    data: ClientToBridgeBluetoothMsg;
+} | {
+    type: 'capabilities';
+    data: ClientToBridgeCapabilitiesMsg;
+} | {
+    type: 'config';
+    data: ClientToBridgeConfigMsg;
+} | {
+    type: 'geo';
+    data: ClientToBridgeGeoMsg;
+} | {
+    type: 'hardware';
+    data: ClientToBridgeHardwareMsg;
+} | {
+    type: 'library';
+    data: ClientToBridgeLibraryMsg;
+} | {
+    type: 'net';
+    data: ClientToBridgeNetMsg;
+} | {
+    type: 'notifications';
+    data: ClientToBridgeNotificationsMsg;
+} | {
+    type: 'phone';
+    data: ClientToBridgePhoneMsg;
+} | {
+    type: 'player';
+    data: ClientToBridgePlayerMsg;
+} | {
+    type: 'store';
+    data: ClientToBridgeStoreMsg;
+} | {
+    type: 'system';
+    data: ClientToBridgeSystemMsg;
+} | {
+    type: 'time';
+    data: ClientToBridgeTimeMsg;
+} | {
+    type: 'voice';
+    data: ClientToBridgeVoiceMsg;
+} | {
+    type: 'webapp';
+    data: ClientToBridgeWebappMsg;
+} | {
+    type: 'forward';
+    data: ForwardMessage;
+};
+/**
+ * Webapp -> daemon network surface: HTTP fetch, WebSocket, and byte
+ * streams, all proxied through the connected companion. The device
+ * has no network connectivity of its own.
+ */
+export type ClientToBridgeNetMsg = {
+    event: 'fetch';
+    data: NetFetch;
+} | {
+    event: 'wsOpen';
+    data: NetWsOpen;
+} | {
+    event: 'wsClose';
+    data: NetWsClose;
+} | {
+    event: 'wsSend';
+    data: NetWsSend;
+} | {
+    event: 'streamOpen';
+    data: NetStreamOpen;
+} | {
+    event: 'streamCancel';
+    data: NetStreamCancel;
+};
+/**
+ * Webapp -> daemon notification action surface. Fire-and-forget; invokes
+ * the notification's positive or negative ANCS-style action slot on the
+ * connected companion. Prefer `positiveAction`/`negativeAction` on the
+ * `Notification` to decide whether a slot exists before invoking it.
+ */
+export type ClientToBridgeNotificationsMsg = {
+    event: 'invokePositive';
+    data: NotificationInvoke;
+} | {
+    event: 'invokeNegative';
+    data: NotificationInvoke;
+};
+/**
+ * Webapp -> daemon call-control surface. Commands are fire-and-forget and
+ * route to the connected companion's telephony backend (iAP2 call CSMs on
+ * iOS, gateway telephony on Android); outcomes surface asynchronously via
+ * `BridgeToClientPhoneMsg` events.
+ */
+export type ClientToBridgePhoneMsg = {
+    event: 'answer';
+    data: PhoneCallAction;
+} | {
+    event: 'accept';
+    data: PhoneAcceptAction;
+} | {
+    event: 'decline';
+    data: PhoneCallAction;
+} | {
+    event: 'end';
+    data: PhoneCallAction;
+} | {
+    event: 'endTyped';
+    data: PhoneEndAction;
+} | {
+    event: 'hold';
+    data: PhoneCallAction;
+} | {
+    event: 'unhold';
+    data: PhoneCallAction;
+} | {
+    event: 'initiate';
+    data: PhoneInitiateAction;
+} | {
+    event: 'swap';
+} | {
+    event: 'merge';
+} | {
+    event: 'mute';
+    data: PhoneMuteAction;
+} | {
+    event: 'dtmf';
+    data: PhoneDtmfAction;
+} | {
+    event: 'stateGet';
+};
+/**
+ * Webapp -> daemon player control surface. Commands are fire-and-forget;
+ * the daemon routes each to whichever gateway owns playback. The two
+ * requests fetch a one-shot snapshot.
+ */
+export type ClientToBridgePlayerMsg = {
+    event: 'play';
+    data: PlayUri;
+} | {
+    event: 'queue';
+    data: QueueUri;
+} | {
+    event: 'pause';
+} | {
+    event: 'resume';
+} | {
+    event: 'skipNext';
+} | {
+    event: 'skipPrev';
+    data: SkipPrev;
+} | {
+    event: 'skipToIndex';
+    data: SkipToIndex;
+} | {
+    event: 'seekTo';
+    data: SeekTo;
+} | {
+    event: 'setShuffle';
+    data: SetShuffle;
+} | {
+    event: 'setRepeat';
+    data: SetRepeat;
+} | {
+    event: 'setSpeed';
+    data: SetSpeed;
+} | {
+    event: 'setCrossfade';
+    data: SetCrossfade;
+} | {
+    event: 'stateGet';
+} | {
+    event: 'queueGet';
+};
+/**
+ * Webapp -> daemon KV storage surface (`client.store`). Storage is
+ * scoped per webapp: keys set by one webapp are invisible to others.
+ * `Get` / `Put` / `Delete` each reply with the resulting `StorageResponse`.
+ */
+export type ClientToBridgeStoreMsg = {
+    event: 'get';
+    data: KVGet;
+} | {
+    event: 'put';
+    data: KVPut;
+} | {
+    event: 'delete';
+    data: KVDelete;
+};
+/**
+ * Webapp -> daemon system control surface. `VersionRequest` fetches the
+ * daemon's `BridgeThingMeta` identity block; `DiagnosticsGet` fetches a
+ * one-shot health snapshot; `LogsTail` pulls a batch of recent log
+ * entries; `LogsSubscribe` / `LogsUnsubscribe` open and close a live log
+ * stream; `Reboot` / `PowerOff` restart or shut down the device;
+ * `FactoryReset` wipes daemon state (config, store, paired devices) and
+ * reboots; `DeviceGetNickname` reads the current device nickname.
+ */
+export type ClientToBridgeSystemMsg = {
+    event: 'versionRequest';
+} | {
+    event: 'diagnosticsGet';
+} | {
+    event: 'logsTail';
+    data: LogsTail;
+} | {
+    event: 'logsSubscribe';
+    data: LogsSubscribe;
+} | {
+    event: 'logsUnsubscribe';
+    data: LogsUnsubscribe;
+} | {
+    event: 'reboot';
+} | {
+    event: 'powerOff';
+} | {
+    event: 'factoryReset';
+} | {
+    event: 'deviceGetNickname';
+};
+/**
+ * Webapp -> daemon wall-clock surface. The device has no
+ * battery-backed RTC, so time authority lives with the connected
+ * companion (or with iOS over iAP2's DeviceTimeUpdate).
+ */
+export type ClientToBridgeTimeMsg = {
+    event: 'get';
+};
+/**
+ * Webapp -> daemon voice/NLU surface: mic mute control and manual
+ * capture triggering. May be unavailable on builds without the mic
+ * hardware or the NLU pipeline enabled.
+ */
+export type ClientToBridgeVoiceMsg = {
+    event: 'cancel';
+} | {
+    event: 'pushToTalk';
+} | {
+    event: 'muteMic';
+    data: MicMute;
+} | {
+    event: 'unmuteMic';
+    data: MicUnmute;
+} | {
+    event: 'stateGet';
+};
+/**
+ * Webapp -> daemon webapp-management surface: enumerate installed webapps, inspect which one
+ * is active, switch the kiosk to a different webapp, and fetch icon bytes. All four verbs are
+ * request/reply.
+ */
+export type ClientToBridgeWebappMsg = {
+    event: 'list';
+} | {
+    event: 'current';
+} | {
+    event: 'activate';
+    data: WebappActivate;
+} | {
+    event: 'icon';
+    data: WebappIcon;
+};
+/**
+ * Broadcast when the gateway writes a new value for the active webapp.
+ * `value: None` means the entry was deleted; consumers should fall back
+ * to whatever default they declared.
+ */
+export type ConfigChanged = {
+    key: string;
+    value: string | null;
+};
+/**
+ * Webapp request: read one config value for the currently active webapp,
+ * as most recently set by the gateway. This surface is read-only; only
+ * the gateway can write config.
+ */
+export type ConfigGet = {
+    key: string;
+};
+/**
+ * Reply to `ConfigGet`.
+ */
+export type ConfigGetReply = {
+    key: string;
+    /**
+     * `None` when the gateway has never set this key, as opposed to an empty string.
+     */
+    value: string | null;
+};
+/**
+ * Reply to `ConfigList`.
+ */
+export type ConfigListReply = {
+    entries: Array<ConfigEntry>;
+};
+/**
+ * Payload for `bluetooth.connect`: connect to an already-paired
+ * device by MAC.
+ */
+export type ConnectBluetooth = {
+    mac: string;
+};
+/**
+ * The bluetooth device currently connected to the daemon.
+ */
+export type ConnectedDevice = {
+    name: string;
+    mac: string;
+};
+/**
+ * Current device nickname. `nickname: None` when the user hasn't set
+ * one. Reply to `DeviceGetNickname`; daemon also broadcasts this as a
+ * `DeviceNicknameChanged` event when the value mutates so webapps stay
+ * in sync without polling.
+ */
+export type DeviceNicknameReply = {
+    nickname: string | null;
+};
+/**
+ * Reply to `DiagnosticsGet`.
+ */
+export type DiagnosticsReply = {
+    diagnostics: Diagnostics;
+};
+/**
+ * Set the manual backlight level. Ignored unless `mode == Manual`;
+ * callers should pair with `setMode({ Manual })` when forcing a level.
+ */
+export type DisplaySetLevel = {
+    /**
+     * Backlight level in `[0.0, 1.0]`.
+     */
+    level: number;
+};
+/**
+ * Payload for `hardware.displaySetMode`: switch backlight control
+ * between daemon-driven (`Auto`, following the ALS) and webapp-driven
+ * (`Manual`, via `displaySetLevel`).
+ */
+export type DisplaySetMode = {
+    mode: BrightnessMode;
+};
+/**
+ * Payload for `earcon`.
+ */
+export type Earcon = {
+    /**
+     * Earcon name; must be one of `AudioCapabilities.earcons`.
+     */
+    name: string;
+};
+/**
+ * Event: a library item's favorited status changed. Fired for changes made through this
+ * client's own `favoritesToggle`/`favoritesSet`/`favoritesSetMany` calls as well as changes
+ * made natively on the connected phone (e.g. in the Spotify or Apple Music app).
+ */
+export type FavoriteChanged = {
+    uri: string;
+    liked: boolean;
+};
+/**
+ * Payload for the `favoritesSet` command: set `item`'s favorited state explicitly. Fire-and-
+ * forget; the result surfaces as a `FavoriteChanged` event.
+ */
+export type FavoritesSet = {
+    item: ItemRef;
+    liked: boolean;
+};
+/**
+ * Bulk favorites mutation. Webapps observing partial success listen
+ * for `FavoriteChanged` events.
+ */
+export type FavoritesSetMany = {
+    entries: Array<FavoritesSet>;
+};
+/**
+ * Payload for the `favoritesToggle` command: flip `item`'s favorited state (liked becomes
+ * unliked and vice versa). Fire-and-forget; the result surfaces as a `FavoriteChanged` event.
+ */
+export type FavoritesToggle = {
+    item: ItemRef;
+};
+/**
+ * Payload for `bluetooth.forget`: unpair a device and drop it from
+ * the daemon's known-device set.
+ */
+export type ForgetBluetooth = {
+    mac: string;
+};
+/**
+ * Error response to a failed `geo.watch` or `geo.getOnce` request.
+ */
+export type GeoErrorReply = {
+    error: GeoError;
+};
+/**
+ * Payload for `geo.getOnce`: fetch a single phone-sourced position
+ * fix without registering a standing watch.
+ */
+export type GeoGetOnce = {
+    accuracy: GeoAccuracy;
+};
+/**
+ * Response to `geo.getOnce`.
+ */
+export type GeoGetOnceReply = {
+    position: Position;
+};
+/**
+ * Stop a previously-issued watch. `token` is the value returned in
+ * `GeoWatchReply.token`. The daemon refcounts watches across webapps;
+ * the companion gets `Unwatch` only when the last token is released.
+ */
+export type GeoUnwatch = {
+    token: string;
+};
+/**
+ * Payload for `geo.watch`: register a standing subscription for
+ * phone-sourced position fixes. The daemon aggregates every active
+ * watcher's `accuracy` and `min_interval_ms` and forwards the most
+ * demanding combination to the companion.
+ */
+export type GeoWatch = {
+    accuracy: GeoAccuracy;
+    /**
+     * Minimum time between fixes, in milliseconds. The daemon uses the
+     * smallest value across all active watchers.
+     */
+    minIntervalMs: number;
+};
+/**
+ * Watch handle. Webapps pass the token back as
+ * `ClientToBridgeGeoMsg::Unwatch { token }` to release the watch.
+ * Tokens are scoped to the webapp's WS connection - the daemon
+ * auto-releases on disconnect.
+ */
+export type GeoWatchReply = {
+    token: string;
+};
+/**
+ * Response to `hardware.stateGet`.
+ */
+export type HardwareStateReply = {
+    state: HardwareState;
+};
+/**
+ * Webapp request: delete the KV storage entry at `key`.
+ */
+export type KVDelete = {
+    key: string;
+};
+/**
+ * Webapp request: read a value out of KV storage by key.
+ */
+export type KVGet = {
+    key: string;
+};
+/**
+ * Webapp request: write a value to KV storage under `key`.
+ */
+export type KVPut = {
+    key: string;
+    value: string;
+};
+/**
+ * Payload for the `browse` request: page through a folder in the library tree, or the root
+ * menu when `node_id` is `None`. Root-level results are cached by the daemon for up to 5
+ * minutes, so a fresh call immediately after a library change on the gateway side may still
+ * return the previous shelf layout.
+ */
+export type LibraryBrowse = {
+    /**
+     * Folder to descend into, from a prior result's `BrowseFolder::node_id`. `None` browses the root.
+     */
+    nodeId: string | null;
+    /**
+     * Requested page size; the daemon clamps this to 100 regardless of the value sent.
+     */
+    limit: number;
+    offset: number;
+    /**
+     * Root only: cap on the number of folders returned. `None` returns every folder.
+     */
+    sections?: number | null;
+    /**
+     * Root only: preview children per folder. `None` is the gateway default; `0` skips preview
+     * hydration entirely and returns a cheap index of node ids, titles, and totals.
+     */
+    preview?: number | null;
+};
+export type LibraryBrowseReply = {
+    result: BrowseResult;
+};
+export type LibraryErrorReply = {
+    error: LibraryError;
+};
+/**
+ * Batch "is each of these favorited?" lookup. Reply `liked` is
+ * index-aligned with the request `uris`, capped at 50 per call.
+ */
+export type LibraryFavoritesContains = {
+    /**
+     * Uris to check; the daemon truncates this to the first 50 regardless of the count sent.
+     */
+    uris: Array<string>;
+};
+export type LibraryFavoritesContainsReply = {
+    /**
+     * Index-aligned with the request's `uris`.
+     */
+    liked: Array<boolean>;
+};
+/**
+ * Payload for the `favoritesList` request: page through the user's saved/liked library items,
+ * mixed across kinds.
+ */
+export type LibraryFavoritesList = {
+    /**
+     * Requested page size; the daemon clamps this to 100 regardless of the value sent.
+     */
+    limit: number;
+    offset: number;
+};
+export type LibraryFavoritesListReply = {
+    page: FavoritesPage;
+};
+/**
+ * Recommendations seeded by up to 5 items. Spotify hard-caps at 5
+ * combined seeds across tracks/artists/genres.
+ */
+export type LibraryRecommendations = {
+    /**
+     * Seed items; the daemon truncates this to the first 5 regardless of the count sent.
+     */
+    seeds: Array<ItemRef>;
+    /**
+     * Restrict results to this item kind. `None` lets the gateway choose based on the seeds.
+     */
+    kind: ItemKind | null;
+    /**
+     * Requested page size; the daemon clamps this to 100 regardless of the value sent.
+     */
+    limit: number;
+    offset: number;
+};
+export type LibraryRecommendationsReply = {
+    result: RecommendationsResult;
+};
+/**
+ * Payload for the `search` request: free-text search across the connected gateway's library.
+ */
+export type LibrarySearch = {
+    query: string;
+    /**
+     * Restrict results to these item kinds. `None` searches every kind.
+     */
+    kinds: Array<ItemKind> | null;
+    /**
+     * Requested page size; the daemon clamps this to 100 regardless of the value sent.
+     */
+    limit: number;
+    offset: number;
+};
+export type LibrarySearchReply = {
+    result: SearchResult;
+};
+/**
+ * Open a streaming subscription. Daemon returns a `LogsSubscribeReply`
+ * with an opaque token; webapp passes the token to `LogsUnsubscribe`
+ * to release. Subscriptions are scoped to the WS connection - the
+ * daemon auto-releases on disconnect.
+ */
+export type LogsSubscribe = {
+    /**
+     * Reserved for selecting the log source; the daemon serves its own tracing stream regardless.
+     */
+    source: LogSource;
+    /**
+     * Allow-list of levels to include; an empty vector matches every level.
+     */
+    levels: Array<LogLevel>;
+    /**
+     * Case-sensitive substring match against `target` or `message`; `None` disables filtering.
+     */
+    filter: string | null;
+};
+/**
+ * Reply to `LogsSubscribe`.
+ */
+export type LogsSubscribeReply = {
+    /**
+     * Opaque handle; pass to `LogsUnsubscribe` to release the subscription.
+     */
+    token: string;
+};
+/**
+ * Pull a one-shot batch of recent log entries. The source, levels, and
+ * filter narrow the returned entries.
+ */
+export type LogsTail = {
+    /**
+     * Reserved for selecting the log source; the daemon serves its own tracing stream regardless.
+     */
+    source: LogSource;
+    /**
+     * Allow-list of levels to include; an empty vector matches every level.
+     */
+    levels: Array<LogLevel>;
+    /**
+     * Case-sensitive substring match against `target` or `message`; `None` disables filtering.
+     */
+    filter: string | null;
+    /**
+     * Caps how many of the most recent matching entries return, in chronological order.
+     */
+    maxLines: number;
+};
+/**
+ * Reply to `LogsTail`.
+ */
+export type LogsTailReply = {
+    /**
+     * Matching entries in chronological order (oldest first).
+     */
+    entries: Array<LogEntry>;
+};
+/**
+ * Release a log stream opened by `LogsSubscribe`. Fire-and-forget: unknown
+ * or malformed tokens are silently ignored rather than surfacing an error.
+ */
+export type LogsUnsubscribe = {
+    token: string;
+};
+/**
+ * Payload for `voice.muteMic`.
+ */
+export type MicMute = {
+    /**
+     * When true and a capture session is already in progress, let it
+     * keep running instead of cutting it short.
+     */
+    preserve: boolean;
+};
+/**
+ * Payload for `voice.unmuteMic`.
+ */
+export type MicUnmute = {
+    /**
+     * Accepted for symmetry with `MicMute`; the daemon ignores it on
+     * unmute.
+     */
+    preserve: boolean;
+};
+/**
+ * Payload for `net.fetch`: a single proxied HTTP request/response
+ * round-trip through the connected companion's network stack.
+ */
+export type NetFetch = {
+    request: NetFetchRequest;
+};
+/**
+ * Error response to `net.fetch`.
+ */
+export type NetFetchErrorReply = {
+    error: NetError;
+};
+/**
+ * Response to `net.fetch`.
+ */
+export type NetFetchReply = {
+    response: NetFetchResponse;
+};
+/**
+ * Payload for `net.stream.cancel`. Ignored by the daemon if
+ * `stream_id` isn't owned by the calling webapp.
+ */
+export type NetStreamCancel = {
+    streamId: string;
+};
+/**
+ * Payload for `net.stream.open`: like `fetch` but delivers the
+ * response body incrementally as `StreamChunk` events instead of one
+ * frame. `stream_id` is assigned by the webapp.
+ */
+export type NetStreamOpen = {
+    streamId: string;
+    request: NetFetchRequest;
+};
+/**
+ * Payload for `net.ws.close`. Ignored by the daemon if `connection_id`
+ * isn't owned by the calling webapp.
+ */
+export type NetWsClose = {
+    connectionId: string;
+    code: number | null;
+    reason: string | null;
+};
+/**
+ * The WebSocket closed, locally or by the remote end.
+ */
+export type NetWsClosed = {
+    connectionId: string;
+    code: number;
+    reason: string;
+};
+/**
+ * Asynchronous WebSocket failure after `net.ws.open` already
+ * succeeded.
+ */
+export type NetWsErrorEvent = {
+    connectionId: string;
+    error: WsError;
+};
+/**
+ * Error response to `net.ws.open`.
+ */
+export type NetWsErrorReply = {
+    error: WsError;
+};
+/**
+ * One inbound frame on an open WebSocket.
+ */
+export type NetWsMessage = {
+    connectionId: string;
+    frame: WsFrame;
+};
+/**
+ * Payload for `net.ws.open`: establish a WebSocket routed through the
+ * companion. `connection_id` is assigned by the webapp up front so
+ * inbound frame/close/error routing is wired before the companion's
+ * ack arrives.
+ */
+export type NetWsOpen = {
+    connectionId: string;
+    url: string;
+    /**
+     * Subprotocols offered to the server, in preference order.
+     */
+    protocols: Array<string> | null;
+    headers: Array<HttpHeader> | null;
+};
+/**
+ * Response to `net.ws.open`.
+ */
+export type NetWsOpenReply = {
+    /**
+     * The subprotocol the server selected, when `NetWsOpen.protocols`
+     * offered a list.
+     */
+    acceptedProtocol: string | null;
+};
+/**
+ * Payload for `net.ws.send`.
+ */
+export type NetWsSend = {
+    connectionId: string;
+    frame: WsFrame;
+};
+/**
+ * Payload for `invokePositive` and `invokeNegative`.
+ */
+export type NotificationInvoke = {
+    /**
+     * Notification id to act on, from `Notification.id`.
+     */
+    id: string;
+};
+export type NotificationRemoved = {
+    /**
+     * Id of the notification that was removed, from `Notification.id`.
+     */
+    id: string;
+    reason: DismissReason;
+};
+/**
+ * Map of MAC string to `Device`.
+ */
+export type PairedDevicesMap = {
+    [key in string]: Device;
+};
+/**
+ * Map of peer-id to `Peer`.
+ */
+export type PeerSnapshotMap = {
+    [key in string]: Peer;
+};
+/**
+ * Explicit-action variant of `Answer`. `Accept` (default) places any
+ * existing active call on hold; `EndAndAccept` ends the existing call
+ * first. Webapps gate on `CommunicationsState.hold_and_accept_available`
+ * or `end_and_accept_available` before sending the non-default action.
+ */
+export type PhoneAcceptAction = {
+    /**
+     * Target call, as surfaced on `PhoneCall.call_id`.
+     */
+    callId: string;
+    action: AcceptCallAction;
+};
+/**
+ * Payload for `answer`, `decline`, `end`, `hold`, and `unhold`: the call to act on.
+ */
+export type PhoneCallAction = {
+    /**
+     * Target call, as surfaced on `PhoneCall.call_id`.
+     */
+    callId: string;
+};
+export type PhoneCallEnded = {
+    /**
+     * Echoes `PhoneCall.call_id` for the call that just ended.
+     */
+    callId: string;
+    reason: CallEndReason;
+};
+/**
+ * Broadcast whenever `CommunicationsState` changes: signal, registration,
+ * or which call-control verbs are currently legal.
+ */
+export type PhoneCommunicationsReply = {
+    state: CommunicationsState;
+};
+/**
+ * Payload for `dtmf`: play a tone on an active call.
+ */
+export type PhoneDtmfAction = {
+    /**
+     * Call to send the tone on; `None` targets the active call.
+     */
+    callId: string | null;
+    tone: DtmfTone;
+};
+/**
+ * Explicit-action variant of `End`. `End` (default) ends the named
+ * call; `EndAll` ends every active call (multi-call / conference).
+ */
+export type PhoneEndAction = {
+    /**
+     * Target call, as surfaced on `PhoneCall.call_id`.
+     */
+    callId: string;
+    action: EndCallAction;
+};
+/**
+ * Response when a phone command could not be carried out.
+ */
+export type PhoneErrorReply = {
+    error: PhoneError;
+};
+/**
+ * Payload for `initiate`: place an outbound call.
+ */
+export type PhoneInitiateAction = {
+    /**
+     * What kind of outbound call to place.
+     */
+    kind: InitiateCallType;
+    /**
+     * Destination address (e.g. phone number) for `Destination` calls; ignored for `Voicemail`/`Redial`.
+     */
+    destinationId: string | null;
+    /**
+     * Call bearer to use; `None` lets the companion pick its default.
+     */
+    service: PhoneCallService | null;
+    /**
+     * Contact id to associate with the call, when known.
+     */
+    addressBookId: string | null;
+};
+/**
+ * Payload for `mute`: mic-mute state for the active call.
+ */
+export type PhoneMuteAction = {
+    /**
+     * `true` mutes the mic, `false` unmutes.
+     */
+    mute: boolean;
+};
+/**
+ * Response to `stateGet`.
+ */
+export type PhoneStateReply = {
+    state: PhoneState;
+};
+/**
+ * Payload for the `play` command.
+ */
+export type PlayUri = {
+    /**
+     * Resource to play, e.g. `spotify:track:...`; any uri scheme a connected gateway claims.
+     */
+    uri: string;
+    /**
+     * Optional album/playlist/show to play `uri` within, so next/prev follow that list.
+     */
+    context: PlayContext | null;
+};
+export type PlayerErrorReply = {
+    error: PlayerError;
+};
+/**
+ * Response to `queueGet`, also carried by the `QueueChanged` event.
+ */
+export type PlayerQueueReply = {
+    /**
+     * The now-playing track, when one is loaded.
+     */
+    current: QueueItem | null;
+    /**
+     * Upcoming tracks in queue order.
+     */
+    items: Array<QueueItem>;
+    /**
+     * Recently-played history.
+     */
+    previous: Array<QueueItem>;
+};
+/**
+ * Response to `stateGet`, also carried by the `Snapshot` event.
+ */
+export type PlayerStateReply = {
+    state: PlayerState;
+    /**
+     * The app currently driving playback, when known (iOS surfaces this over iAP2).
+     */
+    activeApp: CurrentlyActiveApplication | null;
+};
+/**
+ * Payload for the `queue` command.
+ */
+export type QueueUri = {
+    /**
+     * Resource to enqueue.
+     */
+    uri: string;
+    /**
+     * Where in the queue it lands (append / next / explicit index).
+     */
+    position: QueuePosition;
+};
+/**
+ * Payload for `seekTo`: jump to an absolute playhead position.
+ */
+export type SeekTo = {
+    /**
+     * Target playhead in milliseconds from track start.
+     */
+    positionMs: number;
+};
+/**
+ * Payload for `bluetooth.setAlias`: rename the device's own adapter
+ * as seen by peers during discovery and pairing.
+ */
+export type SetBluetoothAlias = {
+    name: string;
+};
+/**
+ * Payload for `setCrossfade`.
+ */
+export type SetCrossfade = {
+    /**
+     * Crossfade duration in milliseconds; `None` turns crossfade off.
+     */
+    durationMs: number | null;
+};
+/**
+ * Payload for `setMute`.
+ */
+export type SetMute = {
+    /**
+     * `true` mutes output, `false` unmutes.
+     */
+    muted: boolean;
+};
+/**
+ * Payload for `setRepeat`.
+ */
+export type SetRepeat = {
+    /**
+     * Desired repeat mode (off / all / one).
+     */
+    mode: RepeatMode;
+};
+/**
+ * Payload for `setShuffle`.
+ */
+export type SetShuffle = {
+    /**
+     * Desired shuffle state.
+     */
+    on: boolean;
+};
+/**
+ * Payload for `setSpeed`. Honored only by gateways that support rate control.
+ */
+export type SetSpeed = {
+    /**
+     * Playback rate; 1.0 is normal speed.
+     */
+    speed: number;
+};
+/**
+ * Payload for `setVolume`.
+ */
+export type SetVolume = {
+    /**
+     * Absolute output level, `0.0` (silent) to `1.0` (max).
+     */
+    level: number;
+};
+/**
+ * Payload for `skipPrev`: go to the previous track, or restart the current one.
+ */
+export type SkipPrev = {
+    /**
+     * When true, restart the current track if it is progressed past the restart threshold; otherwise always move to the previous track.
+     */
+    allowSeeking: boolean;
+};
+/**
+ * Payload for `skipToIndex`: jump to a specific row in the current queue.
+ */
+export type SkipToIndex = {
+    /**
+     * 0-based index into the queue.
+     */
+    index: number;
+};
+/**
+ * Reply to `KVGet`, `KVPut`, and `KVDelete` alike; the request that
+ * produced it distinguishes which operation happened.
+ */
+export type StorageResponse = {
+    key: string;
+    /**
+     * `None` on a `Get` miss or after a `Delete`; `Put` always echoes back `Some` of what it just wrote.
+     */
+    value: string | null;
+};
+/**
+ * Wraps `TimeInfo` for the wire; used as both the `time.get` reply and
+ * the `Changed` event payload.
+ */
+export type TimeSnapshot = {
+    time: TimeInfo;
+};
+/**
+ * Fire-and-forget TTS request. `id` is webapp-assigned and used both
+ * for cancellation and for matching back-to-back `TtsStarted`/`TtsEnded`
+ * events. `voice` selects from `AudioCapabilities.voices`; `None` uses
+ * the gateway default.
+ */
+export type Tts = {
+    id: string;
+    text: string;
+    voice: string | null;
+};
+/**
+ * Payload for `ttsCancel`.
+ */
+export type TtsCancel = {
+    /**
+     * Id of the in-flight `Tts` request to cancel, as passed to `Tts.id`.
+     */
+    id: string;
+};
+/**
+ * Fired when a `Tts` request stops playing, whether it finished or was cut short.
+ */
+export type TtsEnded = {
+    /**
+     * Echoes `Tts.id`.
+     */
+    id: string;
+    /**
+     * `true` if playback finished naturally; `false` if cancelled or interrupted.
+     */
+    completed: boolean;
+};
+/**
+ * Fired when a `Tts` request begins audibly playing.
+ */
+export type TtsStarted = {
+    /**
+     * Echoes `Tts.id`.
+     */
+    id: string;
+};
+/**
+ * Current mic state.
+ */
+export type VoiceState = {
+    muted: boolean;
+    /**
+     * True while a capture session is actively recording.
+     */
+    capturing: boolean;
+};
+/**
+ * Response to `voice.stateGet`.
+ */
+export type VoiceStateReply = {
+    state: VoiceState;
+};
+/**
+ * Current output level and mute state, broadcast after any change
+ * regardless of whether this webapp issued the command.
+ */
+export type VolumeChanged = {
+    /**
+     * Absolute output level, `0.0` (silent) to `1.0` (max).
+     */
+    level: number;
+    muted: boolean;
+};
+/**
+ * Payload for the `activate` request: switch the kiosk to the given webapp. The kiosk runs
+ * exactly one webapp at a time, so the daemon navigates it away from whatever was previously
+ * active.
+ */
+export type WebappActivate = {
+    /**
+     * Id of an installed webapp, from `webapp.list`.
+     */
+    id: string;
+};
+/**
+ * Broadcast when the active webapp changes; carries the new active webapp's name.
+ */
+export type WebappActiveChanged = {
+    name: string;
+};
+export type WebappActiveReply = {
+    /**
+     * Id of the webapp that was just activated.
+     */
+    id: string | null;
+    name: string | null;
+};
+export type WebappCurrentReply = {
+    /**
+     * `None` when no webapp is currently active in the kiosk.
+     */
+    id: string | null;
+    name: string | null;
+};
+/**
+ * Fetch the icon bytes for an installed webapp. Returns the raw bytes
+ * declared by the manifest's `icon` field.
+ */
+export type WebappIcon = {
+    /**
+     * Id of an installed webapp, from `webapp.list`.
+     */
+    id: string;
+};
+/**
+ * Reply to the `icon` request: the raw icon bytes declared by the webapp's manifest.
+ */
+export type WebappIconReply = {
+    bytes: Uint8Array;
+    /**
+     * MIME type declared by the manifest's icon; `None` if the manifest didn't declare one.
+     */
+    mime: string | null;
+};
+export type WebappListReply = {
+    /**
+     * Excludes `Launcher`-role bundles used as alternate home screens.
+     */
+    webapps: Array<WebappInfo>;
+};
+/**
+ * Broadcast when an installed webapp is removed; carries the removed webapp's name.
+ */
+export type WebappUninstalled = {
+    name: string;
+};
+//# sourceMappingURL=client.d.ts.map