From 6341a3c3cd85ebc5b93e23eac2fba544a672a50a Mon Sep 17 00:00:00 2001
From: Hiroshi Horie <548776+hiroshihorie@users.noreply.github.com>
Date: Tue, 10 Mar 2026 02:18:17 +0900
Subject: [PATCH] gen

---
 .../LiveKit/Protos/livekit_metrics.pb.swift   |  24 +-
 .../LiveKit/Protos/livekit_models.pb.swift    | 264 +++++++++---------
 Sources/LiveKit/Protos/livekit_rtc.pb.swift   | 148 +++++-----
 3 files changed, 218 insertions(+), 218 deletions(-)

diff --git a/Sources/LiveKit/Protos/livekit_metrics.pb.swift b/Sources/LiveKit/Protos/livekit_metrics.pb.swift
index 331317ccf..162e41dc4 100644
--- a/Sources/LiveKit/Protos/livekit_metrics.pb.swift
+++ b/Sources/LiveKit/Protos/livekit_metrics.pb.swift
@@ -180,11 +180,11 @@ struct Livekit_MetricsBatch: Sendable {
   var timestampMs: Int64 = 0
 
   var normalizedTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _normalizedTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_normalizedTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_normalizedTimestamp = newValue}
   }
   /// Returns true if `normalizedTimestamp` has been explicitly set.
-  var hasNormalizedTimestamp: Bool {return self._normalizedTimestamp != nil}
+  var hasNormalizedTimestamp: Bool {self._normalizedTimestamp != nil}
   /// Clears the value of `normalizedTimestamp`. Subsequent reads from it will return its default value.
   mutating func clearNormalizedTimestamp() {self._normalizedTimestamp = nil}
 
@@ -241,11 +241,11 @@ struct Livekit_MetricSample: Sendable {
   var timestampMs: Int64 = 0
 
   var normalizedTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _normalizedTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_normalizedTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_normalizedTimestamp = newValue}
   }
   /// Returns true if `normalizedTimestamp` has been explicitly set.
-  var hasNormalizedTimestamp: Bool {return self._normalizedTimestamp != nil}
+  var hasNormalizedTimestamp: Bool {self._normalizedTimestamp != nil}
   /// Clears the value of `normalizedTimestamp`. Subsequent reads from it will return its default value.
   mutating func clearNormalizedTimestamp() {self._normalizedTimestamp = nil}
 
@@ -276,29 +276,29 @@ struct Livekit_EventMetric: Sendable {
 
   /// end time of event based on a monotonic clock (in milliseconds), if needed
   var endTimestampMs: Int64 {
-    get {return _endTimestampMs ?? 0}
+    get {_endTimestampMs ?? 0}
     set {_endTimestampMs = newValue}
   }
   /// Returns true if `endTimestampMs` has been explicitly set.
-  var hasEndTimestampMs: Bool {return self._endTimestampMs != nil}
+  var hasEndTimestampMs: Bool {self._endTimestampMs != nil}
   /// Clears the value of `endTimestampMs`. Subsequent reads from it will return its default value.
   mutating func clearEndTimestampMs() {self._endTimestampMs = nil}
 
   var normalizedStartTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _normalizedStartTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_normalizedStartTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_normalizedStartTimestamp = newValue}
   }
   /// Returns true if `normalizedStartTimestamp` has been explicitly set.
-  var hasNormalizedStartTimestamp: Bool {return self._normalizedStartTimestamp != nil}
+  var hasNormalizedStartTimestamp: Bool {self._normalizedStartTimestamp != nil}
   /// Clears the value of `normalizedStartTimestamp`. Subsequent reads from it will return its default value.
   mutating func clearNormalizedStartTimestamp() {self._normalizedStartTimestamp = nil}
 
   var normalizedEndTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _normalizedEndTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_normalizedEndTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_normalizedEndTimestamp = newValue}
   }
   /// Returns true if `normalizedEndTimestamp` has been explicitly set.
-  var hasNormalizedEndTimestamp: Bool {return self._normalizedEndTimestamp != nil}
+  var hasNormalizedEndTimestamp: Bool {self._normalizedEndTimestamp != nil}
   /// Clears the value of `normalizedEndTimestamp`. Subsequent reads from it will return its default value.
   mutating func clearNormalizedEndTimestamp() {self._normalizedEndTimestamp = nil}
 
@@ -324,11 +324,11 @@ struct Livekit_MetricsRecordingHeader: Sendable {
   var roomID: String = String()
 
   var enableUserDataTraining: Bool {
-    get {return _enableUserDataTraining ?? false}
+    get {_enableUserDataTraining ?? false}
     set {_enableUserDataTraining = newValue}
   }
   /// Returns true if `enableUserDataTraining` has been explicitly set.
-  var hasEnableUserDataTraining: Bool {return self._enableUserDataTraining != nil}
+  var hasEnableUserDataTraining: Bool {self._enableUserDataTraining != nil}
   /// Clears the value of `enableUserDataTraining`. Subsequent reads from it will return its default value.
   mutating func clearEnableUserDataTraining() {self._enableUserDataTraining = nil}
 
diff --git a/Sources/LiveKit/Protos/livekit_models.pb.swift b/Sources/LiveKit/Protos/livekit_models.pb.swift
index 25c18a8e5..68ca32ff5 100644
--- a/Sources/LiveKit/Protos/livekit_models.pb.swift
+++ b/Sources/LiveKit/Protos/livekit_models.pb.swift
@@ -751,11 +751,11 @@ struct Livekit_Room: Sendable {
   var activeRecording: Bool = false
 
   var version: Livekit_TimedVersion {
-    get {return _version ?? Livekit_TimedVersion()}
+    get {_version ?? Livekit_TimedVersion()}
     set {_version = newValue}
   }
   /// Returns true if `version` has been explicitly set.
-  var hasVersion: Bool {return self._version != nil}
+  var hasVersion: Bool {self._version != nil}
   /// Clears the value of `version`. Subsequent reads from it will return its default value.
   mutating func clearVersion() {self._version = nil}
 
@@ -845,90 +845,90 @@ struct Livekit_ParticipantInfo: @unchecked Sendable {
   // methods supported on all messages.
 
   var sid: String {
-    get {return _storage._sid}
+    get {_storage._sid}
     set {_uniqueStorage()._sid = newValue}
   }
 
   var identity: String {
-    get {return _storage._identity}
+    get {_storage._identity}
     set {_uniqueStorage()._identity = newValue}
   }
 
   var state: Livekit_ParticipantInfo.State {
-    get {return _storage._state}
+    get {_storage._state}
     set {_uniqueStorage()._state = newValue}
   }
 
   var tracks: [Livekit_TrackInfo] {
-    get {return _storage._tracks}
+    get {_storage._tracks}
     set {_uniqueStorage()._tracks = newValue}
   }
 
   var metadata: String {
-    get {return _storage._metadata}
+    get {_storage._metadata}
     set {_uniqueStorage()._metadata = newValue}
   }
 
   /// timestamp when participant joined room, in seconds
   var joinedAt: Int64 {
-    get {return _storage._joinedAt}
+    get {_storage._joinedAt}
     set {_uniqueStorage()._joinedAt = newValue}
   }
 
   /// timestamp when participant joined room, in milliseconds
   var joinedAtMs: Int64 {
-    get {return _storage._joinedAtMs}
+    get {_storage._joinedAtMs}
     set {_uniqueStorage()._joinedAtMs = newValue}
   }
 
   var name: String {
-    get {return _storage._name}
+    get {_storage._name}
     set {_uniqueStorage()._name = newValue}
   }
 
   var version: UInt32 {
-    get {return _storage._version}
+    get {_storage._version}
     set {_uniqueStorage()._version = newValue}
   }
 
   var permission: Livekit_ParticipantPermission {
-    get {return _storage._permission ?? Livekit_ParticipantPermission()}
+    get {_storage._permission ?? Livekit_ParticipantPermission()}
     set {_uniqueStorage()._permission = newValue}
   }
   /// Returns true if `permission` has been explicitly set.
-  var hasPermission: Bool {return _storage._permission != nil}
+  var hasPermission: Bool {_storage._permission != nil}
   /// Clears the value of `permission`. Subsequent reads from it will return its default value.
   mutating func clearPermission() {_uniqueStorage()._permission = nil}
 
   var region: String {
-    get {return _storage._region}
+    get {_storage._region}
     set {_uniqueStorage()._region = newValue}
   }
 
   /// indicates the participant has an active publisher connection
   /// and can publish to the server
   var isPublisher: Bool {
-    get {return _storage._isPublisher}
+    get {_storage._isPublisher}
     set {_uniqueStorage()._isPublisher = newValue}
   }
 
   var kind: Livekit_ParticipantInfo.Kind {
-    get {return _storage._kind}
+    get {_storage._kind}
     set {_uniqueStorage()._kind = newValue}
   }
 
   var attributes: Dictionary<String,String> {
-    get {return _storage._attributes}
+    get {_storage._attributes}
     set {_uniqueStorage()._attributes = newValue}
   }
 
   var disconnectReason: Livekit_DisconnectReason {
-    get {return _storage._disconnectReason}
+    get {_storage._disconnectReason}
     set {_uniqueStorage()._disconnectReason = newValue}
   }
 
   var kindDetails: [Livekit_ParticipantInfo.KindDetail] {
-    get {return _storage._kindDetails}
+    get {_storage._kindDetails}
     set {_uniqueStorage()._kindDetails = newValue}
   }
 
@@ -1159,22 +1159,22 @@ struct Livekit_TrackInfo: @unchecked Sendable {
   // methods supported on all messages.
 
   var sid: String {
-    get {return _storage._sid}
+    get {_storage._sid}
     set {_uniqueStorage()._sid = newValue}
   }
 
   var type: Livekit_TrackType {
-    get {return _storage._type}
+    get {_storage._type}
     set {_uniqueStorage()._type = newValue}
   }
 
   var name: String {
-    get {return _storage._name}
+    get {_storage._name}
     set {_uniqueStorage()._name = newValue}
   }
 
   var muted: Bool {
-    get {return _storage._muted}
+    get {_storage._muted}
     set {_uniqueStorage()._muted = newValue}
   }
 
@@ -1183,7 +1183,7 @@ struct Livekit_TrackInfo: @unchecked Sendable {
   ///
   /// NOTE: This field was marked as deprecated in the .proto file.
   var width: UInt32 {
-    get {return _storage._width}
+    get {_storage._width}
     set {_uniqueStorage()._width = newValue}
   }
 
@@ -1191,7 +1191,7 @@ struct Livekit_TrackInfo: @unchecked Sendable {
   ///
   /// NOTE: This field was marked as deprecated in the .proto file.
   var height: UInt32 {
-    get {return _storage._height}
+    get {_storage._height}
     set {_uniqueStorage()._height = newValue}
   }
 
@@ -1199,7 +1199,7 @@ struct Livekit_TrackInfo: @unchecked Sendable {
   ///
   /// NOTE: This field was marked as deprecated in the .proto file.
   var simulcast: Bool {
-    get {return _storage._simulcast}
+    get {_storage._simulcast}
     set {_uniqueStorage()._simulcast = newValue}
   }
 
@@ -1207,13 +1207,13 @@ struct Livekit_TrackInfo: @unchecked Sendable {
   ///
   /// NOTE: This field was marked as deprecated in the .proto file.
   var disableDtx: Bool {
-    get {return _storage._disableDtx}
+    get {_storage._disableDtx}
     set {_uniqueStorage()._disableDtx = newValue}
   }
 
   /// source of media
   var source: Livekit_TrackSource {
-    get {return _storage._source}
+    get {_storage._source}
     set {_uniqueStorage()._source = newValue}
   }
 
@@ -1221,23 +1221,23 @@ struct Livekit_TrackInfo: @unchecked Sendable {
   ///
   /// NOTE: This field was marked as deprecated in the .proto file.
   var layers: [Livekit_VideoLayer] {
-    get {return _storage._layers}
+    get {_storage._layers}
     set {_uniqueStorage()._layers = newValue}
   }
 
   /// mime type of codec
   var mimeType: String {
-    get {return _storage._mimeType}
+    get {_storage._mimeType}
     set {_uniqueStorage()._mimeType = newValue}
   }
 
   var mid: String {
-    get {return _storage._mid}
+    get {_storage._mid}
     set {_uniqueStorage()._mid = newValue}
   }
 
   var codecs: [Livekit_SimulcastCodecInfo] {
-    get {return _storage._codecs}
+    get {_storage._codecs}
     set {_uniqueStorage()._codecs = newValue}
   }
 
@@ -1245,42 +1245,42 @@ struct Livekit_TrackInfo: @unchecked Sendable {
   ///
   /// NOTE: This field was marked as deprecated in the .proto file.
   var stereo: Bool {
-    get {return _storage._stereo}
+    get {_storage._stereo}
     set {_uniqueStorage()._stereo = newValue}
   }
 
   /// true if RED (Redundant Encoding) is disabled for audio
   var disableRed: Bool {
-    get {return _storage._disableRed}
+    get {_storage._disableRed}
     set {_uniqueStorage()._disableRed = newValue}
   }
 
   var encryption: Livekit_Encryption.TypeEnum {
-    get {return _storage._encryption}
+    get {_storage._encryption}
     set {_uniqueStorage()._encryption = newValue}
   }
 
   var stream: String {
-    get {return _storage._stream}
+    get {_storage._stream}
     set {_uniqueStorage()._stream = newValue}
   }
 
   var version: Livekit_TimedVersion {
-    get {return _storage._version ?? Livekit_TimedVersion()}
+    get {_storage._version ?? Livekit_TimedVersion()}
     set {_uniqueStorage()._version = newValue}
   }
   /// Returns true if `version` has been explicitly set.
-  var hasVersion: Bool {return _storage._version != nil}
+  var hasVersion: Bool {_storage._version != nil}
   /// Clears the value of `version`. Subsequent reads from it will return its default value.
   mutating func clearVersion() {_uniqueStorage()._version = nil}
 
   var audioFeatures: [Livekit_AudioTrackFeature] {
-    get {return _storage._audioFeatures}
+    get {_storage._audioFeatures}
     set {_uniqueStorage()._audioFeatures = newValue}
   }
 
   var backupCodecPolicy: Livekit_BackupCodecPolicy {
-    get {return _storage._backupCodecPolicy}
+    get {_storage._backupCodecPolicy}
     set {_uniqueStorage()._backupCodecPolicy = newValue}
   }
 
@@ -1368,19 +1368,19 @@ struct Livekit_DataPacket: @unchecked Sendable {
 
   /// NOTE: This field was marked as deprecated in the .proto file.
   var kind: Livekit_DataPacket.Kind {
-    get {return _storage._kind}
+    get {_storage._kind}
     set {_uniqueStorage()._kind = newValue}
   }
 
   /// participant identity of user that sent the message
   var participantIdentity: String {
-    get {return _storage._participantIdentity}
+    get {_storage._participantIdentity}
     set {_uniqueStorage()._participantIdentity = newValue}
   }
 
   /// identities of participants who will receive the message (sent to all by default)
   var destinationIdentities: [String] {
-    get {return _storage._destinationIdentities}
+    get {_storage._destinationIdentities}
     set {_uniqueStorage()._destinationIdentities = newValue}
   }
 
@@ -1496,13 +1496,13 @@ struct Livekit_DataPacket: @unchecked Sendable {
 
   /// sequence number of reliable packet
   var sequence: UInt32 {
-    get {return _storage._sequence}
+    get {_storage._sequence}
     set {_uniqueStorage()._sequence = newValue}
   }
 
   /// sid of the user that sent the message
   var participantSid: String {
-    get {return _storage._participantSid}
+    get {_storage._participantSid}
     set {_uniqueStorage()._participantSid = newValue}
   }
 
@@ -1731,40 +1731,40 @@ struct Livekit_UserPacket: Sendable {
 
   /// topic under which the message was published
   var topic: String {
-    get {return _topic ?? String()}
+    get {_topic ?? String()}
     set {_topic = newValue}
   }
   /// Returns true if `topic` has been explicitly set.
-  var hasTopic: Bool {return self._topic != nil}
+  var hasTopic: Bool {self._topic != nil}
   /// Clears the value of `topic`. Subsequent reads from it will return its default value.
   mutating func clearTopic() {self._topic = nil}
 
   /// Unique ID to identify the message
   var id: String {
-    get {return _id ?? String()}
+    get {_id ?? String()}
     set {_id = newValue}
   }
   /// Returns true if `id` has been explicitly set.
-  var hasID: Bool {return self._id != nil}
+  var hasID: Bool {self._id != nil}
   /// Clears the value of `id`. Subsequent reads from it will return its default value.
   mutating func clearID() {self._id = nil}
 
   /// start and end time allow relating the message to specific media time
   var startTime: UInt64 {
-    get {return _startTime ?? 0}
+    get {_startTime ?? 0}
     set {_startTime = newValue}
   }
   /// Returns true if `startTime` has been explicitly set.
-  var hasStartTime: Bool {return self._startTime != nil}
+  var hasStartTime: Bool {self._startTime != nil}
   /// Clears the value of `startTime`. Subsequent reads from it will return its default value.
   mutating func clearStartTime() {self._startTime = nil}
 
   var endTime: UInt64 {
-    get {return _endTime ?? 0}
+    get {_endTime ?? 0}
     set {_endTime = newValue}
   }
   /// Returns true if `endTime` has been explicitly set.
-  var hasEndTime: Bool {return self._endTime != nil}
+  var hasEndTime: Bool {self._endTime != nil}
   /// Clears the value of `endTime`. Subsequent reads from it will return its default value.
   mutating func clearEndTime() {self._endTime = nil}
 
@@ -1846,11 +1846,11 @@ struct Livekit_ChatMessage: Sendable {
 
   /// populated only if the intent is to edit/update an existing message
   var editTimestamp: Int64 {
-    get {return _editTimestamp ?? 0}
+    get {_editTimestamp ?? 0}
     set {_editTimestamp = newValue}
   }
   /// Returns true if `editTimestamp` has been explicitly set.
-  var hasEditTimestamp: Bool {return self._editTimestamp != nil}
+  var hasEditTimestamp: Bool {self._editTimestamp != nil}
   /// Clears the value of `editTimestamp`. Subsequent reads from it will return its default value.
   mutating func clearEditTimestamp() {self._editTimestamp = nil}
 
@@ -2157,31 +2157,31 @@ struct Livekit_ClientConfiguration: Sendable {
   // methods supported on all messages.
 
   var video: Livekit_VideoConfiguration {
-    get {return _video ?? Livekit_VideoConfiguration()}
+    get {_video ?? Livekit_VideoConfiguration()}
     set {_video = newValue}
   }
   /// Returns true if `video` has been explicitly set.
-  var hasVideo: Bool {return self._video != nil}
+  var hasVideo: Bool {self._video != nil}
   /// Clears the value of `video`. Subsequent reads from it will return its default value.
   mutating func clearVideo() {self._video = nil}
 
   var screen: Livekit_VideoConfiguration {
-    get {return _screen ?? Livekit_VideoConfiguration()}
+    get {_screen ?? Livekit_VideoConfiguration()}
     set {_screen = newValue}
   }
   /// Returns true if `screen` has been explicitly set.
-  var hasScreen: Bool {return self._screen != nil}
+  var hasScreen: Bool {self._screen != nil}
   /// Clears the value of `screen`. Subsequent reads from it will return its default value.
   mutating func clearScreen() {self._screen = nil}
 
   var resumeConnection: Livekit_ClientConfigSetting = .unset
 
   var disabledCodecs: Livekit_DisabledCodecs {
-    get {return _disabledCodecs ?? Livekit_DisabledCodecs()}
+    get {_disabledCodecs ?? Livekit_DisabledCodecs()}
     set {_disabledCodecs = newValue}
   }
   /// Returns true if `disabledCodecs` has been explicitly set.
-  var hasDisabledCodecs: Bool {return self._disabledCodecs != nil}
+  var hasDisabledCodecs: Bool {self._disabledCodecs != nil}
   /// Clears the value of `disabledCodecs`. Subsequent reads from it will return its default value.
   mutating func clearDisabledCodecs() {self._disabledCodecs = nil}
 
@@ -2230,20 +2230,20 @@ struct Livekit_RTPDrift: Sendable {
   // methods supported on all messages.
 
   var startTime: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _startTime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_startTime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_startTime = newValue}
   }
   /// Returns true if `startTime` has been explicitly set.
-  var hasStartTime: Bool {return self._startTime != nil}
+  var hasStartTime: Bool {self._startTime != nil}
   /// Clears the value of `startTime`. Subsequent reads from it will return its default value.
   mutating func clearStartTime() {self._startTime = nil}
 
   var endTime: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _endTime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_endTime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_endTime = newValue}
   }
   /// Returns true if `endTime` has been explicitly set.
-  var hasEndTime: Bool {return self._endTime != nil}
+  var hasEndTime: Bool {self._endTime != nil}
   /// Clears the value of `endTime`. Subsequent reads from it will return its default value.
   mutating func clearEndTime() {self._endTime = nil}
 
@@ -2275,268 +2275,268 @@ struct Livekit_RTPStats: @unchecked Sendable {
   // methods supported on all messages.
 
   var startTime: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _storage._startTime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_storage._startTime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_uniqueStorage()._startTime = newValue}
   }
   /// Returns true if `startTime` has been explicitly set.
-  var hasStartTime: Bool {return _storage._startTime != nil}
+  var hasStartTime: Bool {_storage._startTime != nil}
   /// Clears the value of `startTime`. Subsequent reads from it will return its default value.
   mutating func clearStartTime() {_uniqueStorage()._startTime = nil}
 
   var endTime: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _storage._endTime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_storage._endTime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_uniqueStorage()._endTime = newValue}
   }
   /// Returns true if `endTime` has been explicitly set.
-  var hasEndTime: Bool {return _storage._endTime != nil}
+  var hasEndTime: Bool {_storage._endTime != nil}
   /// Clears the value of `endTime`. Subsequent reads from it will return its default value.
   mutating func clearEndTime() {_uniqueStorage()._endTime = nil}
 
   var duration: Double {
-    get {return _storage._duration}
+    get {_storage._duration}
     set {_uniqueStorage()._duration = newValue}
   }
 
   var packets: UInt32 {
-    get {return _storage._packets}
+    get {_storage._packets}
     set {_uniqueStorage()._packets = newValue}
   }
 
   var packetRate: Double {
-    get {return _storage._packetRate}
+    get {_storage._packetRate}
     set {_uniqueStorage()._packetRate = newValue}
   }
 
   var bytes: UInt64 {
-    get {return _storage._bytes}
+    get {_storage._bytes}
     set {_uniqueStorage()._bytes = newValue}
   }
 
   var headerBytes: UInt64 {
-    get {return _storage._headerBytes}
+    get {_storage._headerBytes}
     set {_uniqueStorage()._headerBytes = newValue}
   }
 
   var bitrate: Double {
-    get {return _storage._bitrate}
+    get {_storage._bitrate}
     set {_uniqueStorage()._bitrate = newValue}
   }
 
   var packetsLost: UInt32 {
-    get {return _storage._packetsLost}
+    get {_storage._packetsLost}
     set {_uniqueStorage()._packetsLost = newValue}
   }
 
   var packetLossRate: Double {
-    get {return _storage._packetLossRate}
+    get {_storage._packetLossRate}
     set {_uniqueStorage()._packetLossRate = newValue}
   }
 
   var packetLossPercentage: Float {
-    get {return _storage._packetLossPercentage}
+    get {_storage._packetLossPercentage}
     set {_uniqueStorage()._packetLossPercentage = newValue}
   }
 
   var packetsDuplicate: UInt32 {
-    get {return _storage._packetsDuplicate}
+    get {_storage._packetsDuplicate}
     set {_uniqueStorage()._packetsDuplicate = newValue}
   }
 
   var packetDuplicateRate: Double {
-    get {return _storage._packetDuplicateRate}
+    get {_storage._packetDuplicateRate}
     set {_uniqueStorage()._packetDuplicateRate = newValue}
   }
 
   var bytesDuplicate: UInt64 {
-    get {return _storage._bytesDuplicate}
+    get {_storage._bytesDuplicate}
     set {_uniqueStorage()._bytesDuplicate = newValue}
   }
 
   var headerBytesDuplicate: UInt64 {
-    get {return _storage._headerBytesDuplicate}
+    get {_storage._headerBytesDuplicate}
     set {_uniqueStorage()._headerBytesDuplicate = newValue}
   }
 
   var bitrateDuplicate: Double {
-    get {return _storage._bitrateDuplicate}
+    get {_storage._bitrateDuplicate}
     set {_uniqueStorage()._bitrateDuplicate = newValue}
   }
 
   var packetsPadding: UInt32 {
-    get {return _storage._packetsPadding}
+    get {_storage._packetsPadding}
     set {_uniqueStorage()._packetsPadding = newValue}
   }
 
   var packetPaddingRate: Double {
-    get {return _storage._packetPaddingRate}
+    get {_storage._packetPaddingRate}
     set {_uniqueStorage()._packetPaddingRate = newValue}
   }
 
   var bytesPadding: UInt64 {
-    get {return _storage._bytesPadding}
+    get {_storage._bytesPadding}
     set {_uniqueStorage()._bytesPadding = newValue}
   }
 
   var headerBytesPadding: UInt64 {
-    get {return _storage._headerBytesPadding}
+    get {_storage._headerBytesPadding}
     set {_uniqueStorage()._headerBytesPadding = newValue}
   }
 
   var bitratePadding: Double {
-    get {return _storage._bitratePadding}
+    get {_storage._bitratePadding}
     set {_uniqueStorage()._bitratePadding = newValue}
   }
 
   var packetsOutOfOrder: UInt32 {
-    get {return _storage._packetsOutOfOrder}
+    get {_storage._packetsOutOfOrder}
     set {_uniqueStorage()._packetsOutOfOrder = newValue}
   }
 
   var frames: UInt32 {
-    get {return _storage._frames}
+    get {_storage._frames}
     set {_uniqueStorage()._frames = newValue}
   }
 
   var frameRate: Double {
-    get {return _storage._frameRate}
+    get {_storage._frameRate}
     set {_uniqueStorage()._frameRate = newValue}
   }
 
   var jitterCurrent: Double {
-    get {return _storage._jitterCurrent}
+    get {_storage._jitterCurrent}
     set {_uniqueStorage()._jitterCurrent = newValue}
   }
 
   var jitterMax: Double {
-    get {return _storage._jitterMax}
+    get {_storage._jitterMax}
     set {_uniqueStorage()._jitterMax = newValue}
   }
 
   var gapHistogram: Dictionary<Int32,UInt32> {
-    get {return _storage._gapHistogram}
+    get {_storage._gapHistogram}
     set {_uniqueStorage()._gapHistogram = newValue}
   }
 
   var nacks: UInt32 {
-    get {return _storage._nacks}
+    get {_storage._nacks}
     set {_uniqueStorage()._nacks = newValue}
   }
 
   var nackAcks: UInt32 {
-    get {return _storage._nackAcks}
+    get {_storage._nackAcks}
     set {_uniqueStorage()._nackAcks = newValue}
   }
 
   var nackMisses: UInt32 {
-    get {return _storage._nackMisses}
+    get {_storage._nackMisses}
     set {_uniqueStorage()._nackMisses = newValue}
   }
 
   var nackRepeated: UInt32 {
-    get {return _storage._nackRepeated}
+    get {_storage._nackRepeated}
     set {_uniqueStorage()._nackRepeated = newValue}
   }
 
   var plis: UInt32 {
-    get {return _storage._plis}
+    get {_storage._plis}
     set {_uniqueStorage()._plis = newValue}
   }
 
   var lastPli: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _storage._lastPli ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_storage._lastPli ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_uniqueStorage()._lastPli = newValue}
   }
   /// Returns true if `lastPli` has been explicitly set.
-  var hasLastPli: Bool {return _storage._lastPli != nil}
+  var hasLastPli: Bool {_storage._lastPli != nil}
   /// Clears the value of `lastPli`. Subsequent reads from it will return its default value.
   mutating func clearLastPli() {_uniqueStorage()._lastPli = nil}
 
   var firs: UInt32 {
-    get {return _storage._firs}
+    get {_storage._firs}
     set {_uniqueStorage()._firs = newValue}
   }
 
   var lastFir: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _storage._lastFir ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_storage._lastFir ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_uniqueStorage()._lastFir = newValue}
   }
   /// Returns true if `lastFir` has been explicitly set.
-  var hasLastFir: Bool {return _storage._lastFir != nil}
+  var hasLastFir: Bool {_storage._lastFir != nil}
   /// Clears the value of `lastFir`. Subsequent reads from it will return its default value.
   mutating func clearLastFir() {_uniqueStorage()._lastFir = nil}
 
   var rttCurrent: UInt32 {
-    get {return _storage._rttCurrent}
+    get {_storage._rttCurrent}
     set {_uniqueStorage()._rttCurrent = newValue}
   }
 
   var rttMax: UInt32 {
-    get {return _storage._rttMax}
+    get {_storage._rttMax}
     set {_uniqueStorage()._rttMax = newValue}
   }
 
   var keyFrames: UInt32 {
-    get {return _storage._keyFrames}
+    get {_storage._keyFrames}
     set {_uniqueStorage()._keyFrames = newValue}
   }
 
   var lastKeyFrame: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _storage._lastKeyFrame ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_storage._lastKeyFrame ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_uniqueStorage()._lastKeyFrame = newValue}
   }
   /// Returns true if `lastKeyFrame` has been explicitly set.
-  var hasLastKeyFrame: Bool {return _storage._lastKeyFrame != nil}
+  var hasLastKeyFrame: Bool {_storage._lastKeyFrame != nil}
   /// Clears the value of `lastKeyFrame`. Subsequent reads from it will return its default value.
   mutating func clearLastKeyFrame() {_uniqueStorage()._lastKeyFrame = nil}
 
   var layerLockPlis: UInt32 {
-    get {return _storage._layerLockPlis}
+    get {_storage._layerLockPlis}
     set {_uniqueStorage()._layerLockPlis = newValue}
   }
 
   var lastLayerLockPli: SwiftProtobuf.Google_Protobuf_Timestamp {
-    get {return _storage._lastLayerLockPli ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    get {_storage._lastLayerLockPli ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
     set {_uniqueStorage()._lastLayerLockPli = newValue}
   }
   /// Returns true if `lastLayerLockPli` has been explicitly set.
-  var hasLastLayerLockPli: Bool {return _storage._lastLayerLockPli != nil}
+  var hasLastLayerLockPli: Bool {_storage._lastLayerLockPli != nil}
   /// Clears the value of `lastLayerLockPli`. Subsequent reads from it will return its default value.
   mutating func clearLastLayerLockPli() {_uniqueStorage()._lastLayerLockPli = nil}
 
   var packetDrift: Livekit_RTPDrift {
-    get {return _storage._packetDrift ?? Livekit_RTPDrift()}
+    get {_storage._packetDrift ?? Livekit_RTPDrift()}
     set {_uniqueStorage()._packetDrift = newValue}
   }
   /// Returns true if `packetDrift` has been explicitly set.
-  var hasPacketDrift: Bool {return _storage._packetDrift != nil}
+  var hasPacketDrift: Bool {_storage._packetDrift != nil}
   /// Clears the value of `packetDrift`. Subsequent reads from it will return its default value.
   mutating func clearPacketDrift() {_uniqueStorage()._packetDrift = nil}
 
   var ntpReportDrift: Livekit_RTPDrift {
-    get {return _storage._ntpReportDrift ?? Livekit_RTPDrift()}
+    get {_storage._ntpReportDrift ?? Livekit_RTPDrift()}
     set {_uniqueStorage()._ntpReportDrift = newValue}
   }
   /// Returns true if `ntpReportDrift` has been explicitly set.
-  var hasNtpReportDrift: Bool {return _storage._ntpReportDrift != nil}
+  var hasNtpReportDrift: Bool {_storage._ntpReportDrift != nil}
   /// Clears the value of `ntpReportDrift`. Subsequent reads from it will return its default value.
   mutating func clearNtpReportDrift() {_uniqueStorage()._ntpReportDrift = nil}
 
   var rebasedReportDrift: Livekit_RTPDrift {
-    get {return _storage._rebasedReportDrift ?? Livekit_RTPDrift()}
+    get {_storage._rebasedReportDrift ?? Livekit_RTPDrift()}
     set {_uniqueStorage()._rebasedReportDrift = newValue}
   }
   /// Returns true if `rebasedReportDrift` has been explicitly set.
-  var hasRebasedReportDrift: Bool {return _storage._rebasedReportDrift != nil}
+  var hasRebasedReportDrift: Bool {_storage._rebasedReportDrift != nil}
   /// Clears the value of `rebasedReportDrift`. Subsequent reads from it will return its default value.
   mutating func clearRebasedReportDrift() {_uniqueStorage()._rebasedReportDrift = nil}
 
   /// NEXT_ID: 48
   var receivedReportDrift: Livekit_RTPDrift {
-    get {return _storage._receivedReportDrift ?? Livekit_RTPDrift()}
+    get {_storage._receivedReportDrift ?? Livekit_RTPDrift()}
     set {_uniqueStorage()._receivedReportDrift = newValue}
   }
   /// Returns true if `receivedReportDrift` has been explicitly set.
-  var hasReceivedReportDrift: Bool {return _storage._receivedReportDrift != nil}
+  var hasReceivedReportDrift: Bool {_storage._receivedReportDrift != nil}
   /// Clears the value of `receivedReportDrift`. Subsequent reads from it will return its default value.
   mutating func clearReceivedReportDrift() {_uniqueStorage()._receivedReportDrift = nil}
 
@@ -2578,36 +2578,36 @@ struct Livekit_RTPForwarderState: @unchecked Sendable {
   // methods supported on all messages.
 
   var started: Bool {
-    get {return _storage._started}
+    get {_storage._started}
     set {_uniqueStorage()._started = newValue}
   }
 
   var referenceLayerSpatial: Int32 {
-    get {return _storage._referenceLayerSpatial}
+    get {_storage._referenceLayerSpatial}
     set {_uniqueStorage()._referenceLayerSpatial = newValue}
   }
 
   var preStartTime: Int64 {
-    get {return _storage._preStartTime}
+    get {_storage._preStartTime}
     set {_uniqueStorage()._preStartTime = newValue}
   }
 
   var extFirstTimestamp: UInt64 {
-    get {return _storage._extFirstTimestamp}
+    get {_storage._extFirstTimestamp}
     set {_uniqueStorage()._extFirstTimestamp = newValue}
   }
 
   var dummyStartTimestampOffset: UInt64 {
-    get {return _storage._dummyStartTimestampOffset}
+    get {_storage._dummyStartTimestampOffset}
     set {_uniqueStorage()._dummyStartTimestampOffset = newValue}
   }
 
   var rtpMunger: Livekit_RTPMungerState {
-    get {return _storage._rtpMunger ?? Livekit_RTPMungerState()}
+    get {_storage._rtpMunger ?? Livekit_RTPMungerState()}
     set {_uniqueStorage()._rtpMunger = newValue}
   }
   /// Returns true if `rtpMunger` has been explicitly set.
-  var hasRtpMunger: Bool {return _storage._rtpMunger != nil}
+  var hasRtpMunger: Bool {_storage._rtpMunger != nil}
   /// Clears the value of `rtpMunger`. Subsequent reads from it will return its default value.
   mutating func clearRtpMunger() {_uniqueStorage()._rtpMunger = nil}
 
@@ -2625,7 +2625,7 @@ struct Livekit_RTPForwarderState: @unchecked Sendable {
   }
 
   var senderReportState: [Livekit_RTCPSenderReportState] {
-    get {return _storage._senderReportState}
+    get {_storage._senderReportState}
     set {_uniqueStorage()._senderReportState = newValue}
   }
 
@@ -2807,11 +2807,11 @@ struct Livekit_DataStream: Sendable {
 
     /// only populated for finite streams, if it's a stream of unknown size this stays empty
     var totalLength: UInt64 {
-      get {return _totalLength ?? 0}
+      get {_totalLength ?? 0}
       set {_totalLength = newValue}
     }
     /// Returns true if `totalLength` has been explicitly set.
-    var hasTotalLength: Bool {return self._totalLength != nil}
+    var hasTotalLength: Bool {self._totalLength != nil}
     /// Clears the value of `totalLength`. Subsequent reads from it will return its default value.
     mutating func clearTotalLength() {self._totalLength = nil}
 
@@ -2876,11 +2876,11 @@ struct Livekit_DataStream: Sendable {
     ///
     /// NOTE: This field was marked as deprecated in the .proto file.
     var iv: Data {
-      get {return _iv ?? Data()}
+      get {_iv ?? Data()}
       set {_iv = newValue}
     }
     /// Returns true if `iv` has been explicitly set.
-    var hasIv: Bool {return self._iv != nil}
+    var hasIv: Bool {self._iv != nil}
     /// Clears the value of `iv`. Subsequent reads from it will return its default value.
     mutating func clearIv() {self._iv = nil}
 
diff --git a/Sources/LiveKit/Protos/livekit_rtc.pb.swift b/Sources/LiveKit/Protos/livekit_rtc.pb.swift
index c4687f88b..cdeeaadad 100644
--- a/Sources/LiveKit/Protos/livekit_rtc.pb.swift
+++ b/Sources/LiveKit/Protos/livekit_rtc.pb.swift
@@ -662,33 +662,33 @@ struct Livekit_AddTrackRequest: @unchecked Sendable {
 
   /// client ID of track, to match it when RTC track is received
   var cid: String {
-    get {return _storage._cid}
+    get {_storage._cid}
     set {_uniqueStorage()._cid = newValue}
   }
 
   var name: String {
-    get {return _storage._name}
+    get {_storage._name}
     set {_uniqueStorage()._name = newValue}
   }
 
   var type: Livekit_TrackType {
-    get {return _storage._type}
+    get {_storage._type}
     set {_uniqueStorage()._type = newValue}
   }
 
   var width: UInt32 {
-    get {return _storage._width}
+    get {_storage._width}
     set {_uniqueStorage()._width = newValue}
   }
 
   var height: UInt32 {
-    get {return _storage._height}
+    get {_storage._height}
     set {_uniqueStorage()._height = newValue}
   }
 
   /// true to add track and initialize to muted
   var muted: Bool {
-    get {return _storage._muted}
+    get {_storage._muted}
     set {_uniqueStorage()._muted = newValue}
   }
 
@@ -696,28 +696,28 @@ struct Livekit_AddTrackRequest: @unchecked Sendable {
   ///
   /// NOTE: This field was marked as deprecated in the .proto file.
   var disableDtx: Bool {
-    get {return _storage._disableDtx}
+    get {_storage._disableDtx}
     set {_uniqueStorage()._disableDtx = newValue}
   }
 
   var source: Livekit_TrackSource {
-    get {return _storage._source}
+    get {_storage._source}
     set {_uniqueStorage()._source = newValue}
   }
 
   var layers: [Livekit_VideoLayer] {
-    get {return _storage._layers}
+    get {_storage._layers}
     set {_uniqueStorage()._layers = newValue}
   }
 
   var simulcastCodecs: [Livekit_SimulcastCodec] {
-    get {return _storage._simulcastCodecs}
+    get {_storage._simulcastCodecs}
     set {_uniqueStorage()._simulcastCodecs = newValue}
   }
 
   /// server ID of track, publish new codec to exist track
   var sid: String {
-    get {return _storage._sid}
+    get {_storage._sid}
     set {_uniqueStorage()._sid = newValue}
   }
 
@@ -725,35 +725,35 @@ struct Livekit_AddTrackRequest: @unchecked Sendable {
   ///
   /// NOTE: This field was marked as deprecated in the .proto file.
   var stereo: Bool {
-    get {return _storage._stereo}
+    get {_storage._stereo}
     set {_uniqueStorage()._stereo = newValue}
   }
 
   /// true if RED (Redundant Encoding) is disabled for audio
   var disableRed: Bool {
-    get {return _storage._disableRed}
+    get {_storage._disableRed}
     set {_uniqueStorage()._disableRed = newValue}
   }
 
   var encryption: Livekit_Encryption.TypeEnum {
-    get {return _storage._encryption}
+    get {_storage._encryption}
     set {_uniqueStorage()._encryption = newValue}
   }
 
   /// which stream the track belongs to, used to group tracks together.
   /// if not specified, server will infer it from track source to bundle camera/microphone, screenshare/audio together
   var stream: String {
-    get {return _storage._stream}
+    get {_storage._stream}
     set {_uniqueStorage()._stream = newValue}
   }
 
   var backupCodecPolicy: Livekit_BackupCodecPolicy {
-    get {return _storage._backupCodecPolicy}
+    get {_storage._backupCodecPolicy}
     set {_uniqueStorage()._backupCodecPolicy = newValue}
   }
 
   var audioFeatures: [Livekit_AudioTrackFeature] {
-    get {return _storage._audioFeatures}
+    get {_storage._audioFeatures}
     set {_uniqueStorage()._audioFeatures = newValue}
   }
 
@@ -800,100 +800,100 @@ struct Livekit_JoinResponse: @unchecked Sendable {
   // methods supported on all messages.
 
   var room: Livekit_Room {
-    get {return _storage._room ?? Livekit_Room()}
+    get {_storage._room ?? Livekit_Room()}
     set {_uniqueStorage()._room = newValue}
   }
   /// Returns true if `room` has been explicitly set.
-  var hasRoom: Bool {return _storage._room != nil}
+  var hasRoom: Bool {_storage._room != nil}
   /// Clears the value of `room`. Subsequent reads from it will return its default value.
   mutating func clearRoom() {_uniqueStorage()._room = nil}
 
   var participant: Livekit_ParticipantInfo {
-    get {return _storage._participant ?? Livekit_ParticipantInfo()}
+    get {_storage._participant ?? Livekit_ParticipantInfo()}
     set {_uniqueStorage()._participant = newValue}
   }
   /// Returns true if `participant` has been explicitly set.
-  var hasParticipant: Bool {return _storage._participant != nil}
+  var hasParticipant: Bool {_storage._participant != nil}
   /// Clears the value of `participant`. Subsequent reads from it will return its default value.
   mutating func clearParticipant() {_uniqueStorage()._participant = nil}
 
   var otherParticipants: [Livekit_ParticipantInfo] {
-    get {return _storage._otherParticipants}
+    get {_storage._otherParticipants}
     set {_uniqueStorage()._otherParticipants = newValue}
   }
 
   /// deprecated. use server_info.version instead.
   var serverVersion: String {
-    get {return _storage._serverVersion}
+    get {_storage._serverVersion}
     set {_uniqueStorage()._serverVersion = newValue}
   }
 
   var iceServers: [Livekit_ICEServer] {
-    get {return _storage._iceServers}
+    get {_storage._iceServers}
     set {_uniqueStorage()._iceServers = newValue}
   }
 
   /// use subscriber as the primary PeerConnection
   var subscriberPrimary: Bool {
-    get {return _storage._subscriberPrimary}
+    get {_storage._subscriberPrimary}
     set {_uniqueStorage()._subscriberPrimary = newValue}
   }
 
   /// when the current server isn't available, return alternate url to retry connection
   /// when this is set, the other fields will be largely empty
   var alternativeURL: String {
-    get {return _storage._alternativeURL}
+    get {_storage._alternativeURL}
     set {_uniqueStorage()._alternativeURL = newValue}
   }
 
   var clientConfiguration: Livekit_ClientConfiguration {
-    get {return _storage._clientConfiguration ?? Livekit_ClientConfiguration()}
+    get {_storage._clientConfiguration ?? Livekit_ClientConfiguration()}
     set {_uniqueStorage()._clientConfiguration = newValue}
   }
   /// Returns true if `clientConfiguration` has been explicitly set.
-  var hasClientConfiguration: Bool {return _storage._clientConfiguration != nil}
+  var hasClientConfiguration: Bool {_storage._clientConfiguration != nil}
   /// Clears the value of `clientConfiguration`. Subsequent reads from it will return its default value.
   mutating func clearClientConfiguration() {_uniqueStorage()._clientConfiguration = nil}
 
   /// deprecated. use server_info.region instead.
   var serverRegion: String {
-    get {return _storage._serverRegion}
+    get {_storage._serverRegion}
     set {_uniqueStorage()._serverRegion = newValue}
   }
 
   var pingTimeout: Int32 {
-    get {return _storage._pingTimeout}
+    get {_storage._pingTimeout}
     set {_uniqueStorage()._pingTimeout = newValue}
   }
 
   var pingInterval: Int32 {
-    get {return _storage._pingInterval}
+    get {_storage._pingInterval}
     set {_uniqueStorage()._pingInterval = newValue}
   }
 
   var serverInfo: Livekit_ServerInfo {
-    get {return _storage._serverInfo ?? Livekit_ServerInfo()}
+    get {_storage._serverInfo ?? Livekit_ServerInfo()}
     set {_uniqueStorage()._serverInfo = newValue}
   }
   /// Returns true if `serverInfo` has been explicitly set.
-  var hasServerInfo: Bool {return _storage._serverInfo != nil}
+  var hasServerInfo: Bool {_storage._serverInfo != nil}
   /// Clears the value of `serverInfo`. Subsequent reads from it will return its default value.
   mutating func clearServerInfo() {_uniqueStorage()._serverInfo = nil}
 
   /// Server-Injected-Frame byte trailer, used to identify unencrypted frames when e2ee is enabled
   var sifTrailer: Data {
-    get {return _storage._sifTrailer}
+    get {_storage._sifTrailer}
     set {_uniqueStorage()._sifTrailer = newValue}
   }
 
   var enabledPublishCodecs: [Livekit_Codec] {
-    get {return _storage._enabledPublishCodecs}
+    get {_storage._enabledPublishCodecs}
     set {_uniqueStorage()._enabledPublishCodecs = newValue}
   }
 
   /// when set, client should attempt to establish publish peer connection when joining room to speed up publishing
   var fastPublish: Bool {
-    get {return _storage._fastPublish}
+    get {_storage._fastPublish}
     set {_uniqueStorage()._fastPublish = newValue}
   }
 
@@ -912,20 +912,20 @@ struct Livekit_ReconnectResponse: Sendable {
   var iceServers: [Livekit_ICEServer] = []
 
   var clientConfiguration: Livekit_ClientConfiguration {
-    get {return _clientConfiguration ?? Livekit_ClientConfiguration()}
+    get {_clientConfiguration ?? Livekit_ClientConfiguration()}
     set {_clientConfiguration = newValue}
   }
   /// Returns true if `clientConfiguration` has been explicitly set.
-  var hasClientConfiguration: Bool {return self._clientConfiguration != nil}
+  var hasClientConfiguration: Bool {self._clientConfiguration != nil}
   /// Clears the value of `clientConfiguration`. Subsequent reads from it will return its default value.
   mutating func clearClientConfiguration() {self._clientConfiguration = nil}
 
   var serverInfo: Livekit_ServerInfo {
-    get {return _serverInfo ?? Livekit_ServerInfo()}
+    get {_serverInfo ?? Livekit_ServerInfo()}
     set {_serverInfo = newValue}
   }
   /// Returns true if `serverInfo` has been explicitly set.
-  var hasServerInfo: Bool {return self._serverInfo != nil}
+  var hasServerInfo: Bool {self._serverInfo != nil}
   /// Clears the value of `serverInfo`. Subsequent reads from it will return its default value.
   mutating func clearServerInfo() {self._serverInfo = nil}
 
@@ -948,11 +948,11 @@ struct Livekit_TrackPublishedResponse: Sendable {
   var cid: String = String()
 
   var track: Livekit_TrackInfo {
-    get {return _track ?? Livekit_TrackInfo()}
+    get {_track ?? Livekit_TrackInfo()}
     set {_track = newValue}
   }
   /// Returns true if `track` has been explicitly set.
-  var hasTrack: Bool {return self._track != nil}
+  var hasTrack: Bool {self._track != nil}
   /// Clears the value of `track`. Subsequent reads from it will return its default value.
   mutating func clearTrack() {self._track = nil}
 
@@ -1100,11 +1100,11 @@ struct Livekit_LeaveRequest: Sendable {
   var action: Livekit_LeaveRequest.Action = .disconnect
 
   var regions: Livekit_RegionSettings {
-    get {return _regions ?? Livekit_RegionSettings()}
+    get {_regions ?? Livekit_RegionSettings()}
     set {_regions = newValue}
   }
   /// Returns true if `regions` has been explicitly set.
-  var hasRegions: Bool {return self._regions != nil}
+  var hasRegions: Bool {self._regions != nil}
   /// Clears the value of `regions`. Subsequent reads from it will return its default value.
   mutating func clearRegions() {self._regions = nil}
 
@@ -1231,11 +1231,11 @@ struct Livekit_RoomUpdate: Sendable {
   // methods supported on all messages.
 
   var room: Livekit_Room {
-    get {return _room ?? Livekit_Room()}
+    get {_room ?? Livekit_Room()}
     set {_room = newValue}
   }
   /// Returns true if `room` has been explicitly set.
-  var hasRoom: Bool {return self._room != nil}
+  var hasRoom: Bool {self._room != nil}
   /// Clears the value of `room`. Subsequent reads from it will return its default value.
   mutating func clearRoom() {self._room = nil}
 
@@ -1417,31 +1417,31 @@ struct Livekit_RoomMovedResponse: @unchecked Sendable {
 
   /// information about the new room
   var room: Livekit_Room {
-    get {return _storage._room ?? Livekit_Room()}
+    get {_storage._room ?? Livekit_Room()}
     set {_uniqueStorage()._room = newValue}
   }
   /// Returns true if `room` has been explicitly set.
-  var hasRoom: Bool {return _storage._room != nil}
+  var hasRoom: Bool {_storage._room != nil}
   /// Clears the value of `room`. Subsequent reads from it will return its default value.
   mutating func clearRoom() {_uniqueStorage()._room = nil}
 
   /// new reconnect token that can be used to reconnect to the new room
   var token: String {
-    get {return _storage._token}
+    get {_storage._token}
     set {_uniqueStorage()._token = newValue}
   }
 
   var participant: Livekit_ParticipantInfo {
-    get {return _storage._participant ?? Livekit_ParticipantInfo()}
+    get {_storage._participant ?? Livekit_ParticipantInfo()}
     set {_uniqueStorage()._participant = newValue}
   }
   /// Returns true if `participant` has been explicitly set.
-  var hasParticipant: Bool {return _storage._participant != nil}
+  var hasParticipant: Bool {_storage._participant != nil}
   /// Clears the value of `participant`. Subsequent reads from it will return its default value.
   mutating func clearParticipant() {_uniqueStorage()._participant = nil}
 
   var otherParticipants: [Livekit_ParticipantInfo] {
-    get {return _storage._otherParticipants}
+    get {_storage._otherParticipants}
     set {_uniqueStorage()._otherParticipants = newValue}
   }
 
@@ -1461,20 +1461,20 @@ struct Livekit_SyncState: Sendable {
   /// subscribe answer if using dual peer connection
   /// publish answer if using single peer connection
   var answer: Livekit_SessionDescription {
-    get {return _answer ?? Livekit_SessionDescription()}
+    get {_answer ?? Livekit_SessionDescription()}
     set {_answer = newValue}
   }
   /// Returns true if `answer` has been explicitly set.
-  var hasAnswer: Bool {return self._answer != nil}
+  var hasAnswer: Bool {self._answer != nil}
   /// Clears the value of `answer`. Subsequent reads from it will return its default value.
   mutating func clearAnswer() {self._answer = nil}
 
   var subscription: Livekit_UpdateSubscription {
-    get {return _subscription ?? Livekit_UpdateSubscription()}
+    get {_subscription ?? Livekit_UpdateSubscription()}
     set {_subscription = newValue}
   }
   /// Returns true if `subscription` has been explicitly set.
-  var hasSubscription: Bool {return self._subscription != nil}
+  var hasSubscription: Bool {self._subscription != nil}
   /// Clears the value of `subscription`. Subsequent reads from it will return its default value.
   mutating func clearSubscription() {self._subscription = nil}
 
@@ -1486,11 +1486,11 @@ struct Livekit_SyncState: Sendable {
   /// received server side offer if using dual peer connection
   /// sent client side offer if using single peer connection
   var offer: Livekit_SessionDescription {
-    get {return _offer ?? Livekit_SessionDescription()}
+    get {_offer ?? Livekit_SessionDescription()}
     set {_offer = newValue}
   }
   /// Returns true if `offer` has been explicitly set.
-  var hasOffer: Bool {return self._offer != nil}
+  var hasOffer: Bool {self._offer != nil}
   /// Clears the value of `offer`. Subsequent reads from it will return its default value.
   mutating func clearOffer() {self._offer = nil}
 
@@ -1878,11 +1878,11 @@ struct Livekit_ConnectionSettings: Sendable {
   var adaptiveStream: Bool = false
 
   var subscriberAllowPause: Bool {
-    get {return _subscriberAllowPause ?? false}
+    get {_subscriberAllowPause ?? false}
     set {_subscriberAllowPause = newValue}
   }
   /// Returns true if `subscriberAllowPause` has been explicitly set.
-  var hasSubscriberAllowPause: Bool {return self._subscriberAllowPause != nil}
+  var hasSubscriberAllowPause: Bool {self._subscriberAllowPause != nil}
   /// Clears the value of `subscriberAllowPause`. Subsequent reads from it will return its default value.
   mutating func clearSubscriberAllowPause() {self._subscriberAllowPause = nil}
 
@@ -1901,26 +1901,26 @@ struct Livekit_JoinRequest: @unchecked Sendable {
   // methods supported on all messages.
 
   var clientInfo: Livekit_ClientInfo {
-    get {return _storage._clientInfo ?? Livekit_ClientInfo()}
+    get {_storage._clientInfo ?? Livekit_ClientInfo()}
     set {_uniqueStorage()._clientInfo = newValue}
   }
   /// Returns true if `clientInfo` has been explicitly set.
-  var hasClientInfo: Bool {return _storage._clientInfo != nil}
+  var hasClientInfo: Bool {_storage._clientInfo != nil}
   /// Clears the value of `clientInfo`. Subsequent reads from it will return its default value.
   mutating func clearClientInfo() {_uniqueStorage()._clientInfo = nil}
 
   var connectionSettings: Livekit_ConnectionSettings {
-    get {return _storage._connectionSettings ?? Livekit_ConnectionSettings()}
+    get {_storage._connectionSettings ?? Livekit_ConnectionSettings()}
     set {_uniqueStorage()._connectionSettings = newValue}
   }
   /// Returns true if `connectionSettings` has been explicitly set.
-  var hasConnectionSettings: Bool {return _storage._connectionSettings != nil}
+  var hasConnectionSettings: Bool {_storage._connectionSettings != nil}
   /// Clears the value of `connectionSettings`. Subsequent reads from it will return its default value.
   mutating func clearConnectionSettings() {_uniqueStorage()._connectionSettings = nil}
 
   /// if not empty, will overwrite `metadata` in token
   var metadata: String {
-    get {return _storage._metadata}
+    get {_storage._metadata}
     set {_uniqueStorage()._metadata = newValue}
   }
 
@@ -1928,45 +1928,45 @@ struct Livekit_JoinRequest: @unchecked Sendable {
   /// will overwrite if the same key is in the token
   /// will not delete keys from token if there is a key collision and this sets that key to empty value
   var participantAttributes: Dictionary<String,String> {
-    get {return _storage._participantAttributes}
+    get {_storage._participantAttributes}
     set {_uniqueStorage()._participantAttributes = newValue}
   }
 
   var addTrackRequests: [Livekit_AddTrackRequest] {
-    get {return _storage._addTrackRequests}
+    get {_storage._addTrackRequests}
     set {_uniqueStorage()._addTrackRequests = newValue}
   }
 
   var publisherOffer: Livekit_SessionDescription {
-    get {return _storage._publisherOffer ?? Livekit_SessionDescription()}
+    get {_storage._publisherOffer ?? Livekit_SessionDescription()}
     set {_uniqueStorage()._publisherOffer = newValue}
   }
   /// Returns true if `publisherOffer` has been explicitly set.
-  var hasPublisherOffer: Bool {return _storage._publisherOffer != nil}
+  var hasPublisherOffer: Bool {_storage._publisherOffer != nil}
   /// Clears the value of `publisherOffer`. Subsequent reads from it will return its default value.
   mutating func clearPublisherOffer() {_uniqueStorage()._publisherOffer = nil}
 
   var reconnect: Bool {
-    get {return _storage._reconnect}
+    get {_storage._reconnect}
     set {_uniqueStorage()._reconnect = newValue}
   }
 
   var reconnectReason: Livekit_ReconnectReason {
-    get {return _storage._reconnectReason}
+    get {_storage._reconnectReason}
     set {_uniqueStorage()._reconnectReason = newValue}
   }
 
   var participantSid: String {
-    get {return _storage._participantSid}
+    get {_storage._participantSid}
     set {_uniqueStorage()._participantSid = newValue}
   }
 
   var syncState: Livekit_SyncState {
-    get {return _storage._syncState ?? Livekit_SyncState()}
+    get {_storage._syncState ?? Livekit_SyncState()}
     set {_uniqueStorage()._syncState = newValue}
   }
   /// Returns true if `syncState` has been explicitly set.
-  var hasSyncState: Bool {return _storage._syncState != nil}
+  var hasSyncState: Bool {_storage._syncState != nil}
   /// Clears the value of `syncState`. Subsequent reads from it will return its default value.
   mutating func clearSyncState() {_uniqueStorage()._syncState = nil}