@bridgething/client 0.1.2

package/dist/dispatch.generated.d.ts

@@ -0,0 +1,805 @@
+import type { BridgeThingMeta, BrightnessState, LogEntry, Notification, NowPlayingUpdate, OtaError, OtaProgress, PhoneCall, Position, StreamBegin, StreamChunk, StreamEnd, StreamError, WebappError, WebappInfo, WireError } from '@bridgething/lib';
+import type { AmbientLightUpdate, AssetCleared, AssetGet, AssetGot, AssetNotFound, AssetPreload, AssetReady, BluetoothInterface, BluetoothPairingResult, BluetoothPin, BluetoothStatus, CapabilitiesSnapshot, ConfigChanged, ConfigGet, ConfigGetReply, ConfigListReply, ConnectBluetooth, ConnectedDevice, DeviceNicknameReply, DiagnosticsReply, DisplaySetLevel, DisplaySetMode, Earcon, FavoriteChanged, FavoritesSet, FavoritesSetMany, FavoritesToggle, ForgetBluetooth, GeoErrorReply, GeoGetOnce, GeoGetOnceReply, GeoUnwatch, GeoWatch, GeoWatchReply, HardwareStateReply, KVDelete, KVGet, KVPut, LibraryBrowse, LibraryBrowseReply, LibraryErrorReply, LibraryFavoritesContains, LibraryFavoritesContainsReply, LibraryFavoritesList, LibraryFavoritesListReply, LibraryRecommendations, LibraryRecommendationsReply, LibrarySearch, LibrarySearchReply, LogsSubscribe, LogsSubscribeReply, LogsTail, LogsTailReply, LogsUnsubscribe, MicMute, MicUnmute, NetFetch, NetFetchErrorReply, NetFetchReply, NetStreamCancel, NetStreamOpen, NetWsClose, NetWsClosed, NetWsErrorEvent, NetWsErrorReply, NetWsMessage, NetWsOpen, NetWsOpenReply, NetWsSend, NotificationInvoke, NotificationRemoved, PairedDevicesMap, PeerSnapshotMap, PhoneAcceptAction, PhoneCallAction, PhoneCallEnded, PhoneCommunicationsReply, PhoneDtmfAction, PhoneEndAction, PhoneErrorReply, PhoneInitiateAction, PhoneMuteAction, PhoneStateReply, PlayUri, PlayerErrorReply, PlayerQueueReply, PlayerStateReply, QueueUri, SeekTo, SetBluetoothAlias, SetCrossfade, SetMute, SetRepeat, SetShuffle, SetSpeed, SetVolume, SkipPrev, SkipToIndex, StorageResponse, TimeSnapshot, Tts, TtsCancel, TtsEnded, TtsStarted, VoiceState, VoiceStateReply, VolumeChanged, WebappActivate, WebappActiveChanged, WebappActiveReply, WebappCurrentReply, WebappIcon, WebappIconReply, WebappListReply, WebappUninstalled } from '@bridgething/lib/client';
+import { BridgethingClient } from './index';
+export type TypedRequestResult<R, E> = {
+    ok: true;
+    response: R;
+} | {
+    ok: false;
+    kind: 'domain';
+    error: E;
+} | {
+    ok: false;
+    kind: 'protocol';
+    error: WireError;
+};
+export type AssetInboundHandlers = {
+    got: (msg: AssetGot) => void;
+    notFound: (msg: AssetNotFound) => void;
+    ready: (msg: AssetReady) => void;
+    cleared: (msg: AssetCleared) => void;
+};
+export type AudioInboundHandlers = {
+    ttsStarted: (msg: TtsStarted) => void;
+    ttsEnded: (msg: TtsEnded) => void;
+    volumeChanged: (msg: VolumeChanged) => void;
+};
+export type BluetoothInboundHandlers = {
+    status: (msg: BluetoothStatus) => void;
+    connectedDevice: (msg: ConnectedDevice) => void;
+    interface: (msg: BluetoothInterface) => void;
+    pairingResult: (msg: BluetoothPairingResult) => void;
+    pin: (msg: BluetoothPin) => void;
+    pairedDevices: (msg: PairedDevicesMap) => void;
+};
+export type CapabilitiesInboundHandlers = {
+    update: (msg: CapabilitiesSnapshot) => void;
+    snapshot: (msg: CapabilitiesSnapshot) => void;
+};
+export type ConfigInboundHandlers = {
+    get: (msg: ConfigGetReply) => void;
+    list: (msg: ConfigListReply) => void;
+    changed: (msg: ConfigChanged) => void;
+};
+export type GeoInboundHandlers = {
+    position: (msg: Position) => void;
+    watchReply: (msg: GeoWatchReply) => void;
+    getOnceReply: (msg: GeoGetOnceReply) => void;
+    errorReply: (msg: GeoErrorReply) => void;
+};
+export type HardwareInboundHandlers = {
+    ambientLightUpdate: (msg: AmbientLightUpdate) => void;
+    brightnessChanged: (msg: BrightnessState) => void;
+    stateReply: (msg: HardwareStateReply) => void;
+};
+export type LibraryInboundHandlers = {
+    browseReply: (msg: LibraryBrowseReply) => void;
+    searchReply: (msg: LibrarySearchReply) => void;
+    recommendationsReply: (msg: LibraryRecommendationsReply) => void;
+    favoritesListReply: (msg: LibraryFavoritesListReply) => void;
+    favoritesContainsReply: (msg: LibraryFavoritesContainsReply) => void;
+    libraryErrorReply: (msg: LibraryErrorReply) => void;
+    favoriteChanged: (msg: FavoriteChanged) => void;
+};
+export type NetInboundHandlers = {
+    fetchReply: (msg: NetFetchReply) => void;
+    fetchErrorReply: (msg: NetFetchErrorReply) => void;
+    wsOpenReply: (msg: NetWsOpenReply) => void;
+    wsErrorReply: (msg: NetWsErrorReply) => void;
+    wsMessage: (msg: NetWsMessage) => void;
+    wsClosed: (msg: NetWsClosed) => void;
+    wsErrorEvent: (msg: NetWsErrorEvent) => void;
+    streamBegin: (msg: StreamBegin) => void;
+    streamChunk: (msg: StreamChunk) => void;
+    streamEnd: (msg: StreamEnd) => void;
+    streamError: (msg: StreamError) => void;
+};
+export type NotificationsInboundHandlers = {
+    posted: (msg: Notification) => void;
+    updated: (msg: Notification) => void;
+    removed: (msg: NotificationRemoved) => void;
+};
+export type PhoneInboundHandlers = {
+    callStarted: (msg: PhoneCall) => void;
+    callUpdated: (msg: PhoneCall) => void;
+    callEnded: (msg: PhoneCallEnded) => void;
+    communicationsChanged: (msg: PhoneCommunicationsReply) => void;
+    stateReply: (msg: PhoneStateReply) => void;
+    errorReply: (msg: PhoneErrorReply) => void;
+};
+export type PlayerInboundHandlers = {
+    snapshot: (msg: PlayerStateReply) => void;
+    delta: (msg: NowPlayingUpdate) => void;
+    queueChanged: (msg: PlayerQueueReply) => void;
+    stateReply: (msg: PlayerStateReply) => void;
+    queueReply: (msg: PlayerQueueReply) => void;
+    errorReply: (msg: PlayerErrorReply) => void;
+};
+export type SystemInboundHandlers = {
+    version: (msg: BridgeThingMeta) => void;
+    diagnosticsReply: (msg: DiagnosticsReply) => void;
+    logsTailReply: (msg: LogsTailReply) => void;
+    logsSubscribeReply: (msg: LogsSubscribeReply) => void;
+    logEntry: (msg: LogEntry) => void;
+    otaProgress: (msg: OtaProgress) => void;
+    otaError: (msg: OtaError) => void;
+    deviceNickname: (msg: DeviceNicknameReply) => void;
+    deviceNicknameChanged: (msg: DeviceNicknameReply) => void;
+};
+export type TimeInboundHandlers = {
+    changed: (msg: TimeSnapshot) => void;
+    snapshot: (msg: TimeSnapshot) => void;
+};
+export type VoiceInboundHandlers = {
+    stateChanged: (msg: VoiceState) => void;
+    stateReply: (msg: VoiceStateReply) => void;
+};
+export type WebappInboundHandlers = {
+    listReply: (msg: WebappListReply) => void;
+    currentReply: (msg: WebappCurrentReply) => void;
+    activeReply: (msg: WebappActiveReply) => void;
+    iconReply: (msg: WebappIconReply) => void;
+    webappError: (msg: WebappError) => void;
+    activeChanged: (msg: WebappActiveChanged) => void;
+    webappInstalled: (msg: WebappInfo) => void;
+    webappUninstalled: (msg: WebappUninstalled) => void;
+};
+export type ForwardInboundHandlers = {
+    text: (msg: string) => void;
+    json: (msg: unknown) => void;
+    binary: (msg: Uint8Array) => void;
+};
+export declare class AssetSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Asset::Got` from the daemon. */
+    onGot(handler: (msg: AssetGot) => void): () => void;
+    /** Subscribe to `Asset::NotFound` from the daemon. */
+    onNotFound(handler: (msg: AssetNotFound) => void): () => void;
+    /** Subscribe to `Asset::Ready` from the daemon. */
+    onReady(handler: (msg: AssetReady) => void): () => void;
+    /** Subscribe to `Asset::Cleared` from the daemon. */
+    onCleared(handler: (msg: AssetCleared) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Asset` variants. */
+    subscribe(handlers: AssetInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<AssetInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Asset::Preload` to the daemon. */
+    preload(payload: AssetPreload): Promise<void>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    get(req: AssetGet, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<AssetGot, AssetNotFound>>;
+}
+export declare class AudioSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Audio::TtsStarted` from the daemon. */
+    onTtsStarted(handler: (msg: TtsStarted) => void): () => void;
+    /** Subscribe to `Audio::TtsEnded` from the daemon. */
+    onTtsEnded(handler: (msg: TtsEnded) => void): () => void;
+    /** Subscribe to `Audio::VolumeChanged` from the daemon. */
+    onVolumeChanged(handler: (msg: VolumeChanged) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Audio` variants. */
+    subscribe(handlers: AudioInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<AudioInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Audio::VolumeUp` to the daemon. */
+    volumeUp(): Promise<void>;
+    /** Send `Audio::VolumeDown` to the daemon. */
+    volumeDown(): Promise<void>;
+    /** Send `Audio::SetVolume` to the daemon. */
+    setVolume(payload: SetVolume): Promise<void>;
+    /** Send `Audio::MuteToggle` to the daemon. */
+    muteToggle(): Promise<void>;
+    /** Send `Audio::SetMute` to the daemon. */
+    setMute(payload: SetMute): Promise<void>;
+    /** Send `Audio::Tts` to the daemon. */
+    tts(payload: Tts): Promise<void>;
+    /** Send `Audio::TtsCancel` to the daemon. */
+    ttsCancel(payload: TtsCancel): Promise<void>;
+    /** Send `Audio::TtsCancelAll` to the daemon. */
+    ttsCancelAll(): Promise<void>;
+    /** Send `Audio::Earcon` to the daemon. */
+    earcon(payload: Earcon): Promise<void>;
+}
+export declare class BluetoothSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Bluetooth::Status` from the daemon. */
+    onStatus(handler: (msg: BluetoothStatus) => void): () => void;
+    /** Subscribe to `Bluetooth::ConnectedDevice` from the daemon. */
+    onConnectedDevice(handler: (msg: ConnectedDevice) => void): () => void;
+    /** Subscribe to `Bluetooth::Interface` from the daemon. */
+    onInterface(handler: (msg: BluetoothInterface) => void): () => void;
+    /** Subscribe to `Bluetooth::PairingResult` from the daemon. */
+    onPairingResult(handler: (msg: BluetoothPairingResult) => void): () => void;
+    /** Subscribe to `Bluetooth::Pin` from the daemon. */
+    onPin(handler: (msg: BluetoothPin) => void): () => void;
+    /** Subscribe to `Bluetooth::PairedDevices` from the daemon. */
+    onPairedDevices(handler: (msg: PairedDevicesMap) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Bluetooth` variants. */
+    subscribe(handlers: BluetoothInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<BluetoothInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Bluetooth::Connect` to the daemon. */
+    connect(payload: ConnectBluetooth): Promise<void>;
+    /** Send `Bluetooth::EnableDiscoverable` to the daemon. */
+    enableDiscoverable(): Promise<void>;
+    /** Send `Bluetooth::DisableDiscoverable` to the daemon. */
+    disableDiscoverable(): Promise<void>;
+    /** Send `Bluetooth::Forget` to the daemon. */
+    forget(payload: ForgetBluetooth): Promise<void>;
+    /** Send `Bluetooth::SetAlias` to the daemon. */
+    setAlias(payload: SetBluetoothAlias): Promise<void>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    list(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<PairedDevicesMap, never>>;
+}
+export declare class CapabilitiesSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Capabilities::Update` from the daemon. */
+    onUpdate(handler: (msg: CapabilitiesSnapshot) => void): () => void;
+    /** Subscribe to `Capabilities::Snapshot` from the daemon. */
+    onSnapshot(handler: (msg: CapabilitiesSnapshot) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Capabilities` variants. */
+    subscribe(handlers: CapabilitiesInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<CapabilitiesInboundHandlers>): () => void;
+    private _subscribe;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    get(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<CapabilitiesSnapshot, never>>;
+}
+export declare class ConfigSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Config::Get` from the daemon. */
+    onGet(handler: (msg: ConfigGetReply) => void): () => void;
+    /** Subscribe to `Config::List` from the daemon. */
+    onList(handler: (msg: ConfigListReply) => void): () => void;
+    /** Subscribe to `Config::Changed` from the daemon. */
+    onChanged(handler: (msg: ConfigChanged) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Config` variants. */
+    subscribe(handlers: ConfigInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<ConfigInboundHandlers>): () => void;
+    private _subscribe;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    get(req: ConfigGet, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<ConfigGetReply, never>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    list(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<ConfigListReply, never>>;
+}
+export declare class GeoSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Geo::Position` from the daemon. */
+    onPosition(handler: (msg: Position) => void): () => void;
+    /** Subscribe to `Geo::WatchReply` from the daemon. */
+    onWatchReply(handler: (msg: GeoWatchReply) => void): () => void;
+    /** Subscribe to `Geo::GetOnceReply` from the daemon. */
+    onGetOnceReply(handler: (msg: GeoGetOnceReply) => void): () => void;
+    /** Subscribe to `Geo::ErrorReply` from the daemon. */
+    onErrorReply(handler: (msg: GeoErrorReply) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Geo` variants. */
+    subscribe(handlers: GeoInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<GeoInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Geo::Unwatch` to the daemon. */
+    unwatch(payload: GeoUnwatch): Promise<void>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    watch(req: GeoWatch, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<GeoWatchReply, GeoErrorReply>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    getOnce(req: GeoGetOnce, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<GeoGetOnceReply, GeoErrorReply>>;
+}
+export declare class HardwareSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Hardware::AmbientLightUpdate` from the daemon. */
+    onAmbientLightUpdate(handler: (msg: AmbientLightUpdate) => void): () => void;
+    /** Subscribe to `Hardware::BrightnessChanged` from the daemon. */
+    onBrightnessChanged(handler: (msg: BrightnessState) => void): () => void;
+    /** Subscribe to `Hardware::StateReply` from the daemon. */
+    onStateReply(handler: (msg: HardwareStateReply) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Hardware` variants. */
+    subscribe(handlers: HardwareInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<HardwareInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Hardware::DisplaySetMode` to the daemon. */
+    displaySetMode(payload: DisplaySetMode): Promise<void>;
+    /** Send `Hardware::DisplaySetLevel` to the daemon. */
+    displaySetLevel(payload: DisplaySetLevel): Promise<void>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    stateGet(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<HardwareStateReply, never>>;
+}
+export declare class LibrarySurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Library::BrowseReply` from the daemon. */
+    onBrowseReply(handler: (msg: LibraryBrowseReply) => void): () => void;
+    /** Subscribe to `Library::SearchReply` from the daemon. */
+    onSearchReply(handler: (msg: LibrarySearchReply) => void): () => void;
+    /** Subscribe to `Library::RecommendationsReply` from the daemon. */
+    onRecommendationsReply(handler: (msg: LibraryRecommendationsReply) => void): () => void;
+    /** Subscribe to `Library::FavoritesListReply` from the daemon. */
+    onFavoritesListReply(handler: (msg: LibraryFavoritesListReply) => void): () => void;
+    /** Subscribe to `Library::FavoritesContainsReply` from the daemon. */
+    onFavoritesContainsReply(handler: (msg: LibraryFavoritesContainsReply) => void): () => void;
+    /** Subscribe to `Library::LibraryErrorReply` from the daemon. */
+    onLibraryErrorReply(handler: (msg: LibraryErrorReply) => void): () => void;
+    /** Subscribe to `Library::FavoriteChanged` from the daemon. */
+    onFavoriteChanged(handler: (msg: FavoriteChanged) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Library` variants. */
+    subscribe(handlers: LibraryInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<LibraryInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Library::FavoritesToggle` to the daemon. */
+    favoritesToggle(payload: FavoritesToggle): Promise<void>;
+    /** Send `Library::FavoritesSet` to the daemon. */
+    favoritesSet(payload: FavoritesSet): Promise<void>;
+    /** Send `Library::FavoritesSetMany` to the daemon. */
+    favoritesSetMany(payload: FavoritesSetMany): Promise<void>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    browse(req: LibraryBrowse, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<LibraryBrowseReply, LibraryErrorReply>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    search(req: LibrarySearch, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<LibrarySearchReply, LibraryErrorReply>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    recommendations(req: LibraryRecommendations, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<LibraryRecommendationsReply, LibraryErrorReply>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    favoritesList(req: LibraryFavoritesList, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<LibraryFavoritesListReply, LibraryErrorReply>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    favoritesContains(req: LibraryFavoritesContains, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<LibraryFavoritesContainsReply, LibraryErrorReply>>;
+}
+export declare class NetSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Net::FetchReply` from the daemon. */
+    onFetchReply(handler: (msg: NetFetchReply) => void): () => void;
+    /** Subscribe to `Net::FetchErrorReply` from the daemon. */
+    onFetchErrorReply(handler: (msg: NetFetchErrorReply) => void): () => void;
+    /** Subscribe to `Net::WsOpenReply` from the daemon. */
+    onWsOpenReply(handler: (msg: NetWsOpenReply) => void): () => void;
+    /** Subscribe to `Net::WsErrorReply` from the daemon. */
+    onWsErrorReply(handler: (msg: NetWsErrorReply) => void): () => void;
+    /** Subscribe to `Net::WsMessage` from the daemon. */
+    onWsMessage(handler: (msg: NetWsMessage) => void): () => void;
+    /** Subscribe to `Net::WsClosed` from the daemon. */
+    onWsClosed(handler: (msg: NetWsClosed) => void): () => void;
+    /** Subscribe to `Net::WsErrorEvent` from the daemon. */
+    onWsErrorEvent(handler: (msg: NetWsErrorEvent) => void): () => void;
+    /** Subscribe to `Net::StreamBegin` from the daemon. */
+    onStreamBegin(handler: (msg: StreamBegin) => void): () => void;
+    /** Subscribe to `Net::StreamChunk` from the daemon. */
+    onStreamChunk(handler: (msg: StreamChunk) => void): () => void;
+    /** Subscribe to `Net::StreamEnd` from the daemon. */
+    onStreamEnd(handler: (msg: StreamEnd) => void): () => void;
+    /** Subscribe to `Net::StreamError` from the daemon. */
+    onStreamError(handler: (msg: StreamError) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Net` variants. */
+    subscribe(handlers: NetInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<NetInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Net::WsClose` to the daemon. */
+    wsClose(payload: NetWsClose): Promise<void>;
+    /** Send `Net::WsSend` to the daemon. */
+    wsSend(payload: NetWsSend): Promise<void>;
+    /** Send `Net::StreamOpen` to the daemon. */
+    streamOpen(payload: NetStreamOpen): Promise<void>;
+    /** Send `Net::StreamCancel` to the daemon. */
+    streamCancel(payload: NetStreamCancel): Promise<void>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    fetch(req: NetFetch, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<NetFetchReply, NetFetchErrorReply>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    wsOpen(req: NetWsOpen, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<NetWsOpenReply, NetWsErrorReply>>;
+}
+export declare class NotificationsSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Notifications::Posted` from the daemon. */
+    onPosted(handler: (msg: Notification) => void): () => void;
+    /** Subscribe to `Notifications::Updated` from the daemon. */
+    onUpdated(handler: (msg: Notification) => void): () => void;
+    /** Subscribe to `Notifications::Removed` from the daemon. */
+    onRemoved(handler: (msg: NotificationRemoved) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Notifications` variants. */
+    subscribe(handlers: NotificationsInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<NotificationsInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Notifications::InvokePositive` to the daemon. */
+    invokePositive(payload: NotificationInvoke): Promise<void>;
+    /** Send `Notifications::InvokeNegative` to the daemon. */
+    invokeNegative(payload: NotificationInvoke): Promise<void>;
+}
+export declare class PeerSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Peer::Snapshot` from the daemon. */
+    onSnapshot(handler: (msg: PeerSnapshotMap) => void): () => void;
+}
+export declare class PhoneSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Phone::CallStarted` from the daemon. */
+    onCallStarted(handler: (msg: PhoneCall) => void): () => void;
+    /** Subscribe to `Phone::CallUpdated` from the daemon. */
+    onCallUpdated(handler: (msg: PhoneCall) => void): () => void;
+    /** Subscribe to `Phone::CallEnded` from the daemon. */
+    onCallEnded(handler: (msg: PhoneCallEnded) => void): () => void;
+    /** Subscribe to `Phone::CommunicationsChanged` from the daemon. */
+    onCommunicationsChanged(handler: (msg: PhoneCommunicationsReply) => void): () => void;
+    /** Subscribe to `Phone::StateReply` from the daemon. */
+    onStateReply(handler: (msg: PhoneStateReply) => void): () => void;
+    /** Subscribe to `Phone::ErrorReply` from the daemon. */
+    onErrorReply(handler: (msg: PhoneErrorReply) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Phone` variants. */
+    subscribe(handlers: PhoneInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<PhoneInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Phone::Answer` to the daemon. */
+    answer(payload: PhoneCallAction): Promise<void>;
+    /** Send `Phone::Accept` to the daemon. */
+    accept(payload: PhoneAcceptAction): Promise<void>;
+    /** Send `Phone::Decline` to the daemon. */
+    decline(payload: PhoneCallAction): Promise<void>;
+    /** Send `Phone::End` to the daemon. */
+    end(payload: PhoneCallAction): Promise<void>;
+    /** Send `Phone::EndTyped` to the daemon. */
+    endTyped(payload: PhoneEndAction): Promise<void>;
+    /** Send `Phone::Hold` to the daemon. */
+    hold(payload: PhoneCallAction): Promise<void>;
+    /** Send `Phone::Unhold` to the daemon. */
+    unhold(payload: PhoneCallAction): Promise<void>;
+    /** Send `Phone::Initiate` to the daemon. */
+    initiate(payload: PhoneInitiateAction): Promise<void>;
+    /** Send `Phone::Swap` to the daemon. */
+    swap(): Promise<void>;
+    /** Send `Phone::Merge` to the daemon. */
+    merge(): Promise<void>;
+    /** Send `Phone::Mute` to the daemon. */
+    mute(payload: PhoneMuteAction): Promise<void>;
+    /** Send `Phone::Dtmf` to the daemon. */
+    dtmf(payload: PhoneDtmfAction): Promise<void>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    stateGet(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<PhoneStateReply, never>>;
+}
+export declare class PlayerSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Player::Snapshot` from the daemon. */
+    onSnapshot(handler: (msg: PlayerStateReply) => void): () => void;
+    /** Subscribe to `Player::Delta` from the daemon. */
+    onDelta(handler: (msg: NowPlayingUpdate) => void): () => void;
+    /** Subscribe to `Player::QueueChanged` from the daemon. */
+    onQueueChanged(handler: (msg: PlayerQueueReply) => void): () => void;
+    /** Subscribe to `Player::StateReply` from the daemon. */
+    onStateReply(handler: (msg: PlayerStateReply) => void): () => void;
+    /** Subscribe to `Player::QueueReply` from the daemon. */
+    onQueueReply(handler: (msg: PlayerQueueReply) => void): () => void;
+    /** Subscribe to `Player::ErrorReply` from the daemon. */
+    onErrorReply(handler: (msg: PlayerErrorReply) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Player` variants. */
+    subscribe(handlers: PlayerInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<PlayerInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Player::Play` to the daemon. */
+    play(payload: PlayUri): Promise<void>;
+    /** Send `Player::Queue` to the daemon. */
+    queue(payload: QueueUri): Promise<void>;
+    /** Send `Player::Pause` to the daemon. */
+    pause(): Promise<void>;
+    /** Send `Player::Resume` to the daemon. */
+    resume(): Promise<void>;
+    /** Send `Player::SkipNext` to the daemon. */
+    skipNext(): Promise<void>;
+    /** Send `Player::SkipPrev` to the daemon. */
+    skipPrev(payload: SkipPrev): Promise<void>;
+    /** Send `Player::SkipToIndex` to the daemon. */
+    skipToIndex(payload: SkipToIndex): Promise<void>;
+    /** Send `Player::SeekTo` to the daemon. */
+    seekTo(payload: SeekTo): Promise<void>;
+    /** Send `Player::SetShuffle` to the daemon. */
+    setShuffle(payload: SetShuffle): Promise<void>;
+    /** Send `Player::SetRepeat` to the daemon. */
+    setRepeat(payload: SetRepeat): Promise<void>;
+    /** Send `Player::SetSpeed` to the daemon. */
+    setSpeed(payload: SetSpeed): Promise<void>;
+    /** Send `Player::SetCrossfade` to the daemon. */
+    setCrossfade(payload: SetCrossfade): Promise<void>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    stateGet(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<PlayerStateReply, never>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    queueGet(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<PlayerQueueReply, never>>;
+}
+export declare class SystemSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `System::Version` from the daemon. */
+    onVersion(handler: (msg: BridgeThingMeta) => void): () => void;
+    /** Subscribe to `System::DiagnosticsReply` from the daemon. */
+    onDiagnosticsReply(handler: (msg: DiagnosticsReply) => void): () => void;
+    /** Subscribe to `System::LogsTailReply` from the daemon. */
+    onLogsTailReply(handler: (msg: LogsTailReply) => void): () => void;
+    /** Subscribe to `System::LogsSubscribeReply` from the daemon. */
+    onLogsSubscribeReply(handler: (msg: LogsSubscribeReply) => void): () => void;
+    /** Subscribe to `System::LogEntry` from the daemon. */
+    onLogEntry(handler: (msg: LogEntry) => void): () => void;
+    /** Subscribe to `System::OtaProgress` from the daemon. */
+    onOtaProgress(handler: (msg: OtaProgress) => void): () => void;
+    /** Subscribe to `System::OtaError` from the daemon. */
+    onOtaError(handler: (msg: OtaError) => void): () => void;
+    /** Subscribe to `System::DeviceNickname` from the daemon. */
+    onDeviceNickname(handler: (msg: DeviceNicknameReply) => void): () => void;
+    /** Subscribe to `System::DeviceNicknameChanged` from the daemon. */
+    onDeviceNicknameChanged(handler: (msg: DeviceNicknameReply) => void): () => void;
+    /** Exhaustive subscribe over all inbound `System` variants. */
+    subscribe(handlers: SystemInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<SystemInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `System::LogsUnsubscribe` to the daemon. */
+    logsUnsubscribe(payload: LogsUnsubscribe): Promise<void>;
+    /** Send `System::Reboot` to the daemon. */
+    reboot(): Promise<void>;
+    /** Send `System::PowerOff` to the daemon. */
+    powerOff(): Promise<void>;
+    /** Send `System::FactoryReset` to the daemon. */
+    factoryReset(): Promise<void>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    versionRequest(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<BridgeThingMeta, never>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    diagnosticsGet(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<DiagnosticsReply, never>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    logsTail(req: LogsTail, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<LogsTailReply, never>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    logsSubscribe(req: LogsSubscribe, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<LogsSubscribeReply, never>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    deviceGetNickname(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<DeviceNicknameReply, never>>;
+}
+export declare class TimeSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Time::Changed` from the daemon. */
+    onChanged(handler: (msg: TimeSnapshot) => void): () => void;
+    /** Subscribe to `Time::Snapshot` from the daemon. */
+    onSnapshot(handler: (msg: TimeSnapshot) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Time` variants. */
+    subscribe(handlers: TimeInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<TimeInboundHandlers>): () => void;
+    private _subscribe;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    get(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<TimeSnapshot, never>>;
+}
+export declare class VoiceSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Voice::StateChanged` from the daemon. */
+    onStateChanged(handler: (msg: VoiceState) => void): () => void;
+    /** Subscribe to `Voice::StateReply` from the daemon. */
+    onStateReply(handler: (msg: VoiceStateReply) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Voice` variants. */
+    subscribe(handlers: VoiceInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<VoiceInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Voice::Cancel` to the daemon. */
+    cancel(): Promise<void>;
+    /** Send `Voice::PushToTalk` to the daemon. */
+    pushToTalk(): Promise<void>;
+    /** Send `Voice::MuteMic` to the daemon. */
+    muteMic(payload: MicMute): Promise<void>;
+    /** Send `Voice::UnmuteMic` to the daemon. */
+    unmuteMic(payload: MicUnmute): Promise<void>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    stateGet(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<VoiceStateReply, never>>;
+}
+export declare class WebappSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Webapp::ListReply` from the daemon. */
+    onListReply(handler: (msg: WebappListReply) => void): () => void;
+    /** Subscribe to `Webapp::CurrentReply` from the daemon. */
+    onCurrentReply(handler: (msg: WebappCurrentReply) => void): () => void;
+    /** Subscribe to `Webapp::ActiveReply` from the daemon. */
+    onActiveReply(handler: (msg: WebappActiveReply) => void): () => void;
+    /** Subscribe to `Webapp::IconReply` from the daemon. */
+    onIconReply(handler: (msg: WebappIconReply) => void): () => void;
+    /** Subscribe to `Webapp::WebappError` from the daemon. */
+    onWebappError(handler: (msg: WebappError) => void): () => void;
+    /** Subscribe to `Webapp::ActiveChanged` from the daemon. */
+    onActiveChanged(handler: (msg: WebappActiveChanged) => void): () => void;
+    /** Subscribe to `Webapp::WebappInstalled` from the daemon. */
+    onWebappInstalled(handler: (msg: WebappInfo) => void): () => void;
+    /** Subscribe to `Webapp::WebappUninstalled` from the daemon. */
+    onWebappUninstalled(handler: (msg: WebappUninstalled) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Webapp` variants. */
+    subscribe(handlers: WebappInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<WebappInboundHandlers>): () => void;
+    private _subscribe;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    list(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<WebappListReply, never>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    current(options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<WebappCurrentReply, never>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    activate(req: WebappActivate, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<WebappActiveReply, WebappError>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    icon(req: WebappIcon, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<WebappIconReply, WebappError>>;
+}
+export declare class ForwardSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Subscribe to `Forward::Text` from the daemon. */
+    onText(handler: (msg: string) => void): () => void;
+    /** Subscribe to `Forward::Json` from the daemon. */
+    onJson(handler: (msg: unknown) => void): () => void;
+    /** Subscribe to `Forward::Binary` from the daemon. */
+    onBinary(handler: (msg: Uint8Array) => void): () => void;
+    /** Exhaustive subscribe over all inbound `Forward` variants. */
+    subscribe(handlers: ForwardInboundHandlers): () => void;
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers: Partial<ForwardInboundHandlers>): () => void;
+    private _subscribe;
+    /** Send `Forward::Text` to the daemon. */
+    text(payload: string): Promise<void>;
+    /** Send `Forward::Json` to the daemon. */
+    json(payload: unknown): Promise<void>;
+    /** Send `Forward::Binary` to the daemon. */
+    binary(payload: Uint8Array): Promise<void>;
+}
+export declare class StoreSurface {
+    private readonly _client;
+    constructor(_client: BridgethingClient);
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    get(req: KVGet, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<StorageResponse, never>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    put(req: KVPut, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<StorageResponse, never>>;
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    delete(req: KVDelete, options?: {
+        timeoutMs?: number;
+    }): Promise<TypedRequestResult<StorageResponse, never>>;
+}
+export type ClientMessageHandlers = {
+    asset: AssetInboundHandlers;
+    audio: AudioInboundHandlers;
+    bluetooth: BluetoothInboundHandlers;
+    capabilities: CapabilitiesInboundHandlers;
+    config: ConfigInboundHandlers;
+    geo: GeoInboundHandlers;
+    hardware: HardwareInboundHandlers;
+    library: LibraryInboundHandlers;
+    net: NetInboundHandlers;
+    notifications: NotificationsInboundHandlers;
+    peer: (msg: PeerSnapshotMap) => void;
+    phone: PhoneInboundHandlers;
+    player: PlayerInboundHandlers;
+    system: SystemInboundHandlers;
+    time: TimeInboundHandlers;
+    voice: VoiceInboundHandlers;
+    webapp: WebappInboundHandlers;
+    forward: ForwardInboundHandlers;
+};
+export type PartialClientMessageHandlers = {
+    asset?: Partial<AssetInboundHandlers>;
+    audio?: Partial<AudioInboundHandlers>;
+    bluetooth?: Partial<BluetoothInboundHandlers>;
+    capabilities?: Partial<CapabilitiesInboundHandlers>;
+    config?: Partial<ConfigInboundHandlers>;
+    geo?: Partial<GeoInboundHandlers>;
+    hardware?: Partial<HardwareInboundHandlers>;
+    library?: Partial<LibraryInboundHandlers>;
+    net?: Partial<NetInboundHandlers>;
+    notifications?: Partial<NotificationsInboundHandlers>;
+    peer?: (msg: PeerSnapshotMap) => void;
+    phone?: Partial<PhoneInboundHandlers>;
+    player?: Partial<PlayerInboundHandlers>;
+    system?: Partial<SystemInboundHandlers>;
+    time?: Partial<TimeInboundHandlers>;
+    voice?: Partial<VoiceInboundHandlers>;
+    webapp?: Partial<WebappInboundHandlers>;
+    forward?: Partial<ForwardInboundHandlers>;
+};
+/**
+ * Codegen-emitted shape applied to `BridgethingClient` at runtime via
+ * `applyDispatch()`. `index.ts` declares `interface BridgethingClient
+ * extends ClientSurfaces {}` so class+interface merging picks these up
+ * for consumers regardless of how the published `.d.ts` is bundled.
+ */
+export interface ClientSurfaces {
+    /** Methods scoped to the `Asset` wire surface. */
+    readonly asset: AssetSurface;
+    /** Methods scoped to the `Audio` wire surface. */
+    readonly audio: AudioSurface;
+    /** Methods scoped to the `Bluetooth` wire surface. */
+    readonly bluetooth: BluetoothSurface;
+    /** Methods scoped to the `Capabilities` wire surface. */
+    readonly capabilities: CapabilitiesSurface;
+    /** Methods scoped to the `Config` wire surface. */
+    readonly config: ConfigSurface;
+    /** Methods scoped to the `Geo` wire surface. */
+    readonly geo: GeoSurface;
+    /** Methods scoped to the `Hardware` wire surface. */
+    readonly hardware: HardwareSurface;
+    /** Methods scoped to the `Library` wire surface. */
+    readonly library: LibrarySurface;
+    /** Methods scoped to the `Net` wire surface. */
+    readonly net: NetSurface;
+    /** Methods scoped to the `Notifications` wire surface. */
+    readonly notifications: NotificationsSurface;
+    /** Methods scoped to the `Peer` wire surface. */
+    readonly peer: PeerSurface;
+    /** Methods scoped to the `Phone` wire surface. */
+    readonly phone: PhoneSurface;
+    /** Methods scoped to the `Player` wire surface. */
+    readonly player: PlayerSurface;
+    /** Methods scoped to the `System` wire surface. */
+    readonly system: SystemSurface;
+    /** Methods scoped to the `Time` wire surface. */
+    readonly time: TimeSurface;
+    /** Methods scoped to the `Voice` wire surface. */
+    readonly voice: VoiceSurface;
+    /** Methods scoped to the `Webapp` wire surface. */
+    readonly webapp: WebappSurface;
+    /** Methods scoped to the `Forward` wire surface. */
+    readonly forward: ForwardSurface;
+    /** Methods scoped to the `Store` wire surface. */
+    readonly store: StoreSurface;
+    /** Exhaustive subscribe across every inbound wire surface. */
+    subscribe(handlers: ClientMessageHandlers): () => void;
+    subscribePartial(handlers: PartialClientMessageHandlers): () => void;
+}
+/**
+ * Apply codegen-emitted prototype augmentations to BridgethingClient.
+ * Called once from `index.ts` after the class definition. Idempotent.
+ */
+export declare function applyDispatch(): void;
+//# sourceMappingURL=dispatch.generated.d.ts.map