@mentra/bluetooth-sdk 0.1.5 → 0.1.7

package/android/src/main/java/com/mentra/bluetoothsdk/streaming/StreamModels.kt

@@ -0,0 +1,348 @@
+package com.mentra.bluetoothsdk
+
+data class StreamVideoConfig @JvmOverloads constructor(
+    val width: Int? = null,
+    val height: Int? = null,
+    val bitrate: Int? = null,
+    val fps: Int? = null,
+) {
+    fun toMap(): Map<String, Any> =
+        listOfNotNull(
+            width?.let { "width" to it },
+            height?.let { "height" to it },
+            bitrate?.let { "bitrate" to it },
+            fps?.let { "frameRate" to it },
+        ).toMap()
+
+    companion object {
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>?): StreamVideoConfig? {
+            values ?: return null
+            return StreamVideoConfig(
+                width = numberValue(values, "width"),
+                height = numberValue(values, "height"),
+                bitrate = numberValue(values, "bitrate"),
+                fps = numberValue(values, "fps"),
+            )
+        }
+    }
+}
+
+data class StreamAudioConfig @JvmOverloads constructor(
+    val bitrate: Int? = null,
+    val sampleRate: Int? = null,
+    val echoCancellation: Boolean? = null,
+    val noiseSuppression: Boolean? = null,
+) {
+    fun toMap(): Map<String, Any> =
+        listOfNotNull(
+            bitrate?.let { "bitrate" to it },
+            sampleRate?.let { "sampleRate" to it },
+            echoCancellation?.let { "echoCancellation" to it },
+            noiseSuppression?.let { "noiseSuppression" to it },
+        ).toMap()
+
+    companion object {
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>?): StreamAudioConfig? {
+            values ?: return null
+            return StreamAudioConfig(
+                bitrate = numberValue(values, "bitrate"),
+                sampleRate = numberValue(values, "sampleRate"),
+                echoCancellation = values["echoCancellation"] as? Boolean,
+                noiseSuppression = values["noiseSuppression"] as? Boolean,
+            )
+        }
+    }
+}
+
+data class StreamRequest @JvmOverloads constructor(
+    val streamUrl: String,
+    val streamId: String = "",
+    val keepAlive: Boolean = true,
+    val keepAliveIntervalSeconds: Int = 15,
+    val sound: Boolean = true,
+    val video: StreamVideoConfig? = null,
+    val audio: StreamAudioConfig? = null,
+    val extraValues: Map<String, Any> = emptyMap(),
+) {
+    fun toMap(): Map<String, Any> {
+        val values = extraValues.toMutableMap()
+        values["type"] = "start_stream"
+        values["streamUrl"] = streamUrl
+        values["streamId"] = streamId
+        values["keepAlive"] = keepAlive
+        values["keepAliveIntervalSeconds"] = keepAliveIntervalSeconds
+        // The camera light is a privacy indicator and cannot be disabled by SDK callers.
+        values["flash"] = true
+        values["sound"] = sound
+        video?.toMap()?.takeIf { it.isNotEmpty() }?.let { values["video"] = it }
+        audio?.toMap()?.takeIf { it.isNotEmpty() }?.let { values["audio"] = it }
+        return values
+    }
+
+    companion object {
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>): StreamRequest =
+            StreamRequest(
+                streamUrl =
+                    (values["streamUrl"] ?: values["rtmpUrl"] ?: values["srtUrl"] ?: values["whipUrl"]) as? String
+                        ?: "",
+                streamId = values["streamId"] as? String ?: "",
+                keepAlive = values["keepAlive"] as? Boolean ?: true,
+                keepAliveIntervalSeconds = (values["keepAliveIntervalSeconds"] as? Number)?.toInt() ?: 15,
+                sound = values["sound"] as? Boolean ?: true,
+                video = StreamVideoConfig.fromMap(stringMapValue(values["video"])),
+                audio = StreamAudioConfig.fromMap(stringMapValue(values["audio"])),
+                extraValues = values,
+            )
+    }
+}
+
+data class StreamKeepAliveRequest @JvmOverloads constructor(
+    val streamId: String,
+    val ackId: String,
+    val extraValues: Map<String, Any> = emptyMap(),
+) {
+    fun toMap(): Map<String, Any> {
+        val values = extraValues.toMutableMap()
+        values["type"] = "keep_stream_alive"
+        values["streamId"] = streamId
+        values["ackId"] = ackId
+        return values
+    }
+
+    companion object {
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>): StreamKeepAliveRequest =
+            StreamKeepAliveRequest(
+                streamId = values["streamId"] as? String ?: "",
+                ackId = values["ackId"] as? String ?: "",
+                extraValues = values,
+            )
+    }
+}
+
+enum class StreamState(val value: String) {
+    INITIALIZING("initializing"),
+    STREAMING("streaming"),
+    STOPPING("stopping"),
+    STOPPED("stopped"),
+    RECONNECTING("reconnecting"),
+    RECONNECTED("reconnected"),
+    RECONNECT_FAILED("reconnect_failed"),
+    ERROR("error");
+
+    companion object {
+        @JvmStatic
+        fun fromValue(value: String?): StreamState? =
+            when (value?.lowercase()) {
+                "initializing", "starting", "connecting" -> INITIALIZING
+                "streaming", "streaming_started", "active" -> STREAMING
+                "stopping" -> STOPPING
+                "stopped", "not_streaming", "disconnected", "timeout" -> STOPPED
+                "reconnecting" -> RECONNECTING
+                "reconnected" -> RECONNECTED
+                "reconnect_failed" -> RECONNECT_FAILED
+                "error", "error_not_streaming" -> ERROR
+                else -> null
+            }
+    }
+}
+
+enum class StreamStatusKind(val value: String) {
+    LIFECYCLE("lifecycle"),
+    RECONNECT("reconnect"),
+    ERROR("error"),
+    SNAPSHOT("snapshot"),
+}
+
+sealed interface StreamStatus {
+    val kind: StreamStatusKind
+    val state: StreamState
+    val streamId: String?
+    val timestamp: Long?
+
+    fun toMap(): Map<String, Any> {
+        val values = mutableMapOf<String, Any>(
+            "kind" to kind.value,
+            "status" to state.value,
+        )
+        streamId?.takeIf { it.isNotBlank() }?.let { values["streamId"] = it }
+        timestamp?.let { values["timestamp"] = it }
+
+        when (this) {
+            is Lifecycle -> Unit
+            is Reconnecting -> {
+                values["attempt"] = attempt
+                values["maxAttempts"] = maxAttempts
+                values["reason"] = reason
+            }
+            is Reconnected -> values["attempt"] = attempt
+            is ReconnectFailed -> values["maxAttempts"] = maxAttempts
+            is Error -> values["errorDetails"] = errorDetails
+            is Snapshot -> {
+                values["streaming"] = streaming
+                values["reconnecting"] = reconnecting
+                attempt?.let { values["attempt"] = it }
+            }
+        }
+
+        return values
+    }
+
+    fun toEventMap(): Map<String, Any> = toMap() + mapOf("type" to "stream_status")
+
+    data class Lifecycle(
+        override val state: StreamState,
+        override val streamId: String?,
+        override val timestamp: Long?,
+    ) : StreamStatus {
+        override val kind: StreamStatusKind = StreamStatusKind.LIFECYCLE
+    }
+
+    data class Reconnecting(
+        override val streamId: String?,
+        val attempt: Int,
+        val maxAttempts: Int,
+        val reason: String,
+        override val timestamp: Long?,
+    ) : StreamStatus {
+        override val kind: StreamStatusKind = StreamStatusKind.RECONNECT
+        override val state: StreamState = StreamState.RECONNECTING
+    }
+
+    data class Reconnected(
+        override val streamId: String?,
+        val attempt: Int,
+        override val timestamp: Long?,
+    ) : StreamStatus {
+        override val kind: StreamStatusKind = StreamStatusKind.RECONNECT
+        override val state: StreamState = StreamState.RECONNECTED
+    }
+
+    data class ReconnectFailed(
+        override val streamId: String?,
+        val maxAttempts: Int,
+        override val timestamp: Long?,
+    ) : StreamStatus {
+        override val kind: StreamStatusKind = StreamStatusKind.RECONNECT
+        override val state: StreamState = StreamState.RECONNECT_FAILED
+    }
+
+    data class Error(
+        override val streamId: String?,
+        val errorDetails: String,
+        override val timestamp: Long?,
+    ) : StreamStatus {
+        override val kind: StreamStatusKind = StreamStatusKind.ERROR
+        override val state: StreamState = StreamState.ERROR
+    }
+
+    data class Snapshot(
+        override val state: StreamState,
+        val streaming: Boolean,
+        val reconnecting: Boolean,
+        override val streamId: String?,
+        val attempt: Int?,
+        override val timestamp: Long?,
+    ) : StreamStatus {
+        override val kind: StreamStatusKind = StreamStatusKind.SNAPSHOT
+    }
+
+    companion object {
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>): StreamStatus {
+            val rawState = stringValue(values, "status")
+            val streaming = boolValue(values, "streaming")
+            val reconnecting = boolValue(values, "reconnecting") ?: false
+            val streamId = stringValue(values, "streamId")
+            val timestamp = longValue(values, "timestamp")
+            val attempt = numberValue(values, "attempt")
+            val maxAttempts = numberValue(values, "maxAttempts") ?: 0
+
+            if (streaming != null || hasAnyKey(values, "reconnecting")) {
+                return Snapshot(
+                    state = when {
+                        reconnecting -> StreamState.RECONNECTING
+                        streaming == true -> StreamState.STREAMING
+                        else -> StreamState.STOPPED
+                    },
+                    streaming = streaming == true,
+                    reconnecting = reconnecting,
+                    streamId = streamId,
+                    attempt = attempt,
+                    timestamp = timestamp,
+                )
+            }
+
+            val state = StreamState.fromValue(rawState)
+                ?: return Error(
+                    streamId = streamId,
+                    errorDetails = rawState?.let { "Unknown stream status: $it" } ?: "Missing stream status",
+                    timestamp = timestamp,
+                )
+
+            return when (state) {
+                StreamState.RECONNECTING -> Reconnecting(
+                    streamId = streamId,
+                    attempt = attempt ?: 0,
+                    maxAttempts = maxAttempts,
+                    reason = stringValue(values, "reason") ?: "",
+                    timestamp = timestamp,
+                )
+                StreamState.RECONNECTED -> Reconnected(
+                    streamId = streamId,
+                    attempt = attempt ?: 0,
+                    timestamp = timestamp,
+                )
+                StreamState.RECONNECT_FAILED -> ReconnectFailed(
+                    streamId = streamId,
+                    maxAttempts = maxAttempts,
+                    timestamp = timestamp,
+                )
+                StreamState.ERROR -> Error(
+                    streamId = streamId,
+                    errorDetails = stringValue(values, "errorDetails")
+                        ?: if (rawState == "error_not_streaming") "not_streaming" else "Unknown stream error",
+                    timestamp = timestamp,
+                )
+                else -> Lifecycle(
+                    state = state,
+                    streamId = streamId,
+                    timestamp = timestamp,
+                )
+            }
+        }
+    }
+}
+
+data class StreamStatusEvent(
+    val status: StreamStatus,
+) {
+    constructor(values: Map<String, Any>) : this(StreamStatus.fromMap(values))
+
+    val state: StreamState get() = status.state
+    val streamId: String? get() = status.streamId
+    val values: Map<String, Any> get() = status.toEventMap()
+}
+
+data class KeepAliveAckEvent(
+    val streamId: String,
+    val ackId: String,
+    val timestamp: Long?,
+) {
+    constructor(values: Map<String, Any>) : this(
+        streamId = stringValue(values, "streamId").orEmpty(),
+        ackId = stringValue(values, "ackId").orEmpty(),
+        timestamp = longValue(values, "timestamp"),
+    )
+
+    val values: Map<String, Any>
+        get() = buildMap {
+            put("type", "keep_alive_ack")
+            put("streamId", streamId)
+            put("ackId", ackId)
+            timestamp?.let { put("timestamp", it) }
+        }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/stt/SherpaOnnxTranscriber.kt

@@ -226,8 +226,7 @@ class SherpaOnnxTranscriber(private val context: Context) {
      * Feed PCM audio data (16-bit little endian) into the transcriber. This method should be called
      * continuously with short chunks (e.g., 100-300ms).
      *
-     * Note: Audio passed to this method is assumed to have already passed VAD elsewhere, so it's
-     * directly queued for processing without additional VAD checks.
+     * Audio is queued directly; microphone VAD gating is not applied in the SDK.
      */
     fun acceptAudio(pcm16le: ByteArray) {
         if (!running.get()) {
@@ -235,7 +234,6 @@ class SherpaOnnxTranscriber(private val context: Context) {
             return
         }
 
-        // Directly queue the audio data for processing
         if (!pcmQueue.offer(pcm16le.copyOf())) {
             // Queue is full, drop oldest and try again
             pcmQueue.poll()

package/android/src/main/java/com/mentra/bluetoothsdk/types/DeviceModels.kt

@@ -0,0 +1,75 @@
+package com.mentra.bluetoothsdk
+
+import com.mentra.bluetoothsdk.utils.ControllerTypes
+import com.mentra.bluetoothsdk.utils.DeviceTypes
+
+data class MentraBluetoothSdkConfig(
+    val deliverCallbacksOnMainThread: Boolean = true,
+)
+
+class BluetoothException(
+    val code: String,
+    message: String,
+    cause: Throwable? = null,
+) : IllegalStateException(message, cause)
+
+enum class DeviceModel(val deviceType: String) {
+    G1(DeviceTypes.G1),
+    G2(DeviceTypes.G2),
+    MENTRA_LIVE(DeviceTypes.LIVE),
+    MENTRA_NEX(DeviceTypes.NEX),
+    MACH1(DeviceTypes.MACH1),
+    Z100(DeviceTypes.Z100),
+    FRAME(DeviceTypes.FRAME),
+    SIMULATED(DeviceTypes.SIMULATED),
+    R1(ControllerTypes.R1);
+
+    companion object {
+        @JvmStatic
+        fun fromDeviceType(deviceType: String?): DeviceModel =
+            values().firstOrNull { it.deviceType == deviceType } ?: MENTRA_LIVE
+    }
+}
+
+data class Device(
+    val model: DeviceModel,
+    val name: String,
+    /** Android Bluetooth address when available. */
+    val address: String? = null,
+    val rssi: Int? = null,
+    /** Stable app-facing scan-result key. Do not parse; use typed fields instead. */
+    val id: String = address?.takeIf { it.isNotBlank() } ?: "${model.deviceType}:$name",
+) {
+    internal fun toMap(): Map<String, Any> =
+        buildMap {
+            put("id", id)
+            put("model", model.deviceType)
+            put("name", name)
+            address?.takeIf { it.isNotBlank() }?.let {
+                put("address", it)
+            }
+            rssi?.let { put("rssi", it) }
+        }
+
+    companion object {
+        internal fun fromMap(values: Map<String, Any>): Device? {
+            val model = stringValue(values, "model") ?: return null
+            val name = stringValue(values, "name") ?: return null
+            val address = stringValue(values, "address")?.takeIf { it.isNotBlank() }
+            val rssi = numberValue(values, "rssi")
+            val id = stringValue(values, "id")?.takeIf { it.isNotBlank() } ?: address ?: "${model}:$name"
+            return Device(
+                model = DeviceModel.fromDeviceType(model),
+                name = name,
+                address = address,
+                rssi = rssi,
+                id = id,
+            )
+        }
+    }
+}
+
+data class ConnectOptions(
+    val saveAsDefault: Boolean = true,
+    val cancelExistingConnectionAttempt: Boolean = true,
+)

package/build/BluetoothSdk.types.d.ts

@@ -17,9 +17,14 @@ export type TouchEvent = {
 export type HeadUpEvent = {
     up: boolean;
 };
-export type VadStatusEvent = {
-    type: "vad_status";
-    status: boolean;
+export type VoiceActivityDetectionStatusEvent = {
+    type: "voice_activity_detection_status";
+    voiceActivityDetectionEnabled: boolean;
+};
+export type SpeakingStatusEvent = {
+    type: "speaking_status";
+    speaking: boolean;
+    timestamp: number;
 };
 export type BatteryStatusEvent = {
     type: "battery_status";
@@ -159,8 +164,6 @@ export type RgbLedControlResponseEvent = {
 };
 export type RgbLedAction = "on" | "off";
 export type RgbLedColor = "red" | "green" | "blue" | "orange" | "white";
-/** `"auto"` enables local button photo/video capture; `"manual"` reports button events without local gallery capture. */
-export type GalleryMode = "auto" | "manual";
 export type PhotoSize = "small" | "medium" | "large" | "full";
 export type ButtonPhotoSize = "small" | "medium" | "large";
 export type PhotoCompression = "none" | "medium" | "heavy";
@@ -187,13 +190,27 @@ export type CameraFovSetting = {
     fov: number;
     roiPosition: number;
 };
+type NativeCameraFovSetting = {
+    fov: number;
+    roi_position: number;
+};
 export type MicPreference = "auto" | "phone" | "glasses" | "bluetooth";
 export type MicMode = "phone" | "glasses" | "bluetoothClassic" | "bluetooth";
+export type PhotoRequestParams = {
+    requestId: string;
+    appId: string;
+    size: PhotoSize;
+    webhookUrl: string | null;
+    authToken: string | null;
+    compress: PhotoCompression;
+    sound: boolean;
+    exposureTimeNs?: number | null;
+};
 export type StreamVideoConfig = {
     width?: number;
     height?: number;
     bitrate?: number;
-    frameRate?: number;
+    fps?: number;
 };
 export type StreamAudioConfig = {
     bitrate?: number;
@@ -251,7 +268,7 @@ export type MicPcmEvent = {
     bitsPerSample: 16;
     channels: 1;
     encoding: "pcm_s16le";
-    vadGated: boolean;
+    voiceActivityDetectionEnabled: boolean;
 };
 export type MicLc3Event = {
     type: "mic_lc3";
@@ -263,7 +280,7 @@ export type MicLc3Event = {
     frameSizeBytes: number;
     bitrate: number;
     packetizedFromGlasses: boolean;
-    vadGated: boolean;
+    voiceActivityDetectionEnabled: boolean;
 };
 export type StreamStatusLifecycleState = "initializing" | "streaming" | "stopping" | "stopped";
 export type StreamStatusReconnectState = "reconnecting" | "reconnected" | "reconnect_failed";
@@ -383,7 +400,8 @@ export type BluetoothSdkModuleEvents = {
     button_press: (event: ButtonPressEvent) => void;
     touch_event: (event: TouchEvent) => void;
     head_up: (event: HeadUpEvent) => void;
-    vad_status: (event: VadStatusEvent) => void;
+    voice_activity_detection_status: (event: VoiceActivityDetectionStatusEvent) => void;
+    speaking_status: (event: SpeakingStatusEvent) => void;
     battery_status: (event: BatteryStatusEvent) => void;
     local_transcription: (event: LocalTranscriptionEvent) => void;
     wifi_status_change: (event: WifiStatusChangeEvent) => void;
@@ -417,7 +435,7 @@ export type BluetoothSdkModuleEvents = {
     miniapp_selected: (event: MiniappSelectedEvent) => void;
 };
 export type PublicGlassesStatus = Omit<GlassesStatus, "otaUpdateAvailable" | "otaProgress" | "otaInProgress" | "otaVersionUrl">;
-export type PublicBluetoothStatus = Pick<BluetoothStatus, "searching" | "searchingController" | "systemMicUnavailable" | "micRanking" | "currentMic" | "searchResults" | "wifiScanResults" | "lastLog" | "otherBtConnected" | "galleryModeAuto">;
+export type PublicBluetoothStatus = Pick<BluetoothStatus, "searching" | "searchingController" | "systemMicUnavailable" | "micRanking" | "currentMic" | "searchResults" | "wifiScanResults" | "lastLog" | "otherBtConnected" | "galleryModeEnabled">;
 export type BluetoothSdkEventMap = {
     log: LogEvent;
     device_discovered: Device;
@@ -428,7 +446,8 @@ export type BluetoothSdkEventMap = {
     button_press: ButtonPressEvent;
     touch_event: TouchEvent;
     head_up: HeadUpEvent;
-    vad_status: VadStatusEvent;
+    voice_activity_detection_status: VoiceActivityDetectionStatusEvent;
+    speaking_status: SpeakingStatusEvent;
     battery_status: BatteryStatusEvent;
     local_transcription: LocalTranscriptionEvent;
     wifi_status_change: WifiStatusChangeEvent;
@@ -479,20 +498,21 @@ export interface BluetoothSdkPublicModule {
     sendWifiCredentials(ssid: string, password: string): Promise<void>;
     forgetWifiNetwork(ssid: string): Promise<void>;
     setHotspotState(enabled: boolean): Promise<void>;
-    setGalleryMode(mode: GalleryMode): Promise<void>;
+    setGalleryModeEnabled(enabled: boolean): Promise<void>;
+    setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void>;
     setButtonPhotoSettings(size: ButtonPhotoSize): Promise<void>;
-    setButtonVideoRecordingSettings(width: number, height: number, frameRate: number): Promise<void>;
+    setButtonVideoRecordingSettings(width: number, height: number, fps: number): Promise<void>;
     setButtonCameraLed(enabled: boolean): Promise<void>;
     setButtonMaxRecordingTime(minutes: number): Promise<void>;
     setCameraFov(fov: CameraFov): Promise<void>;
     queryGalleryStatus(): Promise<void>;
-    requestPhoto(requestId: string, appId: string, size: PhotoSize, webhookUrl: string | null, authToken: string | null, compress: PhotoCompression, sound: boolean): Promise<void>;
+    requestPhoto(params: PhotoRequestParams): Promise<void>;
     startVideoRecording(requestId: string, save: boolean, sound: boolean): Promise<void>;
     stopVideoRecording(requestId: string): Promise<void>;
     startStream(params: StreamStartRequest): Promise<void>;
     stopStream(): Promise<void>;
     keepStreamAlive(params: StreamKeepAliveRequest): Promise<void>;
-    setMicState(enabled: boolean, useGlassesMic?: boolean, bypassVad?: boolean, sendTranscript?: boolean, sendLc3Data?: boolean): Promise<void>;
+    setMicState(enabled: boolean, useGlassesMic?: boolean, sendTranscript?: boolean, sendLc3Data?: boolean): Promise<void>;
     setPreferredMic(preferredMic: MicPreference): Promise<void>;
     setOwnAppAudioPlaying(playing: boolean): Promise<void>;
     getGlassesMediaVolume(): Promise<GlassesMediaVolumeGetResult>;
@@ -533,6 +553,7 @@ export interface OtaProgress {
 export interface GlassesStatus {
     connection: GlassesConnectionStatus;
     micEnabled: boolean;
+    voiceActivityDetectionEnabled: boolean;
     bluetoothClassicConnected: boolean;
     signalStrength: number;
     /** Milliseconds since epoch when signalStrength was last refreshed by the phone BLE stack. */
@@ -588,6 +609,10 @@ export interface Device {
     name: string;
     /** Platform address/identifier when available: Android Bluetooth address, iOS CoreBluetooth identifier. */
     address?: string;
+    /**
+     * Optional scan signal strength. It may be undefined at first discovery and
+     * appear in a later scan update when the platform reports RSSI metadata.
+     */
     rssi?: number;
 }
 export interface ConnectOptions {
@@ -635,7 +660,7 @@ export interface BluetoothStatus {
     wifiScanResults: WifiSearchResult[];
     lastLog: string[];
     otherBtConnected: boolean;
-    galleryModeAuto: boolean;
+    galleryModeEnabled: boolean;
 }
 export type BluetoothSettingsUpdate = Partial<{
     auth_email: string;
@@ -652,23 +677,23 @@ export type BluetoothSettingsUpdate = Partial<{
     dashboard_height: number;
     dashboard_depth: number;
     menu_apps: DashboardMenuItem[] | CoreDashboardMenuItem[] | Array<Record<string, unknown>> | null;
-    galleryModeAuto: boolean;
+    gallery_mode: boolean;
+    voice_activity_detection_enabled: boolean;
     button_photo_size: ButtonPhotoSize;
     button_video_settings: {
         width: number;
         height: number;
-        frameRate: number;
+        fps: number;
     };
     button_video_width: number;
     button_video_height: number;
     button_video_fps: number;
     button_camera_led: boolean;
     button_max_recording_time: number;
-    camera_fov: CameraFovSetting;
+    camera_fov: NativeCameraFovSetting;
     should_send_pcm: boolean;
     should_send_lc3: boolean;
     should_send_transcript: boolean;
-    bypass_vad: boolean;
     offline_mode: boolean;
     offline_captions_running: boolean;
     local_stt_fallback_active: boolean;
@@ -681,4 +706,5 @@ export type BluetoothSettingsUpdate = Partial<{
     controller_device_name: string;
     controller_address: string;
 }>;
+export {};
 //# sourceMappingURL=BluetoothSdk.types.d.ts.map