@bridgething/client 0.1.2

package/dist/dispatch.generated.js

@@ -0,0 +1,3861 @@
+// THIS FILE IS GENERATED BY tools/codegen. Do not edit by hand.
+// Re-generate with `just codegen` (or `just typescript`).
+import { newUuid } from '@bridgething/lib/uuid';
+import { BridgethingClient } from './index';
+export class AssetSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Asset::Got` from the daemon. */
+    onGot(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'asset')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'got')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Asset::NotFound` from the daemon. */
+    onNotFound(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'asset')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'notFound')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Asset::Ready` from the daemon. */
+    onReady(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'asset')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'ready')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Asset::Cleared` from the daemon. */
+    onCleared(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'asset')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'cleared')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Asset` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'asset')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'got': {
+                    handlers.got?.(inner.data);
+                    return;
+                }
+                case 'notFound': {
+                    handlers.notFound?.(inner.data);
+                    return;
+                }
+                case 'ready': {
+                    handlers.ready?.(inner.data);
+                    return;
+                }
+                case 'cleared': {
+                    handlers.cleared?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Asset: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Asset::Preload` to the daemon. */
+    async preload(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'asset', data: { event: 'preload', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async get(req, options) {
+        const wireData = { type: 'asset', data: { event: 'get', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'asset') {
+            const inner = d.data;
+            if (inner.event === 'got')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'notFound')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class AudioSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Audio::TtsStarted` from the daemon. */
+    onTtsStarted(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'audio')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'ttsStarted')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Audio::TtsEnded` from the daemon. */
+    onTtsEnded(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'audio')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'ttsEnded')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Audio::VolumeChanged` from the daemon. */
+    onVolumeChanged(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'audio')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'volumeChanged')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Audio` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'audio')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'ttsStarted': {
+                    handlers.ttsStarted?.(inner.data);
+                    return;
+                }
+                case 'ttsEnded': {
+                    handlers.ttsEnded?.(inner.data);
+                    return;
+                }
+                case 'volumeChanged': {
+                    handlers.volumeChanged?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Audio: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Audio::VolumeUp` to the daemon. */
+    async volumeUp() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'audio', data: { event: 'volumeUp' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Audio::VolumeDown` to the daemon. */
+    async volumeDown() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'audio', data: { event: 'volumeDown' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Audio::SetVolume` to the daemon. */
+    async setVolume(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'audio', data: { event: 'setVolume', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Audio::MuteToggle` to the daemon. */
+    async muteToggle() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'audio', data: { event: 'muteToggle' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Audio::SetMute` to the daemon. */
+    async setMute(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'audio', data: { event: 'setMute', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Audio::Tts` to the daemon. */
+    async tts(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'audio', data: { event: 'tts', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Audio::TtsCancel` to the daemon. */
+    async ttsCancel(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'audio', data: { event: 'ttsCancel', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Audio::TtsCancelAll` to the daemon. */
+    async ttsCancelAll() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'audio', data: { event: 'ttsCancelAll' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Audio::Earcon` to the daemon. */
+    async earcon(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'audio', data: { event: 'earcon', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+}
+export class BluetoothSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Bluetooth::Status` from the daemon. */
+    onStatus(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'bluetooth')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'status')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Bluetooth::ConnectedDevice` from the daemon. */
+    onConnectedDevice(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'bluetooth')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'connectedDevice')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Bluetooth::Interface` from the daemon. */
+    onInterface(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'bluetooth')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'interface')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Bluetooth::PairingResult` from the daemon. */
+    onPairingResult(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'bluetooth')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'pairingResult')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Bluetooth::Pin` from the daemon. */
+    onPin(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'bluetooth')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'pin')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Bluetooth::PairedDevices` from the daemon. */
+    onPairedDevices(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'bluetooth')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'pairedDevices')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Bluetooth` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'bluetooth')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'status': {
+                    handlers.status?.(inner.data);
+                    return;
+                }
+                case 'connectedDevice': {
+                    handlers.connectedDevice?.(inner.data);
+                    return;
+                }
+                case 'interface': {
+                    handlers.interface?.(inner.data);
+                    return;
+                }
+                case 'pairingResult': {
+                    handlers.pairingResult?.(inner.data);
+                    return;
+                }
+                case 'pin': {
+                    handlers.pin?.(inner.data);
+                    return;
+                }
+                case 'pairedDevices': {
+                    handlers.pairedDevices?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Bluetooth: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Bluetooth::Connect` to the daemon. */
+    async connect(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'bluetooth', data: { event: 'connect', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Bluetooth::EnableDiscoverable` to the daemon. */
+    async enableDiscoverable() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'bluetooth', data: { event: 'enableDiscoverable' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Bluetooth::DisableDiscoverable` to the daemon. */
+    async disableDiscoverable() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'bluetooth', data: { event: 'disableDiscoverable' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Bluetooth::Forget` to the daemon. */
+    async forget(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'bluetooth', data: { event: 'forget', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Bluetooth::SetAlias` to the daemon. */
+    async setAlias(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'bluetooth', data: { event: 'setAlias', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async list(options) {
+        const wireData = { type: 'bluetooth', data: { event: 'list' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'bluetooth') {
+            const inner = d.data;
+            if (inner.event === 'pairedDevices')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class CapabilitiesSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Capabilities::Update` from the daemon. */
+    onUpdate(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'capabilities')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'update')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Capabilities::Snapshot` from the daemon. */
+    onSnapshot(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'capabilities')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'snapshot')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Capabilities` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'capabilities')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'update': {
+                    handlers.update?.(inner.data);
+                    return;
+                }
+                case 'snapshot': {
+                    handlers.snapshot?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Capabilities: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async get(options) {
+        const wireData = { type: 'capabilities', data: { event: 'get' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'capabilities') {
+            const inner = d.data;
+            if (inner.event === 'snapshot')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class ConfigSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Config::Get` from the daemon. */
+    onGet(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'config')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'get')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Config::List` from the daemon. */
+    onList(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'config')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'list')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Config::Changed` from the daemon. */
+    onChanged(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'config')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'changed')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Config` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'config')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'get': {
+                    handlers.get?.(inner.data);
+                    return;
+                }
+                case 'list': {
+                    handlers.list?.(inner.data);
+                    return;
+                }
+                case 'changed': {
+                    handlers.changed?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Config: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async get(req, options) {
+        const wireData = { type: 'config', data: { event: 'get', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'config') {
+            const inner = d.data;
+            if (inner.event === 'get')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async list(options) {
+        const wireData = { type: 'config', data: { event: 'list' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'config') {
+            const inner = d.data;
+            if (inner.event === 'list')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class GeoSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Geo::Position` from the daemon. */
+    onPosition(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'geo')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'position')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Geo::WatchReply` from the daemon. */
+    onWatchReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'geo')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'watchReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Geo::GetOnceReply` from the daemon. */
+    onGetOnceReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'geo')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'getOnceReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Geo::ErrorReply` from the daemon. */
+    onErrorReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'geo')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'errorReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Geo` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'geo')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'position': {
+                    handlers.position?.(inner.data);
+                    return;
+                }
+                case 'watchReply': {
+                    handlers.watchReply?.(inner.data);
+                    return;
+                }
+                case 'getOnceReply': {
+                    handlers.getOnceReply?.(inner.data);
+                    return;
+                }
+                case 'errorReply': {
+                    handlers.errorReply?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Geo: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Geo::Unwatch` to the daemon. */
+    async unwatch(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'geo', data: { event: 'unwatch', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async watch(req, options) {
+        const wireData = { type: 'geo', data: { event: 'watch', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'geo') {
+            const inner = d.data;
+            if (inner.event === 'watchReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'errorReply')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async getOnce(req, options) {
+        const wireData = { type: 'geo', data: { event: 'getOnce', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'geo') {
+            const inner = d.data;
+            if (inner.event === 'getOnceReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'errorReply')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class HardwareSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Hardware::AmbientLightUpdate` from the daemon. */
+    onAmbientLightUpdate(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'hardware')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'ambientLightUpdate')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Hardware::BrightnessChanged` from the daemon. */
+    onBrightnessChanged(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'hardware')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'brightnessChanged')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Hardware::StateReply` from the daemon. */
+    onStateReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'hardware')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'stateReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Hardware` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'hardware')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'ambientLightUpdate': {
+                    handlers.ambientLightUpdate?.(inner.data);
+                    return;
+                }
+                case 'brightnessChanged': {
+                    handlers.brightnessChanged?.(inner.data);
+                    return;
+                }
+                case 'stateReply': {
+                    handlers.stateReply?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Hardware: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Hardware::DisplaySetMode` to the daemon. */
+    async displaySetMode(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'hardware', data: { event: 'displaySetMode', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Hardware::DisplaySetLevel` to the daemon. */
+    async displaySetLevel(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'hardware', data: { event: 'displaySetLevel', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async stateGet(options) {
+        const wireData = { type: 'hardware', data: { event: 'stateGet' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'hardware') {
+            const inner = d.data;
+            if (inner.event === 'stateReply')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class LibrarySurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Library::BrowseReply` from the daemon. */
+    onBrowseReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'library')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'browseReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Library::SearchReply` from the daemon. */
+    onSearchReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'library')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'searchReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Library::RecommendationsReply` from the daemon. */
+    onRecommendationsReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'library')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'recommendationsReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Library::FavoritesListReply` from the daemon. */
+    onFavoritesListReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'library')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'favoritesListReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Library::FavoritesContainsReply` from the daemon. */
+    onFavoritesContainsReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'library')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'favoritesContainsReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Library::LibraryErrorReply` from the daemon. */
+    onLibraryErrorReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'library')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'libraryErrorReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Library::FavoriteChanged` from the daemon. */
+    onFavoriteChanged(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'library')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'favoriteChanged')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Library` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'library')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'browseReply': {
+                    handlers.browseReply?.(inner.data);
+                    return;
+                }
+                case 'searchReply': {
+                    handlers.searchReply?.(inner.data);
+                    return;
+                }
+                case 'recommendationsReply': {
+                    handlers.recommendationsReply?.(inner.data);
+                    return;
+                }
+                case 'favoritesListReply': {
+                    handlers.favoritesListReply?.(inner.data);
+                    return;
+                }
+                case 'favoritesContainsReply': {
+                    handlers.favoritesContainsReply?.(inner.data);
+                    return;
+                }
+                case 'libraryErrorReply': {
+                    handlers.libraryErrorReply?.(inner.data);
+                    return;
+                }
+                case 'favoriteChanged': {
+                    handlers.favoriteChanged?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Library: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Library::FavoritesToggle` to the daemon. */
+    async favoritesToggle(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'library', data: { event: 'favoritesToggle', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Library::FavoritesSet` to the daemon. */
+    async favoritesSet(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'library', data: { event: 'favoritesSet', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Library::FavoritesSetMany` to the daemon. */
+    async favoritesSetMany(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'library', data: { event: 'favoritesSetMany', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async browse(req, options) {
+        const wireData = { type: 'library', data: { event: 'browse', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'library') {
+            const inner = d.data;
+            if (inner.event === 'browseReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'libraryErrorReply')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async search(req, options) {
+        const wireData = { type: 'library', data: { event: 'search', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'library') {
+            const inner = d.data;
+            if (inner.event === 'searchReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'libraryErrorReply')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async recommendations(req, options) {
+        const wireData = { type: 'library', data: { event: 'recommendations', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'library') {
+            const inner = d.data;
+            if (inner.event === 'recommendationsReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'libraryErrorReply')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async favoritesList(req, options) {
+        const wireData = { type: 'library', data: { event: 'favoritesList', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'library') {
+            const inner = d.data;
+            if (inner.event === 'favoritesListReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'libraryErrorReply')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async favoritesContains(req, options) {
+        const wireData = { type: 'library', data: { event: 'favoritesContains', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'library') {
+            const inner = d.data;
+            if (inner.event === 'favoritesContainsReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'libraryErrorReply')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class NetSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Net::FetchReply` from the daemon. */
+    onFetchReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'fetchReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Net::FetchErrorReply` from the daemon. */
+    onFetchErrorReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'fetchErrorReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Net::WsOpenReply` from the daemon. */
+    onWsOpenReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'wsOpenReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Net::WsErrorReply` from the daemon. */
+    onWsErrorReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'wsErrorReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Net::WsMessage` from the daemon. */
+    onWsMessage(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'wsMessage')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Net::WsClosed` from the daemon. */
+    onWsClosed(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'wsClosed')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Net::WsErrorEvent` from the daemon. */
+    onWsErrorEvent(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'wsErrorEvent')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Net::StreamBegin` from the daemon. */
+    onStreamBegin(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'streamBegin')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Net::StreamChunk` from the daemon. */
+    onStreamChunk(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'streamChunk')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Net::StreamEnd` from the daemon. */
+    onStreamEnd(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'streamEnd')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Net::StreamError` from the daemon. */
+    onStreamError(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'streamError')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Net` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'net')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'fetchReply': {
+                    handlers.fetchReply?.(inner.data);
+                    return;
+                }
+                case 'fetchErrorReply': {
+                    handlers.fetchErrorReply?.(inner.data);
+                    return;
+                }
+                case 'wsOpenReply': {
+                    handlers.wsOpenReply?.(inner.data);
+                    return;
+                }
+                case 'wsErrorReply': {
+                    handlers.wsErrorReply?.(inner.data);
+                    return;
+                }
+                case 'wsMessage': {
+                    handlers.wsMessage?.(inner.data);
+                    return;
+                }
+                case 'wsClosed': {
+                    handlers.wsClosed?.(inner.data);
+                    return;
+                }
+                case 'wsErrorEvent': {
+                    handlers.wsErrorEvent?.(inner.data);
+                    return;
+                }
+                case 'streamBegin': {
+                    handlers.streamBegin?.(inner.data);
+                    return;
+                }
+                case 'streamChunk': {
+                    handlers.streamChunk?.(inner.data);
+                    return;
+                }
+                case 'streamEnd': {
+                    handlers.streamEnd?.(inner.data);
+                    return;
+                }
+                case 'streamError': {
+                    handlers.streamError?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Net: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Net::WsClose` to the daemon. */
+    async wsClose(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'net', data: { event: 'wsClose', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Net::WsSend` to the daemon. */
+    async wsSend(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'net', data: { event: 'wsSend', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Net::StreamOpen` to the daemon. */
+    async streamOpen(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'net', data: { event: 'streamOpen', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Net::StreamCancel` to the daemon. */
+    async streamCancel(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'net', data: { event: 'streamCancel', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async fetch(req, options) {
+        const wireData = { type: 'net', data: { event: 'fetch', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'net') {
+            const inner = d.data;
+            if (inner.event === 'fetchReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'fetchErrorReply')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async wsOpen(req, options) {
+        const wireData = { type: 'net', data: { event: 'wsOpen', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'net') {
+            const inner = d.data;
+            if (inner.event === 'wsOpenReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'wsErrorReply')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class NotificationsSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Notifications::Posted` from the daemon. */
+    onPosted(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'notifications')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'posted')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Notifications::Updated` from the daemon. */
+    onUpdated(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'notifications')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'updated')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Notifications::Removed` from the daemon. */
+    onRemoved(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'notifications')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'removed')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Notifications` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'notifications')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'posted': {
+                    handlers.posted?.(inner.data);
+                    return;
+                }
+                case 'updated': {
+                    handlers.updated?.(inner.data);
+                    return;
+                }
+                case 'removed': {
+                    handlers.removed?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Notifications: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Notifications::InvokePositive` to the daemon. */
+    async invokePositive(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'notifications', data: { event: 'invokePositive', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Notifications::InvokeNegative` to the daemon. */
+    async invokeNegative(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'notifications', data: { event: 'invokeNegative', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+}
+export class PeerSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Peer::Snapshot` from the daemon. */
+    onSnapshot(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'peer')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'snapshot')
+                return;
+            handler(inner.data);
+        });
+    }
+}
+export class PhoneSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Phone::CallStarted` from the daemon. */
+    onCallStarted(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'phone')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'callStarted')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Phone::CallUpdated` from the daemon. */
+    onCallUpdated(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'phone')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'callUpdated')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Phone::CallEnded` from the daemon. */
+    onCallEnded(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'phone')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'callEnded')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Phone::CommunicationsChanged` from the daemon. */
+    onCommunicationsChanged(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'phone')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'communicationsChanged')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Phone::StateReply` from the daemon. */
+    onStateReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'phone')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'stateReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Phone::ErrorReply` from the daemon. */
+    onErrorReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'phone')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'errorReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Phone` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'phone')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'callStarted': {
+                    handlers.callStarted?.(inner.data);
+                    return;
+                }
+                case 'callUpdated': {
+                    handlers.callUpdated?.(inner.data);
+                    return;
+                }
+                case 'callEnded': {
+                    handlers.callEnded?.(inner.data);
+                    return;
+                }
+                case 'communicationsChanged': {
+                    handlers.communicationsChanged?.(inner.data);
+                    return;
+                }
+                case 'stateReply': {
+                    handlers.stateReply?.(inner.data);
+                    return;
+                }
+                case 'errorReply': {
+                    handlers.errorReply?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Phone: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Phone::Answer` to the daemon. */
+    async answer(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'answer', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::Accept` to the daemon. */
+    async accept(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'accept', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::Decline` to the daemon. */
+    async decline(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'decline', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::End` to the daemon. */
+    async end(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'end', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::EndTyped` to the daemon. */
+    async endTyped(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'endTyped', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::Hold` to the daemon. */
+    async hold(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'hold', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::Unhold` to the daemon. */
+    async unhold(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'unhold', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::Initiate` to the daemon. */
+    async initiate(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'initiate', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::Swap` to the daemon. */
+    async swap() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'swap' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::Merge` to the daemon. */
+    async merge() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'merge' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::Mute` to the daemon. */
+    async mute(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'mute', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Phone::Dtmf` to the daemon. */
+    async dtmf(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'phone', data: { event: 'dtmf', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async stateGet(options) {
+        const wireData = { type: 'phone', data: { event: 'stateGet' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'phone') {
+            const inner = d.data;
+            if (inner.event === 'stateReply')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class PlayerSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Player::Snapshot` from the daemon. */
+    onSnapshot(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'player')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'snapshot')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Player::Delta` from the daemon. */
+    onDelta(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'player')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'delta')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Player::QueueChanged` from the daemon. */
+    onQueueChanged(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'player')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'queueChanged')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Player::StateReply` from the daemon. */
+    onStateReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'player')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'stateReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Player::QueueReply` from the daemon. */
+    onQueueReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'player')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'queueReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Player::ErrorReply` from the daemon. */
+    onErrorReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'player')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'errorReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Player` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'player')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'snapshot': {
+                    handlers.snapshot?.(inner.data);
+                    return;
+                }
+                case 'delta': {
+                    handlers.delta?.(inner.data);
+                    return;
+                }
+                case 'queueChanged': {
+                    handlers.queueChanged?.(inner.data);
+                    return;
+                }
+                case 'stateReply': {
+                    handlers.stateReply?.(inner.data);
+                    return;
+                }
+                case 'queueReply': {
+                    handlers.queueReply?.(inner.data);
+                    return;
+                }
+                case 'errorReply': {
+                    handlers.errorReply?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Player: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Player::Play` to the daemon. */
+    async play(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'play', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::Queue` to the daemon. */
+    async queue(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'queue', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::Pause` to the daemon. */
+    async pause() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'pause' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::Resume` to the daemon. */
+    async resume() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'resume' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::SkipNext` to the daemon. */
+    async skipNext() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'skipNext' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::SkipPrev` to the daemon. */
+    async skipPrev(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'skipPrev', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::SkipToIndex` to the daemon. */
+    async skipToIndex(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'skipToIndex', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::SeekTo` to the daemon. */
+    async seekTo(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'seekTo', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::SetShuffle` to the daemon. */
+    async setShuffle(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'setShuffle', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::SetRepeat` to the daemon. */
+    async setRepeat(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'setRepeat', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::SetSpeed` to the daemon. */
+    async setSpeed(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'setSpeed', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Player::SetCrossfade` to the daemon. */
+    async setCrossfade(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'player', data: { event: 'setCrossfade', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async stateGet(options) {
+        const wireData = { type: 'player', data: { event: 'stateGet' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'player') {
+            const inner = d.data;
+            if (inner.event === 'stateReply')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async queueGet(options) {
+        const wireData = { type: 'player', data: { event: 'queueGet' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'player') {
+            const inner = d.data;
+            if (inner.event === 'queueReply')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class SystemSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `System::Version` from the daemon. */
+    onVersion(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'system')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'version')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `System::DiagnosticsReply` from the daemon. */
+    onDiagnosticsReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'system')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'diagnosticsReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `System::LogsTailReply` from the daemon. */
+    onLogsTailReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'system')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'logsTailReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `System::LogsSubscribeReply` from the daemon. */
+    onLogsSubscribeReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'system')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'logsSubscribeReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `System::LogEntry` from the daemon. */
+    onLogEntry(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'system')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'logEntry')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `System::OtaProgress` from the daemon. */
+    onOtaProgress(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'system')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'otaProgress')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `System::OtaError` from the daemon. */
+    onOtaError(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'system')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'otaError')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `System::DeviceNickname` from the daemon. */
+    onDeviceNickname(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'system')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'deviceNickname')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `System::DeviceNicknameChanged` from the daemon. */
+    onDeviceNicknameChanged(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'system')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'deviceNicknameChanged')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `System` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'system')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'version': {
+                    handlers.version?.(inner.data);
+                    return;
+                }
+                case 'diagnosticsReply': {
+                    handlers.diagnosticsReply?.(inner.data);
+                    return;
+                }
+                case 'logsTailReply': {
+                    handlers.logsTailReply?.(inner.data);
+                    return;
+                }
+                case 'logsSubscribeReply': {
+                    handlers.logsSubscribeReply?.(inner.data);
+                    return;
+                }
+                case 'logEntry': {
+                    handlers.logEntry?.(inner.data);
+                    return;
+                }
+                case 'otaProgress': {
+                    handlers.otaProgress?.(inner.data);
+                    return;
+                }
+                case 'otaError': {
+                    handlers.otaError?.(inner.data);
+                    return;
+                }
+                case 'deviceNickname': {
+                    handlers.deviceNickname?.(inner.data);
+                    return;
+                }
+                case 'deviceNicknameChanged': {
+                    handlers.deviceNicknameChanged?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('System: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `System::LogsUnsubscribe` to the daemon. */
+    async logsUnsubscribe(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'system', data: { event: 'logsUnsubscribe', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `System::Reboot` to the daemon. */
+    async reboot() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'system', data: { event: 'reboot' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `System::PowerOff` to the daemon. */
+    async powerOff() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'system', data: { event: 'powerOff' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `System::FactoryReset` to the daemon. */
+    async factoryReset() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'system', data: { event: 'factoryReset' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async versionRequest(options) {
+        const wireData = { type: 'system', data: { event: 'versionRequest' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'system') {
+            const inner = d.data;
+            if (inner.event === 'version')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async diagnosticsGet(options) {
+        const wireData = { type: 'system', data: { event: 'diagnosticsGet' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'system') {
+            const inner = d.data;
+            if (inner.event === 'diagnosticsReply')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async logsTail(req, options) {
+        const wireData = { type: 'system', data: { event: 'logsTail', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'system') {
+            const inner = d.data;
+            if (inner.event === 'logsTailReply')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async logsSubscribe(req, options) {
+        const wireData = { type: 'system', data: { event: 'logsSubscribe', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'system') {
+            const inner = d.data;
+            if (inner.event === 'logsSubscribeReply')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async deviceGetNickname(options) {
+        const wireData = { type: 'system', data: { event: 'deviceGetNickname' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'system') {
+            const inner = d.data;
+            if (inner.event === 'deviceNickname')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class TimeSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Time::Changed` from the daemon. */
+    onChanged(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'time')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'changed')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Time::Snapshot` from the daemon. */
+    onSnapshot(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'time')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'snapshot')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Time` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'time')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'changed': {
+                    handlers.changed?.(inner.data);
+                    return;
+                }
+                case 'snapshot': {
+                    handlers.snapshot?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Time: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async get(options) {
+        const wireData = { type: 'time', data: { event: 'get' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'time') {
+            const inner = d.data;
+            if (inner.event === 'snapshot')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class VoiceSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Voice::StateChanged` from the daemon. */
+    onStateChanged(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'voice')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'stateChanged')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Voice::StateReply` from the daemon. */
+    onStateReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'voice')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'stateReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Voice` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'voice')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'stateChanged': {
+                    handlers.stateChanged?.(inner.data);
+                    return;
+                }
+                case 'stateReply': {
+                    handlers.stateReply?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Voice: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Voice::Cancel` to the daemon. */
+    async cancel() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'voice', data: { event: 'cancel' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Voice::PushToTalk` to the daemon. */
+    async pushToTalk() {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'voice', data: { event: 'pushToTalk' } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Voice::MuteMic` to the daemon. */
+    async muteMic(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'voice', data: { event: 'muteMic', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Voice::UnmuteMic` to the daemon. */
+    async unmuteMic(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'command' },
+            data: { type: 'voice', data: { event: 'unmuteMic', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async stateGet(options) {
+        const wireData = { type: 'voice', data: { event: 'stateGet' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'voice') {
+            const inner = d.data;
+            if (inner.event === 'stateReply')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class WebappSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Webapp::ListReply` from the daemon. */
+    onListReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'webapp')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'listReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Webapp::CurrentReply` from the daemon. */
+    onCurrentReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'webapp')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'currentReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Webapp::ActiveReply` from the daemon. */
+    onActiveReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'webapp')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'activeReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Webapp::IconReply` from the daemon. */
+    onIconReply(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'webapp')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'iconReply')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Webapp::WebappError` from the daemon. */
+    onWebappError(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'webapp')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'webappError')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Webapp::ActiveChanged` from the daemon. */
+    onActiveChanged(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'webapp')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'activeChanged')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Webapp::WebappInstalled` from the daemon. */
+    onWebappInstalled(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'webapp')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'webappInstalled')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Webapp::WebappUninstalled` from the daemon. */
+    onWebappUninstalled(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'webapp')
+                return;
+            const inner = data.data;
+            if (inner.event !== 'webappUninstalled')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Webapp` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'webapp')
+                return;
+            const inner = data.data;
+            switch (inner.event) {
+                case 'listReply': {
+                    handlers.listReply?.(inner.data);
+                    return;
+                }
+                case 'currentReply': {
+                    handlers.currentReply?.(inner.data);
+                    return;
+                }
+                case 'activeReply': {
+                    handlers.activeReply?.(inner.data);
+                    return;
+                }
+                case 'iconReply': {
+                    handlers.iconReply?.(inner.data);
+                    return;
+                }
+                case 'webappError': {
+                    handlers.webappError?.(inner.data);
+                    return;
+                }
+                case 'activeChanged': {
+                    handlers.activeChanged?.(inner.data);
+                    return;
+                }
+                case 'webappInstalled': {
+                    handlers.webappInstalled?.(inner.data);
+                    return;
+                }
+                case 'webappUninstalled': {
+                    handlers.webappUninstalled?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Webapp: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async list(options) {
+        const wireData = { type: 'webapp', data: { event: 'list' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'webapp') {
+            const inner = d.data;
+            if (inner.event === 'listReply')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async current(options) {
+        const wireData = { type: 'webapp', data: { event: 'current' } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'webapp') {
+            const inner = d.data;
+            if (inner.event === 'currentReply')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async activate(req, options) {
+        const wireData = { type: 'webapp', data: { event: 'activate', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'webapp') {
+            const inner = d.data;
+            if (inner.event === 'activeReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'webappError')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async icon(req, options) {
+        const wireData = { type: 'webapp', data: { event: 'icon', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'webapp') {
+            const inner = d.data;
+            if (inner.event === 'iconReply')
+                return { ok: true, response: inner.data };
+            if (inner.event === 'webappError')
+                return { ok: false, kind: 'domain', error: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+export class ForwardSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Subscribe to `Forward::Text` from the daemon. */
+    onText(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'forward')
+                return;
+            const inner = data.data;
+            if (inner.encoding !== 'text')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Forward::Json` from the daemon. */
+    onJson(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'forward')
+                return;
+            const inner = data.data;
+            if (inner.encoding !== 'json')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Subscribe to `Forward::Binary` from the daemon. */
+    onBinary(handler) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'forward')
+                return;
+            const inner = data.data;
+            if (inner.encoding !== 'binary')
+                return;
+            handler(inner.data);
+        });
+    }
+    /** Exhaustive subscribe over all inbound `Forward` variants. */
+    subscribe(handlers) {
+        return this._subscribe(handlers, false);
+    }
+    /** Same as `subscribe` but every handler is optional. */
+    subscribePartial(handlers) {
+        return this._subscribe(handlers, true);
+    }
+    _subscribe(handlers, partial) {
+        return this._client.on(event => {
+            if (event.type !== 'message')
+                return;
+            const data = event.message.data;
+            if (data.type !== 'forward')
+                return;
+            const inner = data.data;
+            switch (inner.encoding) {
+                case 'text': {
+                    handlers.text?.(inner.data);
+                    return;
+                }
+                case 'json': {
+                    handlers.json?.(inner.data);
+                    return;
+                }
+                case 'binary': {
+                    handlers.binary?.(inner.data);
+                    return;
+                }
+                default: {
+                    if (!partial)
+                        this._client.logger.warn('Forward: no handler for inner', inner);
+                    return;
+                }
+            }
+        });
+    }
+    /** Send `Forward::Text` to the daemon. */
+    async text(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'event' },
+            data: { type: 'forward', data: { encoding: 'text', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Forward::Json` to the daemon. */
+    async json(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'event' },
+            data: { type: 'forward', data: { encoding: 'json', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+    /** Send `Forward::Binary` to the daemon. */
+    async binary(payload) {
+        const msg = {
+            id: newUuid(),
+            meta: { kind: 'event' },
+            data: { type: 'forward', data: { encoding: 'binary', data: payload } },
+        };
+        await this._client.send(msg);
+    }
+}
+export class StoreSurface {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async get(req, options) {
+        const wireData = { type: 'store', data: { event: 'get', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'store') {
+            const inner = d.data;
+            if (inner.event === 'response')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async put(req, options) {
+        const wireData = { type: 'store', data: { event: 'put', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'store') {
+            const inner = d.data;
+            if (inner.event === 'response')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+    /** Typed request to the daemon: webapp sends, daemon responds. */
+    async delete(req, options) {
+        const wireData = { type: 'store', data: { event: 'delete', data: req } };
+        const response = await this._client.request(wireData, options?.timeoutMs);
+        const d = response.data;
+        if (d.type === 'store') {
+            const inner = d.data;
+            if (inner.event === 'response')
+                return { ok: true, response: inner.data };
+        }
+        if (d.type === 'error')
+            return { ok: false, kind: 'protocol', error: d.data };
+        return { ok: false, kind: 'protocol', error: { type: 'unsupported' } };
+    }
+}
+/**
+ * Apply codegen-emitted prototype augmentations to BridgethingClient.
+ * Called once from `index.ts` after the class definition. Idempotent.
+ */
+export function applyDispatch() {
+    const surfaceCache = new WeakMap();
+    function bucketFor(c) {
+        let bucket = surfaceCache.get(c);
+        if (!bucket) {
+            bucket = {};
+            surfaceCache.set(c, bucket);
+        }
+        return bucket;
+    }
+    Object.defineProperty(BridgethingClient.prototype, 'asset', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.asset ??= new AssetSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'audio', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.audio ??= new AudioSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'bluetooth', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.bluetooth ??= new BluetoothSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'capabilities', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.capabilities ??= new CapabilitiesSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'config', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.config ??= new ConfigSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'geo', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.geo ??= new GeoSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'hardware', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.hardware ??= new HardwareSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'library', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.library ??= new LibrarySurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'net', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.net ??= new NetSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'notifications', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.notifications ??= new NotificationsSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'peer', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.peer ??= new PeerSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'phone', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.phone ??= new PhoneSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'player', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.player ??= new PlayerSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'system', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.system ??= new SystemSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'time', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.time ??= new TimeSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'voice', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.voice ??= new VoiceSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'webapp', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.webapp ??= new WebappSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'forward', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.forward ??= new ForwardSurface(this));
+        },
+    });
+    Object.defineProperty(BridgethingClient.prototype, 'store', {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const bucket = bucketFor(this);
+            return (bucket.store ??= new StoreSurface(this));
+        },
+    });
+    BridgethingClient.prototype.subscribe = function (handlers) {
+        return outerSubscribe(this, handlers, false);
+    };
+    BridgethingClient.prototype.subscribePartial = function (handlers) {
+        return outerSubscribe(this, handlers, true);
+    };
+}
+function outerSubscribe(c, handlers, partial) {
+    return c.on((event) => {
+        if (event.type !== 'message')
+            return;
+        const data = event.message.data;
+        switch (data.type) {
+            case 'asset': {
+                const innerHandlers = handlers.asset;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for asset');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'got': {
+                        innerHandlers.got?.(inner.data);
+                        return;
+                    }
+                    case 'notFound': {
+                        innerHandlers.notFound?.(inner.data);
+                        return;
+                    }
+                    case 'ready': {
+                        innerHandlers.ready?.(inner.data);
+                        return;
+                    }
+                    case 'cleared': {
+                        innerHandlers.cleared?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Asset: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'audio': {
+                const innerHandlers = handlers.audio;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for audio');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'ttsStarted': {
+                        innerHandlers.ttsStarted?.(inner.data);
+                        return;
+                    }
+                    case 'ttsEnded': {
+                        innerHandlers.ttsEnded?.(inner.data);
+                        return;
+                    }
+                    case 'volumeChanged': {
+                        innerHandlers.volumeChanged?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Audio: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'bluetooth': {
+                const innerHandlers = handlers.bluetooth;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for bluetooth');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'status': {
+                        innerHandlers.status?.(inner.data);
+                        return;
+                    }
+                    case 'connectedDevice': {
+                        innerHandlers.connectedDevice?.(inner.data);
+                        return;
+                    }
+                    case 'interface': {
+                        innerHandlers.interface?.(inner.data);
+                        return;
+                    }
+                    case 'pairingResult': {
+                        innerHandlers.pairingResult?.(inner.data);
+                        return;
+                    }
+                    case 'pin': {
+                        innerHandlers.pin?.(inner.data);
+                        return;
+                    }
+                    case 'pairedDevices': {
+                        innerHandlers.pairedDevices?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Bluetooth: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'capabilities': {
+                const innerHandlers = handlers.capabilities;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for capabilities');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'update': {
+                        innerHandlers.update?.(inner.data);
+                        return;
+                    }
+                    case 'snapshot': {
+                        innerHandlers.snapshot?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Capabilities: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'config': {
+                const innerHandlers = handlers.config;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for config');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'get': {
+                        innerHandlers.get?.(inner.data);
+                        return;
+                    }
+                    case 'list': {
+                        innerHandlers.list?.(inner.data);
+                        return;
+                    }
+                    case 'changed': {
+                        innerHandlers.changed?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Config: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'geo': {
+                const innerHandlers = handlers.geo;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for geo');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'position': {
+                        innerHandlers.position?.(inner.data);
+                        return;
+                    }
+                    case 'watchReply': {
+                        innerHandlers.watchReply?.(inner.data);
+                        return;
+                    }
+                    case 'getOnceReply': {
+                        innerHandlers.getOnceReply?.(inner.data);
+                        return;
+                    }
+                    case 'errorReply': {
+                        innerHandlers.errorReply?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Geo: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'hardware': {
+                const innerHandlers = handlers.hardware;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for hardware');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'ambientLightUpdate': {
+                        innerHandlers.ambientLightUpdate?.(inner.data);
+                        return;
+                    }
+                    case 'brightnessChanged': {
+                        innerHandlers.brightnessChanged?.(inner.data);
+                        return;
+                    }
+                    case 'stateReply': {
+                        innerHandlers.stateReply?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Hardware: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'library': {
+                const innerHandlers = handlers.library;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for library');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'browseReply': {
+                        innerHandlers.browseReply?.(inner.data);
+                        return;
+                    }
+                    case 'searchReply': {
+                        innerHandlers.searchReply?.(inner.data);
+                        return;
+                    }
+                    case 'recommendationsReply': {
+                        innerHandlers.recommendationsReply?.(inner.data);
+                        return;
+                    }
+                    case 'favoritesListReply': {
+                        innerHandlers.favoritesListReply?.(inner.data);
+                        return;
+                    }
+                    case 'favoritesContainsReply': {
+                        innerHandlers.favoritesContainsReply?.(inner.data);
+                        return;
+                    }
+                    case 'libraryErrorReply': {
+                        innerHandlers.libraryErrorReply?.(inner.data);
+                        return;
+                    }
+                    case 'favoriteChanged': {
+                        innerHandlers.favoriteChanged?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Library: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'net': {
+                const innerHandlers = handlers.net;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for net');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'fetchReply': {
+                        innerHandlers.fetchReply?.(inner.data);
+                        return;
+                    }
+                    case 'fetchErrorReply': {
+                        innerHandlers.fetchErrorReply?.(inner.data);
+                        return;
+                    }
+                    case 'wsOpenReply': {
+                        innerHandlers.wsOpenReply?.(inner.data);
+                        return;
+                    }
+                    case 'wsErrorReply': {
+                        innerHandlers.wsErrorReply?.(inner.data);
+                        return;
+                    }
+                    case 'wsMessage': {
+                        innerHandlers.wsMessage?.(inner.data);
+                        return;
+                    }
+                    case 'wsClosed': {
+                        innerHandlers.wsClosed?.(inner.data);
+                        return;
+                    }
+                    case 'wsErrorEvent': {
+                        innerHandlers.wsErrorEvent?.(inner.data);
+                        return;
+                    }
+                    case 'streamBegin': {
+                        innerHandlers.streamBegin?.(inner.data);
+                        return;
+                    }
+                    case 'streamChunk': {
+                        innerHandlers.streamChunk?.(inner.data);
+                        return;
+                    }
+                    case 'streamEnd': {
+                        innerHandlers.streamEnd?.(inner.data);
+                        return;
+                    }
+                    case 'streamError': {
+                        innerHandlers.streamError?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Net: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'notifications': {
+                const innerHandlers = handlers.notifications;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for notifications');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'posted': {
+                        innerHandlers.posted?.(inner.data);
+                        return;
+                    }
+                    case 'updated': {
+                        innerHandlers.updated?.(inner.data);
+                        return;
+                    }
+                    case 'removed': {
+                        innerHandlers.removed?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Notifications: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'peer': {
+                const handler = handlers.peer;
+                if (!handler) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for peer');
+                    return;
+                }
+                handler(data.data.data);
+                return;
+            }
+            case 'phone': {
+                const innerHandlers = handlers.phone;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for phone');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'callStarted': {
+                        innerHandlers.callStarted?.(inner.data);
+                        return;
+                    }
+                    case 'callUpdated': {
+                        innerHandlers.callUpdated?.(inner.data);
+                        return;
+                    }
+                    case 'callEnded': {
+                        innerHandlers.callEnded?.(inner.data);
+                        return;
+                    }
+                    case 'communicationsChanged': {
+                        innerHandlers.communicationsChanged?.(inner.data);
+                        return;
+                    }
+                    case 'stateReply': {
+                        innerHandlers.stateReply?.(inner.data);
+                        return;
+                    }
+                    case 'errorReply': {
+                        innerHandlers.errorReply?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Phone: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'player': {
+                const innerHandlers = handlers.player;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for player');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'snapshot': {
+                        innerHandlers.snapshot?.(inner.data);
+                        return;
+                    }
+                    case 'delta': {
+                        innerHandlers.delta?.(inner.data);
+                        return;
+                    }
+                    case 'queueChanged': {
+                        innerHandlers.queueChanged?.(inner.data);
+                        return;
+                    }
+                    case 'stateReply': {
+                        innerHandlers.stateReply?.(inner.data);
+                        return;
+                    }
+                    case 'queueReply': {
+                        innerHandlers.queueReply?.(inner.data);
+                        return;
+                    }
+                    case 'errorReply': {
+                        innerHandlers.errorReply?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Player: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'system': {
+                const innerHandlers = handlers.system;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for system');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'version': {
+                        innerHandlers.version?.(inner.data);
+                        return;
+                    }
+                    case 'diagnosticsReply': {
+                        innerHandlers.diagnosticsReply?.(inner.data);
+                        return;
+                    }
+                    case 'logsTailReply': {
+                        innerHandlers.logsTailReply?.(inner.data);
+                        return;
+                    }
+                    case 'logsSubscribeReply': {
+                        innerHandlers.logsSubscribeReply?.(inner.data);
+                        return;
+                    }
+                    case 'logEntry': {
+                        innerHandlers.logEntry?.(inner.data);
+                        return;
+                    }
+                    case 'otaProgress': {
+                        innerHandlers.otaProgress?.(inner.data);
+                        return;
+                    }
+                    case 'otaError': {
+                        innerHandlers.otaError?.(inner.data);
+                        return;
+                    }
+                    case 'deviceNickname': {
+                        innerHandlers.deviceNickname?.(inner.data);
+                        return;
+                    }
+                    case 'deviceNicknameChanged': {
+                        innerHandlers.deviceNicknameChanged?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('System: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'time': {
+                const innerHandlers = handlers.time;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for time');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'changed': {
+                        innerHandlers.changed?.(inner.data);
+                        return;
+                    }
+                    case 'snapshot': {
+                        innerHandlers.snapshot?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Time: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'voice': {
+                const innerHandlers = handlers.voice;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for voice');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'stateChanged': {
+                        innerHandlers.stateChanged?.(inner.data);
+                        return;
+                    }
+                    case 'stateReply': {
+                        innerHandlers.stateReply?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Voice: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'webapp': {
+                const innerHandlers = handlers.webapp;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for webapp');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.event) {
+                    case 'listReply': {
+                        innerHandlers.listReply?.(inner.data);
+                        return;
+                    }
+                    case 'currentReply': {
+                        innerHandlers.currentReply?.(inner.data);
+                        return;
+                    }
+                    case 'activeReply': {
+                        innerHandlers.activeReply?.(inner.data);
+                        return;
+                    }
+                    case 'iconReply': {
+                        innerHandlers.iconReply?.(inner.data);
+                        return;
+                    }
+                    case 'webappError': {
+                        innerHandlers.webappError?.(inner.data);
+                        return;
+                    }
+                    case 'activeChanged': {
+                        innerHandlers.activeChanged?.(inner.data);
+                        return;
+                    }
+                    case 'webappInstalled': {
+                        innerHandlers.webappInstalled?.(inner.data);
+                        return;
+                    }
+                    case 'webappUninstalled': {
+                        innerHandlers.webappUninstalled?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Webapp: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            case 'forward': {
+                const innerHandlers = handlers.forward;
+                if (!innerHandlers) {
+                    if (!partial)
+                        c.logger.warn('subscribe: no handler for forward');
+                    return;
+                }
+                const inner = data.data;
+                switch (inner.encoding) {
+                    case 'text': {
+                        innerHandlers.text?.(inner.data);
+                        return;
+                    }
+                    case 'json': {
+                        innerHandlers.json?.(inner.data);
+                        return;
+                    }
+                    case 'binary': {
+                        innerHandlers.binary?.(inner.data);
+                        return;
+                    }
+                    default: {
+                        if (!partial)
+                            c.logger.warn('Forward: no handler for inner', inner);
+                        return;
+                    }
+                }
+            }
+            default: {
+                if (!partial)
+                    c.logger.warn('subscribe: no handler for unknown wire variant', data);
+                return;
+            }
+        }
+    });
+}
+//# sourceMappingURL=dispatch.generated.js.map