diff --git a/livekit-api/src/services/egress.rs b/livekit-api/src/services/egress.rs index 7c2fd08ce..a3b9d954d 100644 --- a/livekit-api/src/services/egress.rs +++ b/livekit-api/src/services/egress.rs @@ -153,6 +153,7 @@ impl EgressClient { image_outputs, output: None, // Deprecated await_start_signal: options.await_start_signal, + ..Default::default() }, self.base .auth_header(VideoGrants { room_record: true, ..Default::default() }, None)?, @@ -184,6 +185,7 @@ impl EgressClient { stream_outputs, segment_outputs, image_outputs, + ..Default::default() }, self.base .auth_header(VideoGrants { room_record: true, ..Default::default() }, None)?, @@ -215,6 +217,7 @@ impl EgressClient { segment_outputs, image_outputs, output: None, // Deprecated + ..Default::default() }, self.base .auth_header(VideoGrants { room_record: true, ..Default::default() }, None)?, @@ -244,6 +247,7 @@ impl EgressClient { } }, track_id: track_id.to_string(), + ..Default::default() }, self.base .auth_header(VideoGrants { room_record: true, ..Default::default() }, None)?, diff --git a/livekit-api/src/services/sip.rs b/livekit-api/src/services/sip.rs index 01e4d431a..6fa7aacf1 100644 --- a/livekit-api/src/services/sip.rs +++ b/livekit-api/src/services/sip.rs @@ -354,9 +354,7 @@ impl SIPClient { hide_phone_number: options.hide_phone_number, rule: Some(proto::SipDispatchRule { rule: Some(rule.to_owned()) }), - // TODO: support these attributes - room_preset: Default::default(), - room_config: Default::default(), + ..Default::default() }, self.base.auth_header( Default::default(), diff --git a/livekit-ffi/protocol/participant.proto b/livekit-ffi/protocol/participant.proto index 3f1e2720c..ea7eb41a1 100644 --- a/livekit-ffi/protocol/participant.proto +++ b/livekit-ffi/protocol/participant.proto @@ -70,4 +70,5 @@ enum DisconnectReason { USER_REJECTED = 12; // SIP protocol failure or unexpected response SIP_TRUNK_FAILURE = 13; + CONNECTION_TIMEOUT = 14; } \ No newline at end of file diff --git a/livekit-ffi/protocol/track.proto b/livekit-ffi/protocol/track.proto index 88a62c236..0e6889e2e 100644 --- a/livekit-ffi/protocol/track.proto +++ b/livekit-ffi/protocol/track.proto @@ -89,6 +89,7 @@ message TrackPublicationInfo { required bool muted = 9; required bool remote = 10; required EncryptionType encryption_type = 11; + repeated AudioTrackFeature audio_features = 12; } message OwnedTrackPublication { @@ -147,3 +148,13 @@ message ParticipantTrackPermission { message SetTrackSubscriptionPermissionsResponse { } + +enum AudioTrackFeature { + TF_STEREO = 0; + TF_NO_DTX = 1; + TF_AUTO_GAIN_CONTROL = 2; + TF_ECHO_CANCELLATION = 3; + TF_NOISE_SUPPRESSION = 4; + TF_ENHANCED_NOISE_CANCELLATION = 5; + TF_PRECONNECT_BUFFER = 6; // client will buffer audio once available and send it to the server via bytes stream once connected +} diff --git a/livekit-ffi/src/conversion/participant.rs b/livekit-ffi/src/conversion/participant.rs index c80453cd9..33cf20dec 100644 --- a/livekit-ffi/src/conversion/participant.rs +++ b/livekit-ffi/src/conversion/participant.rs @@ -61,6 +61,7 @@ impl From for proto::DisconnectReason { DisconnectReason::UserUnavailable => proto::DisconnectReason::UserUnavailable, DisconnectReason::UserRejected => proto::DisconnectReason::UserRejected, DisconnectReason::SipTrunkFailure => proto::DisconnectReason::SipTrunkFailure, + DisconnectReason::ConnectionTimeout => proto::DisconnectReason::ConnectionTimeout, } } } diff --git a/livekit-ffi/src/conversion/room.rs b/livekit-ffi/src/conversion/room.rs index 2662bf3b8..805d7ce2f 100644 --- a/livekit-ffi/src/conversion/room.rs +++ b/livekit-ffi/src/conversion/room.rs @@ -98,6 +98,7 @@ impl From for proto::DisconnectReason { DisconnectReason::UserUnavailable => Self::UserUnavailable, DisconnectReason::UserRejected => Self::UserRejected, DisconnectReason::SipTrunkFailure => Self::SipTrunkFailure, + DisconnectReason::ConnectionTimeout => Self::ConnectionTimeout, } } } diff --git a/livekit-ffi/src/conversion/track.rs b/livekit-ffi/src/conversion/track.rs index 2e1d33f69..82da937dd 100644 --- a/livekit-ffi/src/conversion/track.rs +++ b/livekit-ffi/src/conversion/track.rs @@ -34,6 +34,11 @@ impl From<&FfiPublication> for proto::TrackPublicationInfo { muted: publication.is_muted(), remote: publication.is_remote(), encryption_type: proto::EncryptionType::from(publication.encryption_type()).into(), + audio_features: publication + .audio_features() + .into_iter() + .map(|i| proto::AudioTrackFeature::from(i).into()) + .collect(), } } } @@ -121,3 +126,35 @@ impl From for ParticipantTrackPermission { } } } + +impl From for AudioTrackFeature { + fn from(value: proto::AudioTrackFeature) -> Self { + match value { + proto::AudioTrackFeature::TfStereo => AudioTrackFeature::TfStereo, + proto::AudioTrackFeature::TfNoDtx => AudioTrackFeature::TfNoDtx, + proto::AudioTrackFeature::TfAutoGainControl => AudioTrackFeature::TfAutoGainControl, + proto::AudioTrackFeature::TfEchoCancellation => AudioTrackFeature::TfEchoCancellation, + proto::AudioTrackFeature::TfNoiseSuppression => AudioTrackFeature::TfNoiseSuppression, + proto::AudioTrackFeature::TfEnhancedNoiseCancellation => { + AudioTrackFeature::TfEnhancedNoiseCancellation + } + proto::AudioTrackFeature::TfPreconnectBuffer => AudioTrackFeature::TfPreconnectBuffer, + } + } +} + +impl From for proto::AudioTrackFeature { + fn from(value: AudioTrackFeature) -> Self { + match value { + AudioTrackFeature::TfStereo => proto::AudioTrackFeature::TfStereo, + AudioTrackFeature::TfNoDtx => proto::AudioTrackFeature::TfNoDtx, + AudioTrackFeature::TfAutoGainControl => proto::AudioTrackFeature::TfAutoGainControl, + AudioTrackFeature::TfEchoCancellation => proto::AudioTrackFeature::TfEchoCancellation, + AudioTrackFeature::TfNoiseSuppression => proto::AudioTrackFeature::TfNoiseSuppression, + AudioTrackFeature::TfEnhancedNoiseCancellation => { + proto::AudioTrackFeature::TfEnhancedNoiseCancellation + } + AudioTrackFeature::TfPreconnectBuffer => proto::AudioTrackFeature::TfPreconnectBuffer, + } + } +} diff --git a/livekit-ffi/src/livekit.proto.rs b/livekit-ffi/src/livekit.proto.rs index be0e5c1bc..39a539617 100644 --- a/livekit-ffi/src/livekit.proto.rs +++ b/livekit-ffi/src/livekit.proto.rs @@ -1392,6 +1392,8 @@ pub struct TrackPublicationInfo { pub remote: bool, #[prost(enumeration="EncryptionType", required, tag="11")] pub encryption_type: i32, + #[prost(enumeration="AudioTrackFeature", repeated, packed="false", tag="12")] + pub audio_features: ::prost::alloc::vec::Vec, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -1575,6 +1577,48 @@ impl StreamState { } } } +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum AudioTrackFeature { + TfStereo = 0, + TfNoDtx = 1, + TfAutoGainControl = 2, + TfEchoCancellation = 3, + TfNoiseSuppression = 4, + TfEnhancedNoiseCancellation = 5, + /// client will buffer audio once available and send it to the server via bytes stream once connected + TfPreconnectBuffer = 6, +} +impl AudioTrackFeature { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + AudioTrackFeature::TfStereo => "TF_STEREO", + AudioTrackFeature::TfNoDtx => "TF_NO_DTX", + AudioTrackFeature::TfAutoGainControl => "TF_AUTO_GAIN_CONTROL", + AudioTrackFeature::TfEchoCancellation => "TF_ECHO_CANCELLATION", + AudioTrackFeature::TfNoiseSuppression => "TF_NOISE_SUPPRESSION", + AudioTrackFeature::TfEnhancedNoiseCancellation => "TF_ENHANCED_NOISE_CANCELLATION", + AudioTrackFeature::TfPreconnectBuffer => "TF_PRECONNECT_BUFFER", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TF_STEREO" => Some(Self::TfStereo), + "TF_NO_DTX" => Some(Self::TfNoDtx), + "TF_AUTO_GAIN_CONTROL" => Some(Self::TfAutoGainControl), + "TF_ECHO_CANCELLATION" => Some(Self::TfEchoCancellation), + "TF_NOISE_SUPPRESSION" => Some(Self::TfNoiseSuppression), + "TF_ENHANCED_NOISE_CANCELLATION" => Some(Self::TfEnhancedNoiseCancellation), + "TF_PRECONNECT_BUFFER" => Some(Self::TfPreconnectBuffer), + _ => None, + } + } +} /// Enable/Disable a remote track publication #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -1694,6 +1738,7 @@ pub enum DisconnectReason { UserRejected = 12, /// SIP protocol failure or unexpected response SipTrunkFailure = 13, + ConnectionTimeout = 14, } impl DisconnectReason { /// String value of the enum field names used in the ProtoBuf definition. @@ -1716,6 +1761,7 @@ impl DisconnectReason { DisconnectReason::UserUnavailable => "USER_UNAVAILABLE", DisconnectReason::UserRejected => "USER_REJECTED", DisconnectReason::SipTrunkFailure => "SIP_TRUNK_FAILURE", + DisconnectReason::ConnectionTimeout => "CONNECTION_TIMEOUT", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -1735,6 +1781,7 @@ impl DisconnectReason { "USER_UNAVAILABLE" => Some(Self::UserUnavailable), "USER_REJECTED" => Some(Self::UserRejected), "SIP_TRUNK_FAILURE" => Some(Self::SipTrunkFailure), + "CONNECTION_TIMEOUT" => Some(Self::ConnectionTimeout), _ => None, } } diff --git a/livekit-protocol/protocol b/livekit-protocol/protocol index 7d8d588f7..b047e92f0 160000 --- a/livekit-protocol/protocol +++ b/livekit-protocol/protocol @@ -1 +1 @@ -Subproject commit 7d8d588f7509f169fd6b72817dfecf25c31414e8 +Subproject commit b047e92f055de744e5a5293848830cd803f3217b diff --git a/livekit-protocol/src/livekit.rs b/livekit-protocol/src/livekit.rs index 6097e1704..250ab4345 100644 --- a/livekit-protocol/src/livekit.rs +++ b/livekit-protocol/src/livekit.rs @@ -199,6 +199,14 @@ pub struct Pagination { #[prost(int32, tag="2")] pub limit: i32, } +/// ListUpdate is used for updated APIs where 'repeated string' field is modified. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListUpdate { + /// set the field to a new list + #[prost(string, repeated, tag="1")] + pub set: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Room { @@ -321,6 +329,8 @@ pub struct ParticipantInfo { pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, #[prost(enumeration="DisconnectReason", tag="16")] pub disconnect_reason: i32, + #[prost(enumeration="participant_info::KindDetail", repeated, tag="18")] + pub kind_details: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `ParticipantInfo`. pub mod participant_info { @@ -400,6 +410,32 @@ pub mod participant_info { } } } + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum KindDetail { + CloudAgent = 0, + Forwarded = 1, + } + impl KindDetail { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + KindDetail::CloudAgent => "CLOUD_AGENT", + KindDetail::Forwarded => "FORWARDED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CLOUD_AGENT" => Some(Self::CloudAgent), + "FORWARDED" => Some(Self::Forwarded), + _ => None, + } + } + } } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -855,6 +891,7 @@ pub mod client_info { Cpp = 10, UnityWeb = 11, Node = 12, + Unreal = 13, } impl Sdk { /// String value of the enum field names used in the ProtoBuf definition. @@ -876,6 +913,7 @@ pub mod client_info { Sdk::Cpp => "CPP", Sdk::UnityWeb => "UNITY_WEB", Sdk::Node => "NODE", + Sdk::Unreal => "UNREAL", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -894,6 +932,7 @@ pub mod client_info { "CPP" => Some(Self::Cpp), "UNITY_WEB" => Some(Self::UnityWeb), "NODE" => Some(Self::Node), + "UNREAL" => Some(Self::Unreal), _ => None, } } @@ -1273,6 +1312,14 @@ pub mod data_stream { } } } +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WebhookConfig { + #[prost(string, tag="1")] + pub url: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub signing_key: ::prost::alloc::string::String, +} #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum AudioCodec { @@ -1367,10 +1414,13 @@ impl ImageCodec { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum BackupCodecPolicy { - /// default behavior, regress to backup codec and all subscribers will receive the backup codec - Regression = 0, + /// default behavior, the track prefer to regress to backup codec and all subscribers will receive the backup codec, + /// the sfu will try to regress codec if possible but not assured. + PreferRegression = 0, /// encoding/send the primary and backup codec simultaneously Simulcast = 1, + /// force the track to regress to backup codec, this option can be used in video conference or the publisher has limited bandwidth/encoding power + Regression = 2, } impl BackupCodecPolicy { /// String value of the enum field names used in the ProtoBuf definition. @@ -1379,15 +1429,17 @@ impl BackupCodecPolicy { /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - BackupCodecPolicy::Regression => "REGRESSION", + BackupCodecPolicy::PreferRegression => "PREFER_REGRESSION", BackupCodecPolicy::Simulcast => "SIMULCAST", + BackupCodecPolicy::Regression => "REGRESSION", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { - "REGRESSION" => Some(Self::Regression), + "PREFER_REGRESSION" => Some(Self::PreferRegression), "SIMULCAST" => Some(Self::Simulcast), + "REGRESSION" => Some(Self::Regression), _ => None, } } @@ -1579,6 +1631,8 @@ pub enum DisconnectReason { UserRejected = 12, /// SIP protocol failure or unexpected response SipTrunkFailure = 13, + /// server timed out a participant session + ConnectionTimeout = 14, } impl DisconnectReason { /// String value of the enum field names used in the ProtoBuf definition. @@ -1601,6 +1655,7 @@ impl DisconnectReason { DisconnectReason::UserUnavailable => "USER_UNAVAILABLE", DisconnectReason::UserRejected => "USER_REJECTED", DisconnectReason::SipTrunkFailure => "SIP_TRUNK_FAILURE", + DisconnectReason::ConnectionTimeout => "CONNECTION_TIMEOUT", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -1620,6 +1675,7 @@ impl DisconnectReason { "USER_UNAVAILABLE" => Some(Self::UserUnavailable), "USER_REJECTED" => Some(Self::UserRejected), "SIP_TRUNK_FAILURE" => Some(Self::SipTrunkFailure), + "CONNECTION_TIMEOUT" => Some(Self::ConnectionTimeout), _ => None, } } @@ -1697,6 +1753,8 @@ pub enum AudioTrackFeature { TfEchoCancellation = 3, TfNoiseSuppression = 4, TfEnhancedNoiseCancellation = 5, + /// client will buffer audio once available and send it to the server via bytes stream once connected + TfPreconnectBuffer = 6, } impl AudioTrackFeature { /// String value of the enum field names used in the ProtoBuf definition. @@ -1711,6 +1769,7 @@ impl AudioTrackFeature { AudioTrackFeature::TfEchoCancellation => "TF_ECHO_CANCELLATION", AudioTrackFeature::TfNoiseSuppression => "TF_NOISE_SUPPRESSION", AudioTrackFeature::TfEnhancedNoiseCancellation => "TF_ENHANCED_NOISE_CANCELLATION", + AudioTrackFeature::TfPreconnectBuffer => "TF_PRECONNECT_BUFFER", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -1722,6 +1781,7 @@ impl AudioTrackFeature { "TF_ECHO_CANCELLATION" => Some(Self::TfEchoCancellation), "TF_NOISE_SUPPRESSION" => Some(Self::TfNoiseSuppression), "TF_ENHANCED_NOISE_CANCELLATION" => Some(Self::TfEnhancedNoiseCancellation), + "TF_PRECONNECT_BUFFER" => Some(Self::TfPreconnectBuffer), _ => None, } } @@ -1756,6 +1816,9 @@ pub struct RoomCompositeEgressRequest { pub segment_outputs: ::prost::alloc::vec::Vec, #[prost(message, repeated, tag="14")] pub image_outputs: ::prost::alloc::vec::Vec, + /// extra webhooks to call for this request + #[prost(message, repeated, tag="16")] + pub webhooks: ::prost::alloc::vec::Vec, /// deprecated (use _output fields) #[prost(oneof="room_composite_egress_request::Output", tags="6, 7, 10")] pub output: ::core::option::Option, @@ -1806,6 +1869,9 @@ pub struct WebEgressRequest { pub segment_outputs: ::prost::alloc::vec::Vec, #[prost(message, repeated, tag="13")] pub image_outputs: ::prost::alloc::vec::Vec, + /// extra webhooks to call for this request + #[prost(message, repeated, tag="14")] + pub webhooks: ::prost::alloc::vec::Vec, /// deprecated (use _output fields) #[prost(oneof="web_egress_request::Output", tags="4, 5, 6")] pub output: ::core::option::Option, @@ -1855,6 +1921,9 @@ pub struct ParticipantEgressRequest { pub segment_outputs: ::prost::alloc::vec::Vec, #[prost(message, repeated, tag="9")] pub image_outputs: ::prost::alloc::vec::Vec, + /// extra webhooks to call for this request + #[prost(message, repeated, tag="10")] + pub webhooks: ::prost::alloc::vec::Vec, #[prost(oneof="participant_egress_request::Options", tags="4, 5")] pub options: ::core::option::Option, } @@ -1892,6 +1961,9 @@ pub struct TrackCompositeEgressRequest { pub segment_outputs: ::prost::alloc::vec::Vec, #[prost(message, repeated, tag="14")] pub image_outputs: ::prost::alloc::vec::Vec, + /// extra webhooks to call for this request + #[prost(message, repeated, tag="15")] + pub webhooks: ::prost::alloc::vec::Vec, /// deprecated (use _output fields) #[prost(oneof="track_composite_egress_request::Output", tags="4, 5, 8")] pub output: ::core::option::Option, @@ -1932,6 +2004,9 @@ pub struct TrackEgressRequest { /// required #[prost(string, tag="2")] pub track_id: ::prost::alloc::string::String, + /// extra webhooks to call for this request + #[prost(message, repeated, tag="5")] + pub webhooks: ::prost::alloc::vec::Vec, /// required #[prost(oneof="track_egress_request::Output", tags="3, 4")] pub output: ::core::option::Option, @@ -2572,6 +2647,8 @@ impl SegmentedFileSuffix { pub enum ImageFileSuffix { ImageSuffixIndex = 0, ImageSuffixTimestamp = 1, + /// Do not append any suffix and overwrite the existing image with the latest + ImageSuffixNoneOverwrite = 2, } impl ImageFileSuffix { /// String value of the enum field names used in the ProtoBuf definition. @@ -2582,6 +2659,7 @@ impl ImageFileSuffix { match self { ImageFileSuffix::ImageSuffixIndex => "IMAGE_SUFFIX_INDEX", ImageFileSuffix::ImageSuffixTimestamp => "IMAGE_SUFFIX_TIMESTAMP", + ImageFileSuffix::ImageSuffixNoneOverwrite => "IMAGE_SUFFIX_NONE_OVERWRITE", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -2589,6 +2667,7 @@ impl ImageFileSuffix { match value { "IMAGE_SUFFIX_INDEX" => Some(Self::ImageSuffixIndex), "IMAGE_SUFFIX_TIMESTAMP" => Some(Self::ImageSuffixTimestamp), + "IMAGE_SUFFIX_NONE_OVERWRITE" => Some(Self::ImageSuffixNoneOverwrite), _ => None, } } @@ -2947,6 +3026,9 @@ pub struct AddTrackRequest { #[prost(bool, tag="6")] pub muted: bool, /// true if DTX (Discontinuous Transmission) is disabled for audio + /// + /// deprecated in favor of audio_features + #[deprecated] #[prost(bool, tag="7")] pub disable_dtx: bool, #[prost(enumeration="TrackSource", tag="8")] @@ -2958,6 +3040,8 @@ pub struct AddTrackRequest { /// server ID of track, publish new codec to exist track #[prost(string, tag="11")] pub sid: ::prost::alloc::string::String, + /// deprecated in favor of audio_features + #[deprecated] #[prost(bool, tag="12")] pub stereo: bool, /// true if RED (Redundant Encoding) is disabled for audio @@ -2971,6 +3055,8 @@ pub struct AddTrackRequest { pub stream: ::prost::alloc::string::String, #[prost(enumeration="BackupCodecPolicy", tag="16")] pub backup_codec_policy: i32, + #[prost(enumeration="AudioTrackFeature", repeated, tag="17")] + pub audio_features: ::prost::alloc::vec::Vec, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -4174,6 +4260,23 @@ pub struct RoomConfiguration { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] +pub struct ForwardParticipantRequest { + /// room to forward participant from + #[prost(string, tag="1")] + pub room: ::prost::alloc::string::String, + /// identity of the participant to forward + #[prost(string, tag="2")] + pub identity: ::prost::alloc::string::String, + /// room to forward participant to + #[prost(string, tag="3")] + pub destination_room: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ForwardParticipantResponse { +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateIngressRequest { #[prost(enumeration="IngressInput", tag="1")] pub input_type: i32, @@ -4608,6 +4711,7 @@ pub struct WebhookEvent { /// timestamp in seconds #[prost(int64, tag="7")] pub created_at: i64, + #[deprecated] #[prost(int32, tag="11")] pub num_dropped: i32, } @@ -4744,6 +4848,25 @@ pub struct CreateSipInboundTrunkRequest { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateSipInboundTrunkRequest { + #[prost(string, tag="1")] + pub sip_trunk_id: ::prost::alloc::string::String, + #[prost(oneof="update_sip_inbound_trunk_request::Action", tags="2, 3")] + pub action: ::core::option::Option, +} +/// Nested message and enum types in `UpdateSIPInboundTrunkRequest`. +pub mod update_sip_inbound_trunk_request { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Action { + #[prost(message, tag="2")] + Replace(super::SipInboundTrunkInfo), + #[prost(message, tag="3")] + Update(super::SipInboundTrunkUpdate), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct SipInboundTrunkInfo { #[prost(string, tag="1")] pub sip_trunk_id: ::prost::alloc::string::String, @@ -4802,6 +4925,26 @@ pub struct SipInboundTrunkInfo { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] +pub struct SipInboundTrunkUpdate { + #[prost(message, optional, tag="1")] + pub numbers: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub allowed_addresses: ::core::option::Option, + #[prost(message, optional, tag="3")] + pub allowed_numbers: ::core::option::Option, + #[prost(string, optional, tag="4")] + pub auth_username: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, optional, tag="5")] + pub auth_password: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, optional, tag="6")] + pub name: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, optional, tag="7")] + pub metadata: ::core::option::Option<::prost::alloc::string::String>, + #[prost(enumeration="SipMediaEncryption", optional, tag="8")] + pub media_encryption: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateSipOutboundTrunkRequest { /// Trunk ID is ignored #[prost(message, optional, tag="1")] @@ -4809,6 +4952,25 @@ pub struct CreateSipOutboundTrunkRequest { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateSipOutboundTrunkRequest { + #[prost(string, tag="1")] + pub sip_trunk_id: ::prost::alloc::string::String, + #[prost(oneof="update_sip_outbound_trunk_request::Action", tags="2, 3")] + pub action: ::core::option::Option, +} +/// Nested message and enum types in `UpdateSIPOutboundTrunkRequest`. +pub mod update_sip_outbound_trunk_request { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Action { + #[prost(message, tag="2")] + Replace(super::SipOutboundTrunkInfo), + #[prost(message, tag="3")] + Update(super::SipOutboundTrunkUpdate), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct SipOutboundTrunkInfo { #[prost(string, tag="1")] pub sip_trunk_id: ::prost::alloc::string::String, @@ -4859,6 +5021,26 @@ pub struct SipOutboundTrunkInfo { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] +pub struct SipOutboundTrunkUpdate { + #[prost(string, optional, tag="1")] + pub address: ::core::option::Option<::prost::alloc::string::String>, + #[prost(enumeration="SipTransport", optional, tag="2")] + pub transport: ::core::option::Option, + #[prost(message, optional, tag="3")] + pub numbers: ::core::option::Option, + #[prost(string, optional, tag="4")] + pub auth_username: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, optional, tag="5")] + pub auth_password: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, optional, tag="6")] + pub name: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, optional, tag="7")] + pub metadata: ::core::option::Option<::prost::alloc::string::String>, + #[prost(enumeration="SipMediaEncryption", optional, tag="8")] + pub media_encryption: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct GetSipInboundTrunkRequest { #[prost(string, tag="1")] pub sip_trunk_id: ::prost::alloc::string::String, @@ -4999,24 +5181,33 @@ pub mod sip_dispatch_rule { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateSipDispatchRuleRequest { + /// Rule ID is ignored + #[prost(message, optional, tag="10")] + pub dispatch_rule: ::core::option::Option, + #[deprecated] #[prost(message, optional, tag="1")] pub rule: ::core::option::Option, /// What trunks are accepted for this dispatch rule /// If empty all trunks will match this dispatch rule + #[deprecated] #[prost(string, repeated, tag="2")] pub trunk_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// By default the From value (Phone number) is used for participant name/identity and added to attributes. /// If true, a random value for identity will be used and numbers will be omitted from attributes. + #[deprecated] #[prost(bool, tag="3")] pub hide_phone_number: bool, /// Dispatch Rule will only accept a call made to these numbers (if set). + #[deprecated] #[prost(string, repeated, tag="6")] pub inbound_numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Optional human-readable name for the Dispatch Rule. + #[deprecated] #[prost(string, tag="4")] pub name: ::prost::alloc::string::String, /// User-defined metadata for the Dispatch Rule. /// Participants created by this rule will inherit this metadata. + #[deprecated] #[prost(string, tag="5")] pub metadata: ::prost::alloc::string::String, /// User-defined attributes for the Dispatch Rule. @@ -5024,14 +5215,35 @@ pub struct CreateSipDispatchRuleRequest { #[prost(map="string, string", tag="7")] pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, /// Cloud-only, config preset to use + #[deprecated] #[prost(string, tag="8")] pub room_preset: ::prost::alloc::string::String, /// RoomConfiguration to use if the participant initiates the room + #[deprecated] #[prost(message, optional, tag="9")] pub room_config: ::core::option::Option, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateSipDispatchRuleRequest { + #[prost(string, tag="1")] + pub sip_dispatch_rule_id: ::prost::alloc::string::String, + #[prost(oneof="update_sip_dispatch_rule_request::Action", tags="2, 3")] + pub action: ::core::option::Option, +} +/// Nested message and enum types in `UpdateSIPDispatchRuleRequest`. +pub mod update_sip_dispatch_rule_request { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Action { + #[prost(message, tag="2")] + Replace(super::SipDispatchRuleInfo), + #[prost(message, tag="3")] + Update(super::SipDispatchRuleUpdate), + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct SipDispatchRuleInfo { #[prost(string, tag="1")] pub sip_dispatch_rule_id: ::prost::alloc::string::String, @@ -5067,6 +5279,22 @@ pub struct SipDispatchRuleInfo { #[prost(enumeration="SipMediaEncryption", tag="12")] pub media_encryption: i32, } +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SipDispatchRuleUpdate { + #[prost(message, optional, tag="1")] + pub trunk_ids: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub rule: ::core::option::Option, + #[prost(string, optional, tag="3")] + pub name: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, optional, tag="4")] + pub metadata: ::core::option::Option<::prost::alloc::string::String>, + #[prost(map="string, string", tag="5")] + pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + #[prost(enumeration="SipMediaEncryption", optional, tag="6")] + pub media_encryption: ::core::option::Option, +} /// ListSIPDispatchRuleRequest lists dispatch rules for given filters. If no filters are set, all rules are listed. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -5217,6 +5445,9 @@ pub struct TransferSipParticipantRequest { /// Add the following headers to the REFER SIP request. #[prost(map="string, string", tag="5")] pub headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// Max time for the transfer destination to answer the call. + #[prost(message, optional, tag="6")] + pub ringing_timeout: ::core::option::Option<::pbjson_types::Duration>, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] diff --git a/livekit-protocol/src/livekit.serde.rs b/livekit-protocol/src/livekit.serde.rs index 817bccf24..4cd41062f 100644 --- a/livekit-protocol/src/livekit.serde.rs +++ b/livekit-protocol/src/livekit.serde.rs @@ -150,6 +150,9 @@ impl serde::Serialize for AddTrackRequest { if self.backup_codec_policy != 0 { len += 1; } + if !self.audio_features.is_empty() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("livekit.AddTrackRequest", len)?; if !self.cid.is_empty() { struct_ser.serialize_field("cid", &self.cid)?; @@ -207,6 +210,13 @@ impl serde::Serialize for AddTrackRequest { .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backup_codec_policy)))?; struct_ser.serialize_field("backupCodecPolicy", &v)?; } + if !self.audio_features.is_empty() { + let v = self.audio_features.iter().cloned().map(|v| { + AudioTrackFeature::try_from(v) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v))) + }).collect::, _>>()?; + struct_ser.serialize_field("audioFeatures", &v)?; + } struct_ser.end() } } @@ -237,6 +247,8 @@ impl<'de> serde::Deserialize<'de> for AddTrackRequest { "stream", "backup_codec_policy", "backupCodecPolicy", + "audio_features", + "audioFeatures", ]; #[allow(clippy::enum_variant_names)] @@ -257,6 +269,7 @@ impl<'de> serde::Deserialize<'de> for AddTrackRequest { Encryption, Stream, BackupCodecPolicy, + AudioFeatures, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -295,6 +308,7 @@ impl<'de> serde::Deserialize<'de> for AddTrackRequest { "encryption" => Ok(GeneratedField::Encryption), "stream" => Ok(GeneratedField::Stream), "backupCodecPolicy" | "backup_codec_policy" => Ok(GeneratedField::BackupCodecPolicy), + "audioFeatures" | "audio_features" => Ok(GeneratedField::AudioFeatures), _ => Ok(GeneratedField::__SkipField__), } } @@ -330,6 +344,7 @@ impl<'de> serde::Deserialize<'de> for AddTrackRequest { let mut encryption__ = None; let mut stream__ = None; let mut backup_codec_policy__ = None; + let mut audio_features__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Cid => { @@ -432,6 +447,12 @@ impl<'de> serde::Deserialize<'de> for AddTrackRequest { } backup_codec_policy__ = Some(map_.next_value::()? as i32); } + GeneratedField::AudioFeatures => { + if audio_features__.is_some() { + return Err(serde::de::Error::duplicate_field("audioFeatures")); + } + audio_features__ = Some(map_.next_value::>()?.into_iter().map(|x| x as i32).collect()); + } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -454,6 +475,7 @@ impl<'de> serde::Deserialize<'de> for AddTrackRequest { encryption: encryption__.unwrap_or_default(), stream: stream__.unwrap_or_default(), backup_codec_policy: backup_codec_policy__.unwrap_or_default(), + audio_features: audio_features__.unwrap_or_default(), }) } } @@ -1088,6 +1110,7 @@ impl serde::Serialize for AudioTrackFeature { Self::TfEchoCancellation => "TF_ECHO_CANCELLATION", Self::TfNoiseSuppression => "TF_NOISE_SUPPRESSION", Self::TfEnhancedNoiseCancellation => "TF_ENHANCED_NOISE_CANCELLATION", + Self::TfPreconnectBuffer => "TF_PRECONNECT_BUFFER", }; serializer.serialize_str(variant) } @@ -1105,6 +1128,7 @@ impl<'de> serde::Deserialize<'de> for AudioTrackFeature { "TF_ECHO_CANCELLATION", "TF_NOISE_SUPPRESSION", "TF_ENHANCED_NOISE_CANCELLATION", + "TF_PRECONNECT_BUFFER", ]; struct GeneratedVisitor; @@ -1151,6 +1175,7 @@ impl<'de> serde::Deserialize<'de> for AudioTrackFeature { "TF_ECHO_CANCELLATION" => Ok(AudioTrackFeature::TfEchoCancellation), "TF_NOISE_SUPPRESSION" => Ok(AudioTrackFeature::TfNoiseSuppression), "TF_ENHANCED_NOISE_CANCELLATION" => Ok(AudioTrackFeature::TfEnhancedNoiseCancellation), + "TF_PRECONNECT_BUFFER" => Ok(AudioTrackFeature::TfPreconnectBuffer), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -1938,8 +1963,9 @@ impl serde::Serialize for BackupCodecPolicy { S: serde::Serializer, { let variant = match self { - Self::Regression => "REGRESSION", + Self::PreferRegression => "PREFER_REGRESSION", Self::Simulcast => "SIMULCAST", + Self::Regression => "REGRESSION", }; serializer.serialize_str(variant) } @@ -1951,8 +1977,9 @@ impl<'de> serde::Deserialize<'de> for BackupCodecPolicy { D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "REGRESSION", + "PREFER_REGRESSION", "SIMULCAST", + "REGRESSION", ]; struct GeneratedVisitor; @@ -1993,8 +2020,9 @@ impl<'de> serde::Deserialize<'de> for BackupCodecPolicy { E: serde::de::Error, { match value { - "REGRESSION" => Ok(BackupCodecPolicy::Regression), + "PREFER_REGRESSION" => Ok(BackupCodecPolicy::PreferRegression), "SIMULCAST" => Ok(BackupCodecPolicy::Simulcast), + "REGRESSION" => Ok(BackupCodecPolicy::Regression), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -2802,6 +2830,7 @@ impl serde::Serialize for client_info::Sdk { Self::Cpp => "CPP", Self::UnityWeb => "UNITY_WEB", Self::Node => "NODE", + Self::Unreal => "UNREAL", }; serializer.serialize_str(variant) } @@ -2826,6 +2855,7 @@ impl<'de> serde::Deserialize<'de> for client_info::Sdk { "CPP", "UNITY_WEB", "NODE", + "UNREAL", ]; struct GeneratedVisitor; @@ -2879,6 +2909,7 @@ impl<'de> serde::Deserialize<'de> for client_info::Sdk { "CPP" => Ok(client_info::Sdk::Cpp), "UNITY_WEB" => Ok(client_info::Sdk::UnityWeb), "NODE" => Ok(client_info::Sdk::Node), + "UNREAL" => Ok(client_info::Sdk::Unreal), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -4052,6 +4083,9 @@ impl serde::Serialize for CreateSipDispatchRuleRequest { { use serde::ser::SerializeStruct; let mut len = 0; + if self.dispatch_rule.is_some() { + len += 1; + } if self.rule.is_some() { len += 1; } @@ -4080,6 +4114,9 @@ impl serde::Serialize for CreateSipDispatchRuleRequest { len += 1; } let mut struct_ser = serializer.serialize_struct("livekit.CreateSIPDispatchRuleRequest", len)?; + if let Some(v) = self.dispatch_rule.as_ref() { + struct_ser.serialize_field("dispatchRule", v)?; + } if let Some(v) = self.rule.as_ref() { struct_ser.serialize_field("rule", v)?; } @@ -4117,6 +4154,8 @@ impl<'de> serde::Deserialize<'de> for CreateSipDispatchRuleRequest { D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "dispatch_rule", + "dispatchRule", "rule", "trunk_ids", "trunkIds", @@ -4135,6 +4174,7 @@ impl<'de> serde::Deserialize<'de> for CreateSipDispatchRuleRequest { #[allow(clippy::enum_variant_names)] enum GeneratedField { + DispatchRule, Rule, TrunkIds, HidePhoneNumber, @@ -4166,6 +4206,7 @@ impl<'de> serde::Deserialize<'de> for CreateSipDispatchRuleRequest { E: serde::de::Error, { match value { + "dispatchRule" | "dispatch_rule" => Ok(GeneratedField::DispatchRule), "rule" => Ok(GeneratedField::Rule), "trunkIds" | "trunk_ids" => Ok(GeneratedField::TrunkIds), "hidePhoneNumber" | "hide_phone_number" => Ok(GeneratedField::HidePhoneNumber), @@ -4194,6 +4235,7 @@ impl<'de> serde::Deserialize<'de> for CreateSipDispatchRuleRequest { where V: serde::de::MapAccess<'de>, { + let mut dispatch_rule__ = None; let mut rule__ = None; let mut trunk_ids__ = None; let mut hide_phone_number__ = None; @@ -4205,6 +4247,12 @@ impl<'de> serde::Deserialize<'de> for CreateSipDispatchRuleRequest { let mut room_config__ = None; while let Some(k) = map_.next_key()? { match k { + GeneratedField::DispatchRule => { + if dispatch_rule__.is_some() { + return Err(serde::de::Error::duplicate_field("dispatchRule")); + } + dispatch_rule__ = map_.next_value()?; + } GeneratedField::Rule => { if rule__.is_some() { return Err(serde::de::Error::duplicate_field("rule")); @@ -4267,6 +4315,7 @@ impl<'de> serde::Deserialize<'de> for CreateSipDispatchRuleRequest { } } Ok(CreateSipDispatchRuleRequest { + dispatch_rule: dispatch_rule__, rule: rule__, trunk_ids: trunk_ids__.unwrap_or_default(), hide_phone_number: hide_phone_number__.unwrap_or_default(), @@ -7549,6 +7598,7 @@ impl serde::Serialize for DisconnectReason { Self::UserUnavailable => "USER_UNAVAILABLE", Self::UserRejected => "USER_REJECTED", Self::SipTrunkFailure => "SIP_TRUNK_FAILURE", + Self::ConnectionTimeout => "CONNECTION_TIMEOUT", }; serializer.serialize_str(variant) } @@ -7574,6 +7624,7 @@ impl<'de> serde::Deserialize<'de> for DisconnectReason { "USER_UNAVAILABLE", "USER_REJECTED", "SIP_TRUNK_FAILURE", + "CONNECTION_TIMEOUT", ]; struct GeneratedVisitor; @@ -7628,6 +7679,7 @@ impl<'de> serde::Deserialize<'de> for DisconnectReason { "USER_UNAVAILABLE" => Ok(DisconnectReason::UserUnavailable), "USER_REJECTED" => Ok(DisconnectReason::UserRejected), "SIP_TRUNK_FAILURE" => Ok(DisconnectReason::SipTrunkFailure), + "CONNECTION_TIMEOUT" => Ok(DisconnectReason::ConnectionTimeout), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -9583,7 +9635,7 @@ impl<'de> serde::Deserialize<'de> for FileInfo { deserializer.deserialize_struct("livekit.FileInfo", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GcpUpload { +impl serde::Serialize for ForwardParticipantRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9591,45 +9643,46 @@ impl serde::Serialize for GcpUpload { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.credentials.is_empty() { + if !self.room.is_empty() { len += 1; } - if !self.bucket.is_empty() { + if !self.identity.is_empty() { len += 1; } - if self.proxy.is_some() { + if !self.destination_room.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.GCPUpload", len)?; - if !self.credentials.is_empty() { - struct_ser.serialize_field("credentials", &self.credentials)?; + let mut struct_ser = serializer.serialize_struct("livekit.ForwardParticipantRequest", len)?; + if !self.room.is_empty() { + struct_ser.serialize_field("room", &self.room)?; } - if !self.bucket.is_empty() { - struct_ser.serialize_field("bucket", &self.bucket)?; + if !self.identity.is_empty() { + struct_ser.serialize_field("identity", &self.identity)?; } - if let Some(v) = self.proxy.as_ref() { - struct_ser.serialize_field("proxy", v)?; + if !self.destination_room.is_empty() { + struct_ser.serialize_field("destinationRoom", &self.destination_room)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GcpUpload { +impl<'de> serde::Deserialize<'de> for ForwardParticipantRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "credentials", - "bucket", - "proxy", + "room", + "identity", + "destination_room", + "destinationRoom", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Credentials, - Bucket, - Proxy, + Room, + Identity, + DestinationRoom, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -9652,9 +9705,9 @@ impl<'de> serde::Deserialize<'de> for GcpUpload { E: serde::de::Error, { match value { - "credentials" => Ok(GeneratedField::Credentials), - "bucket" => Ok(GeneratedField::Bucket), - "proxy" => Ok(GeneratedField::Proxy), + "room" => Ok(GeneratedField::Room), + "identity" => Ok(GeneratedField::Identity), + "destinationRoom" | "destination_room" => Ok(GeneratedField::DestinationRoom), _ => Ok(GeneratedField::__SkipField__), } } @@ -9664,55 +9717,127 @@ impl<'de> serde::Deserialize<'de> for GcpUpload { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GcpUpload; + type Value = ForwardParticipantRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.GCPUpload") + formatter.write_str("struct livekit.ForwardParticipantRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut credentials__ = None; - let mut bucket__ = None; - let mut proxy__ = None; + let mut room__ = None; + let mut identity__ = None; + let mut destination_room__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Credentials => { - if credentials__.is_some() { - return Err(serde::de::Error::duplicate_field("credentials")); + GeneratedField::Room => { + if room__.is_some() { + return Err(serde::de::Error::duplicate_field("room")); } - credentials__ = Some(map_.next_value()?); + room__ = Some(map_.next_value()?); } - GeneratedField::Bucket => { - if bucket__.is_some() { - return Err(serde::de::Error::duplicate_field("bucket")); + GeneratedField::Identity => { + if identity__.is_some() { + return Err(serde::de::Error::duplicate_field("identity")); } - bucket__ = Some(map_.next_value()?); + identity__ = Some(map_.next_value()?); } - GeneratedField::Proxy => { - if proxy__.is_some() { - return Err(serde::de::Error::duplicate_field("proxy")); + GeneratedField::DestinationRoom => { + if destination_room__.is_some() { + return Err(serde::de::Error::duplicate_field("destinationRoom")); } - proxy__ = map_.next_value()?; + destination_room__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(GcpUpload { - credentials: credentials__.unwrap_or_default(), - bucket: bucket__.unwrap_or_default(), - proxy: proxy__, + Ok(ForwardParticipantRequest { + room: room__.unwrap_or_default(), + identity: identity__.unwrap_or_default(), + destination_room: destination_room__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.GCPUpload", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.ForwardParticipantRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetSipInboundTrunkRequest { +impl serde::Serialize for ForwardParticipantResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.ForwardParticipantResponse", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ForwardParticipantResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Ok(GeneratedField::__SkipField__) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ForwardParticipantResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.ForwardParticipantResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(ForwardParticipantResponse { + }) + } + } + deserializer.deserialize_struct("livekit.ForwardParticipantResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for GcpUpload { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9720,30 +9845,45 @@ impl serde::Serialize for GetSipInboundTrunkRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.sip_trunk_id.is_empty() { + if !self.credentials.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.GetSIPInboundTrunkRequest", len)?; - if !self.sip_trunk_id.is_empty() { - struct_ser.serialize_field("sipTrunkId", &self.sip_trunk_id)?; + if !self.bucket.is_empty() { + len += 1; + } + if self.proxy.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.GCPUpload", len)?; + if !self.credentials.is_empty() { + struct_ser.serialize_field("credentials", &self.credentials)?; + } + if !self.bucket.is_empty() { + struct_ser.serialize_field("bucket", &self.bucket)?; + } + if let Some(v) = self.proxy.as_ref() { + struct_ser.serialize_field("proxy", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetSipInboundTrunkRequest { +impl<'de> serde::Deserialize<'de> for GcpUpload { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "sip_trunk_id", - "sipTrunkId", + "credentials", + "bucket", + "proxy", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - SipTrunkId, + Credentials, + Bucket, + Proxy, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -9766,7 +9906,9 @@ impl<'de> serde::Deserialize<'de> for GetSipInboundTrunkRequest { E: serde::de::Error, { match value { - "sipTrunkId" | "sip_trunk_id" => Ok(GeneratedField::SipTrunkId), + "credentials" => Ok(GeneratedField::Credentials), + "bucket" => Ok(GeneratedField::Bucket), + "proxy" => Ok(GeneratedField::Proxy), _ => Ok(GeneratedField::__SkipField__), } } @@ -9776,39 +9918,55 @@ impl<'de> serde::Deserialize<'de> for GetSipInboundTrunkRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetSipInboundTrunkRequest; + type Value = GcpUpload; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.GetSIPInboundTrunkRequest") + formatter.write_str("struct livekit.GCPUpload") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut sip_trunk_id__ = None; + let mut credentials__ = None; + let mut bucket__ = None; + let mut proxy__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::SipTrunkId => { - if sip_trunk_id__.is_some() { - return Err(serde::de::Error::duplicate_field("sipTrunkId")); + GeneratedField::Credentials => { + if credentials__.is_some() { + return Err(serde::de::Error::duplicate_field("credentials")); } - sip_trunk_id__ = Some(map_.next_value()?); + credentials__ = Some(map_.next_value()?); + } + GeneratedField::Bucket => { + if bucket__.is_some() { + return Err(serde::de::Error::duplicate_field("bucket")); + } + bucket__ = Some(map_.next_value()?); + } + GeneratedField::Proxy => { + if proxy__.is_some() { + return Err(serde::de::Error::duplicate_field("proxy")); + } + proxy__ = map_.next_value()?; } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(GetSipInboundTrunkRequest { - sip_trunk_id: sip_trunk_id__.unwrap_or_default(), + Ok(GcpUpload { + credentials: credentials__.unwrap_or_default(), + bucket: bucket__.unwrap_or_default(), + proxy: proxy__, }) } } - deserializer.deserialize_struct("livekit.GetSIPInboundTrunkRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.GCPUpload", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetSipInboundTrunkResponse { +impl serde::Serialize for GetSipInboundTrunkRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9816,29 +9974,125 @@ impl serde::Serialize for GetSipInboundTrunkResponse { { use serde::ser::SerializeStruct; let mut len = 0; - if self.trunk.is_some() { + if !self.sip_trunk_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.GetSIPInboundTrunkResponse", len)?; - if let Some(v) = self.trunk.as_ref() { - struct_ser.serialize_field("trunk", v)?; + let mut struct_ser = serializer.serialize_struct("livekit.GetSIPInboundTrunkRequest", len)?; + if !self.sip_trunk_id.is_empty() { + struct_ser.serialize_field("sipTrunkId", &self.sip_trunk_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetSipInboundTrunkResponse { +impl<'de> serde::Deserialize<'de> for GetSipInboundTrunkRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "trunk", + "sip_trunk_id", + "sipTrunkId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Trunk, + SipTrunkId, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sipTrunkId" | "sip_trunk_id" => Ok(GeneratedField::SipTrunkId), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GetSipInboundTrunkRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.GetSIPInboundTrunkRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sip_trunk_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::SipTrunkId => { + if sip_trunk_id__.is_some() { + return Err(serde::de::Error::duplicate_field("sipTrunkId")); + } + sip_trunk_id__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(GetSipInboundTrunkRequest { + sip_trunk_id: sip_trunk_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.GetSIPInboundTrunkRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for GetSipInboundTrunkResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.trunk.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.GetSIPInboundTrunkResponse", len)?; + if let Some(v) = self.trunk.as_ref() { + struct_ser.serialize_field("trunk", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for GetSipInboundTrunkResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "trunk", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Trunk, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -10303,6 +10557,7 @@ impl serde::Serialize for ImageFileSuffix { let variant = match self { Self::ImageSuffixIndex => "IMAGE_SUFFIX_INDEX", Self::ImageSuffixTimestamp => "IMAGE_SUFFIX_TIMESTAMP", + Self::ImageSuffixNoneOverwrite => "IMAGE_SUFFIX_NONE_OVERWRITE", }; serializer.serialize_str(variant) } @@ -10316,6 +10571,7 @@ impl<'de> serde::Deserialize<'de> for ImageFileSuffix { const FIELDS: &[&str] = &[ "IMAGE_SUFFIX_INDEX", "IMAGE_SUFFIX_TIMESTAMP", + "IMAGE_SUFFIX_NONE_OVERWRITE", ]; struct GeneratedVisitor; @@ -10358,6 +10614,7 @@ impl<'de> serde::Deserialize<'de> for ImageFileSuffix { match value { "IMAGE_SUFFIX_INDEX" => Ok(ImageFileSuffix::ImageSuffixIndex), "IMAGE_SUFFIX_TIMESTAMP" => Ok(ImageFileSuffix::ImageSuffixTimestamp), + "IMAGE_SUFFIX_NONE_OVERWRITE" => Ok(ImageFileSuffix::ImageSuffixNoneOverwrite), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -15943,6 +16200,101 @@ impl<'de> serde::Deserialize<'de> for ListSipTrunkResponse { deserializer.deserialize_struct("livekit.ListSIPTrunkResponse", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for ListUpdate { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.set.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.ListUpdate", len)?; + if !self.set.is_empty() { + struct_ser.serialize_field("set", &self.set)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ListUpdate { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "set", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Set, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "set" => Ok(GeneratedField::Set), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ListUpdate; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.ListUpdate") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut set__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Set => { + if set__.is_some() { + return Err(serde::de::Error::duplicate_field("set")); + } + set__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(ListUpdate { + set: set__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.ListUpdate", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for MetricLabel { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -16973,6 +17325,9 @@ impl serde::Serialize for ParticipantEgressRequest { if !self.image_outputs.is_empty() { len += 1; } + if !self.webhooks.is_empty() { + len += 1; + } if self.options.is_some() { len += 1; } @@ -16998,6 +17353,9 @@ impl serde::Serialize for ParticipantEgressRequest { if !self.image_outputs.is_empty() { struct_ser.serialize_field("imageOutputs", &self.image_outputs)?; } + if !self.webhooks.is_empty() { + struct_ser.serialize_field("webhooks", &self.webhooks)?; + } if let Some(v) = self.options.as_ref() { match v { participant_egress_request::Options::Preset(v) => { @@ -17033,6 +17391,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantEgressRequest { "segmentOutputs", "image_outputs", "imageOutputs", + "webhooks", "preset", "advanced", ]; @@ -17046,6 +17405,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantEgressRequest { StreamOutputs, SegmentOutputs, ImageOutputs, + Webhooks, Preset, Advanced, __SkipField__, @@ -17077,6 +17437,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantEgressRequest { "streamOutputs" | "stream_outputs" => Ok(GeneratedField::StreamOutputs), "segmentOutputs" | "segment_outputs" => Ok(GeneratedField::SegmentOutputs), "imageOutputs" | "image_outputs" => Ok(GeneratedField::ImageOutputs), + "webhooks" => Ok(GeneratedField::Webhooks), "preset" => Ok(GeneratedField::Preset), "advanced" => Ok(GeneratedField::Advanced), _ => Ok(GeneratedField::__SkipField__), @@ -17105,6 +17466,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantEgressRequest { let mut stream_outputs__ = None; let mut segment_outputs__ = None; let mut image_outputs__ = None; + let mut webhooks__ = None; let mut options__ = None; while let Some(k) = map_.next_key()? { match k { @@ -17150,6 +17512,12 @@ impl<'de> serde::Deserialize<'de> for ParticipantEgressRequest { } image_outputs__ = Some(map_.next_value()?); } + GeneratedField::Webhooks => { + if webhooks__.is_some() { + return Err(serde::de::Error::duplicate_field("webhooks")); + } + webhooks__ = Some(map_.next_value()?); + } GeneratedField::Preset => { if options__.is_some() { return Err(serde::de::Error::duplicate_field("preset")); @@ -17176,6 +17544,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantEgressRequest { stream_outputs: stream_outputs__.unwrap_or_default(), segment_outputs: segment_outputs__.unwrap_or_default(), image_outputs: image_outputs__.unwrap_or_default(), + webhooks: webhooks__.unwrap_or_default(), options: options__, }) } @@ -17236,6 +17605,9 @@ impl serde::Serialize for ParticipantInfo { if self.disconnect_reason != 0 { len += 1; } + if !self.kind_details.is_empty() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("livekit.ParticipantInfo", len)?; if !self.sid.is_empty() { struct_ser.serialize_field("sid", &self.sid)?; @@ -17292,6 +17664,13 @@ impl serde::Serialize for ParticipantInfo { .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.disconnect_reason)))?; struct_ser.serialize_field("disconnectReason", &v)?; } + if !self.kind_details.is_empty() { + let v = self.kind_details.iter().cloned().map(|v| { + participant_info::KindDetail::try_from(v) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v))) + }).collect::, _>>()?; + struct_ser.serialize_field("kindDetails", &v)?; + } struct_ser.end() } } @@ -17321,6 +17700,8 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { "attributes", "disconnect_reason", "disconnectReason", + "kind_details", + "kindDetails", ]; #[allow(clippy::enum_variant_names)] @@ -17340,6 +17721,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { Kind, Attributes, DisconnectReason, + KindDetails, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -17377,6 +17759,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { "kind" => Ok(GeneratedField::Kind), "attributes" => Ok(GeneratedField::Attributes), "disconnectReason" | "disconnect_reason" => Ok(GeneratedField::DisconnectReason), + "kindDetails" | "kind_details" => Ok(GeneratedField::KindDetails), _ => Ok(GeneratedField::__SkipField__), } } @@ -17411,6 +17794,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { let mut kind__ = None; let mut attributes__ = None; let mut disconnect_reason__ = None; + let mut kind_details__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Sid => { @@ -17511,6 +17895,12 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { } disconnect_reason__ = Some(map_.next_value::()? as i32); } + GeneratedField::KindDetails => { + if kind_details__.is_some() { + return Err(serde::de::Error::duplicate_field("kindDetails")); + } + kind_details__ = Some(map_.next_value::>()?.into_iter().map(|x| x as i32).collect()); + } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -17532,6 +17922,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { kind: kind__.unwrap_or_default(), attributes: attributes__.unwrap_or_default(), disconnect_reason: disconnect_reason__.unwrap_or_default(), + kind_details: kind_details__.unwrap_or_default(), }) } } @@ -17618,6 +18009,77 @@ impl<'de> serde::Deserialize<'de> for participant_info::Kind { deserializer.deserialize_any(GeneratedVisitor) } } +impl serde::Serialize for participant_info::KindDetail { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::CloudAgent => "CLOUD_AGENT", + Self::Forwarded => "FORWARDED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for participant_info::KindDetail { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "CLOUD_AGENT", + "FORWARDED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = participant_info::KindDetail; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "CLOUD_AGENT" => Ok(participant_info::KindDetail::CloudAgent), + "FORWARDED" => Ok(participant_info::KindDetail::Forwarded), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} impl serde::Serialize for participant_info::State { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -22135,6 +22597,9 @@ impl serde::Serialize for RoomCompositeEgressRequest { if !self.image_outputs.is_empty() { len += 1; } + if !self.webhooks.is_empty() { + len += 1; + } if self.output.is_some() { len += 1; } @@ -22174,6 +22639,9 @@ impl serde::Serialize for RoomCompositeEgressRequest { if !self.image_outputs.is_empty() { struct_ser.serialize_field("imageOutputs", &self.image_outputs)?; } + if !self.webhooks.is_empty() { + struct_ser.serialize_field("webhooks", &self.webhooks)?; + } if let Some(v) = self.output.as_ref() { match v { room_composite_egress_request::Output::File(v) => { @@ -22228,6 +22696,7 @@ impl<'de> serde::Deserialize<'de> for RoomCompositeEgressRequest { "segmentOutputs", "image_outputs", "imageOutputs", + "webhooks", "file", "stream", "segments", @@ -22247,6 +22716,7 @@ impl<'de> serde::Deserialize<'de> for RoomCompositeEgressRequest { StreamOutputs, SegmentOutputs, ImageOutputs, + Webhooks, File, Stream, Segments, @@ -22284,6 +22754,7 @@ impl<'de> serde::Deserialize<'de> for RoomCompositeEgressRequest { "streamOutputs" | "stream_outputs" => Ok(GeneratedField::StreamOutputs), "segmentOutputs" | "segment_outputs" => Ok(GeneratedField::SegmentOutputs), "imageOutputs" | "image_outputs" => Ok(GeneratedField::ImageOutputs), + "webhooks" => Ok(GeneratedField::Webhooks), "file" => Ok(GeneratedField::File), "stream" => Ok(GeneratedField::Stream), "segments" => Ok(GeneratedField::Segments), @@ -22318,6 +22789,7 @@ impl<'de> serde::Deserialize<'de> for RoomCompositeEgressRequest { let mut stream_outputs__ = None; let mut segment_outputs__ = None; let mut image_outputs__ = None; + let mut webhooks__ = None; let mut output__ = None; let mut options__ = None; while let Some(k) = map_.next_key()? { @@ -22382,6 +22854,12 @@ impl<'de> serde::Deserialize<'de> for RoomCompositeEgressRequest { } image_outputs__ = Some(map_.next_value()?); } + GeneratedField::Webhooks => { + if webhooks__.is_some() { + return Err(serde::de::Error::duplicate_field("webhooks")); + } + webhooks__ = Some(map_.next_value()?); + } GeneratedField::File => { if output__.is_some() { return Err(serde::de::Error::duplicate_field("file")); @@ -22432,6 +22910,7 @@ impl<'de> serde::Deserialize<'de> for RoomCompositeEgressRequest { stream_outputs: stream_outputs__.unwrap_or_default(), segment_outputs: segment_outputs__.unwrap_or_default(), image_outputs: image_outputs__.unwrap_or_default(), + webhooks: webhooks__.unwrap_or_default(), output: output__, options: options__, }) @@ -25296,6 +25775,192 @@ impl<'de> serde::Deserialize<'de> for SipDispatchRuleInfo { deserializer.deserialize_struct("livekit.SIPDispatchRuleInfo", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for SipDispatchRuleUpdate { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.trunk_ids.is_some() { + len += 1; + } + if self.rule.is_some() { + len += 1; + } + if self.name.is_some() { + len += 1; + } + if self.metadata.is_some() { + len += 1; + } + if !self.attributes.is_empty() { + len += 1; + } + if self.media_encryption.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.SIPDispatchRuleUpdate", len)?; + if let Some(v) = self.trunk_ids.as_ref() { + struct_ser.serialize_field("trunkIds", v)?; + } + if let Some(v) = self.rule.as_ref() { + struct_ser.serialize_field("rule", v)?; + } + if let Some(v) = self.name.as_ref() { + struct_ser.serialize_field("name", v)?; + } + if let Some(v) = self.metadata.as_ref() { + struct_ser.serialize_field("metadata", v)?; + } + if !self.attributes.is_empty() { + struct_ser.serialize_field("attributes", &self.attributes)?; + } + if let Some(v) = self.media_encryption.as_ref() { + let v = SipMediaEncryption::try_from(*v) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("mediaEncryption", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SipDispatchRuleUpdate { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "trunk_ids", + "trunkIds", + "rule", + "name", + "metadata", + "attributes", + "media_encryption", + "mediaEncryption", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TrunkIds, + Rule, + Name, + Metadata, + Attributes, + MediaEncryption, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "trunkIds" | "trunk_ids" => Ok(GeneratedField::TrunkIds), + "rule" => Ok(GeneratedField::Rule), + "name" => Ok(GeneratedField::Name), + "metadata" => Ok(GeneratedField::Metadata), + "attributes" => Ok(GeneratedField::Attributes), + "mediaEncryption" | "media_encryption" => Ok(GeneratedField::MediaEncryption), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SipDispatchRuleUpdate; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.SIPDispatchRuleUpdate") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut trunk_ids__ = None; + let mut rule__ = None; + let mut name__ = None; + let mut metadata__ = None; + let mut attributes__ = None; + let mut media_encryption__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::TrunkIds => { + if trunk_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("trunkIds")); + } + trunk_ids__ = map_.next_value()?; + } + GeneratedField::Rule => { + if rule__.is_some() { + return Err(serde::de::Error::duplicate_field("rule")); + } + rule__ = map_.next_value()?; + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = map_.next_value()?; + } + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); + } + metadata__ = map_.next_value()?; + } + GeneratedField::Attributes => { + if attributes__.is_some() { + return Err(serde::de::Error::duplicate_field("attributes")); + } + attributes__ = Some( + map_.next_value::>()? + ); + } + GeneratedField::MediaEncryption => { + if media_encryption__.is_some() { + return Err(serde::de::Error::duplicate_field("mediaEncryption")); + } + media_encryption__ = map_.next_value::<::std::option::Option>()?.map(|x| x as i32); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(SipDispatchRuleUpdate { + trunk_ids: trunk_ids__, + rule: rule__, + name: name__, + metadata: metadata__, + attributes: attributes__.unwrap_or_default(), + media_encryption: media_encryption__, + }) + } + } + deserializer.deserialize_struct("livekit.SIPDispatchRuleUpdate", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for SipFeature { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -25813,6 +26478,227 @@ impl<'de> serde::Deserialize<'de> for SipInboundTrunkInfo { deserializer.deserialize_struct("livekit.SIPInboundTrunkInfo", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for SipInboundTrunkUpdate { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.numbers.is_some() { + len += 1; + } + if self.allowed_addresses.is_some() { + len += 1; + } + if self.allowed_numbers.is_some() { + len += 1; + } + if self.auth_username.is_some() { + len += 1; + } + if self.auth_password.is_some() { + len += 1; + } + if self.name.is_some() { + len += 1; + } + if self.metadata.is_some() { + len += 1; + } + if self.media_encryption.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.SIPInboundTrunkUpdate", len)?; + if let Some(v) = self.numbers.as_ref() { + struct_ser.serialize_field("numbers", v)?; + } + if let Some(v) = self.allowed_addresses.as_ref() { + struct_ser.serialize_field("allowedAddresses", v)?; + } + if let Some(v) = self.allowed_numbers.as_ref() { + struct_ser.serialize_field("allowedNumbers", v)?; + } + if let Some(v) = self.auth_username.as_ref() { + struct_ser.serialize_field("authUsername", v)?; + } + if let Some(v) = self.auth_password.as_ref() { + struct_ser.serialize_field("authPassword", v)?; + } + if let Some(v) = self.name.as_ref() { + struct_ser.serialize_field("name", v)?; + } + if let Some(v) = self.metadata.as_ref() { + struct_ser.serialize_field("metadata", v)?; + } + if let Some(v) = self.media_encryption.as_ref() { + let v = SipMediaEncryption::try_from(*v) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("mediaEncryption", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SipInboundTrunkUpdate { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "numbers", + "allowed_addresses", + "allowedAddresses", + "allowed_numbers", + "allowedNumbers", + "auth_username", + "authUsername", + "auth_password", + "authPassword", + "name", + "metadata", + "media_encryption", + "mediaEncryption", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Numbers, + AllowedAddresses, + AllowedNumbers, + AuthUsername, + AuthPassword, + Name, + Metadata, + MediaEncryption, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "numbers" => Ok(GeneratedField::Numbers), + "allowedAddresses" | "allowed_addresses" => Ok(GeneratedField::AllowedAddresses), + "allowedNumbers" | "allowed_numbers" => Ok(GeneratedField::AllowedNumbers), + "authUsername" | "auth_username" => Ok(GeneratedField::AuthUsername), + "authPassword" | "auth_password" => Ok(GeneratedField::AuthPassword), + "name" => Ok(GeneratedField::Name), + "metadata" => Ok(GeneratedField::Metadata), + "mediaEncryption" | "media_encryption" => Ok(GeneratedField::MediaEncryption), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SipInboundTrunkUpdate; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.SIPInboundTrunkUpdate") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut numbers__ = None; + let mut allowed_addresses__ = None; + let mut allowed_numbers__ = None; + let mut auth_username__ = None; + let mut auth_password__ = None; + let mut name__ = None; + let mut metadata__ = None; + let mut media_encryption__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Numbers => { + if numbers__.is_some() { + return Err(serde::de::Error::duplicate_field("numbers")); + } + numbers__ = map_.next_value()?; + } + GeneratedField::AllowedAddresses => { + if allowed_addresses__.is_some() { + return Err(serde::de::Error::duplicate_field("allowedAddresses")); + } + allowed_addresses__ = map_.next_value()?; + } + GeneratedField::AllowedNumbers => { + if allowed_numbers__.is_some() { + return Err(serde::de::Error::duplicate_field("allowedNumbers")); + } + allowed_numbers__ = map_.next_value()?; + } + GeneratedField::AuthUsername => { + if auth_username__.is_some() { + return Err(serde::de::Error::duplicate_field("authUsername")); + } + auth_username__ = map_.next_value()?; + } + GeneratedField::AuthPassword => { + if auth_password__.is_some() { + return Err(serde::de::Error::duplicate_field("authPassword")); + } + auth_password__ = map_.next_value()?; + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = map_.next_value()?; + } + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); + } + metadata__ = map_.next_value()?; + } + GeneratedField::MediaEncryption => { + if media_encryption__.is_some() { + return Err(serde::de::Error::duplicate_field("mediaEncryption")); + } + media_encryption__ = map_.next_value::<::std::option::Option>()?.map(|x| x as i32); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(SipInboundTrunkUpdate { + numbers: numbers__, + allowed_addresses: allowed_addresses__, + allowed_numbers: allowed_numbers__, + auth_username: auth_username__, + auth_password: auth_password__, + name: name__, + metadata: metadata__, + media_encryption: media_encryption__, + }) + } + } + deserializer.deserialize_struct("livekit.SIPInboundTrunkUpdate", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for SipMediaEncryption { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -26395,6 +27281,227 @@ impl<'de> serde::Deserialize<'de> for SipOutboundTrunkInfo { deserializer.deserialize_struct("livekit.SIPOutboundTrunkInfo", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for SipOutboundTrunkUpdate { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.address.is_some() { + len += 1; + } + if self.transport.is_some() { + len += 1; + } + if self.numbers.is_some() { + len += 1; + } + if self.auth_username.is_some() { + len += 1; + } + if self.auth_password.is_some() { + len += 1; + } + if self.name.is_some() { + len += 1; + } + if self.metadata.is_some() { + len += 1; + } + if self.media_encryption.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.SIPOutboundTrunkUpdate", len)?; + if let Some(v) = self.address.as_ref() { + struct_ser.serialize_field("address", v)?; + } + if let Some(v) = self.transport.as_ref() { + let v = SipTransport::try_from(*v) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("transport", &v)?; + } + if let Some(v) = self.numbers.as_ref() { + struct_ser.serialize_field("numbers", v)?; + } + if let Some(v) = self.auth_username.as_ref() { + struct_ser.serialize_field("authUsername", v)?; + } + if let Some(v) = self.auth_password.as_ref() { + struct_ser.serialize_field("authPassword", v)?; + } + if let Some(v) = self.name.as_ref() { + struct_ser.serialize_field("name", v)?; + } + if let Some(v) = self.metadata.as_ref() { + struct_ser.serialize_field("metadata", v)?; + } + if let Some(v) = self.media_encryption.as_ref() { + let v = SipMediaEncryption::try_from(*v) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("mediaEncryption", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SipOutboundTrunkUpdate { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "address", + "transport", + "numbers", + "auth_username", + "authUsername", + "auth_password", + "authPassword", + "name", + "metadata", + "media_encryption", + "mediaEncryption", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Address, + Transport, + Numbers, + AuthUsername, + AuthPassword, + Name, + Metadata, + MediaEncryption, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "address" => Ok(GeneratedField::Address), + "transport" => Ok(GeneratedField::Transport), + "numbers" => Ok(GeneratedField::Numbers), + "authUsername" | "auth_username" => Ok(GeneratedField::AuthUsername), + "authPassword" | "auth_password" => Ok(GeneratedField::AuthPassword), + "name" => Ok(GeneratedField::Name), + "metadata" => Ok(GeneratedField::Metadata), + "mediaEncryption" | "media_encryption" => Ok(GeneratedField::MediaEncryption), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SipOutboundTrunkUpdate; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.SIPOutboundTrunkUpdate") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut address__ = None; + let mut transport__ = None; + let mut numbers__ = None; + let mut auth_username__ = None; + let mut auth_password__ = None; + let mut name__ = None; + let mut metadata__ = None; + let mut media_encryption__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Address => { + if address__.is_some() { + return Err(serde::de::Error::duplicate_field("address")); + } + address__ = map_.next_value()?; + } + GeneratedField::Transport => { + if transport__.is_some() { + return Err(serde::de::Error::duplicate_field("transport")); + } + transport__ = map_.next_value::<::std::option::Option>()?.map(|x| x as i32); + } + GeneratedField::Numbers => { + if numbers__.is_some() { + return Err(serde::de::Error::duplicate_field("numbers")); + } + numbers__ = map_.next_value()?; + } + GeneratedField::AuthUsername => { + if auth_username__.is_some() { + return Err(serde::de::Error::duplicate_field("authUsername")); + } + auth_username__ = map_.next_value()?; + } + GeneratedField::AuthPassword => { + if auth_password__.is_some() { + return Err(serde::de::Error::duplicate_field("authPassword")); + } + auth_password__ = map_.next_value()?; + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = map_.next_value()?; + } + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); + } + metadata__ = map_.next_value()?; + } + GeneratedField::MediaEncryption => { + if media_encryption__.is_some() { + return Err(serde::de::Error::duplicate_field("mediaEncryption")); + } + media_encryption__ = map_.next_value::<::std::option::Option>()?.map(|x| x as i32); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(SipOutboundTrunkUpdate { + address: address__, + transport: transport__, + numbers: numbers__, + auth_username: auth_username__, + auth_password: auth_password__, + name: name__, + metadata: metadata__, + media_encryption: media_encryption__, + }) + } + } + deserializer.deserialize_struct("livekit.SIPOutboundTrunkUpdate", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for SipParticipantInfo { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -32968,6 +34075,9 @@ impl serde::Serialize for TrackCompositeEgressRequest { if !self.image_outputs.is_empty() { len += 1; } + if !self.webhooks.is_empty() { + len += 1; + } if self.output.is_some() { len += 1; } @@ -32996,6 +34106,9 @@ impl serde::Serialize for TrackCompositeEgressRequest { if !self.image_outputs.is_empty() { struct_ser.serialize_field("imageOutputs", &self.image_outputs)?; } + if !self.webhooks.is_empty() { + struct_ser.serialize_field("webhooks", &self.webhooks)?; + } if let Some(v) = self.output.as_ref() { match v { track_composite_egress_request::Output::File(v) => { @@ -33045,6 +34158,7 @@ impl<'de> serde::Deserialize<'de> for TrackCompositeEgressRequest { "segmentOutputs", "image_outputs", "imageOutputs", + "webhooks", "file", "stream", "segments", @@ -33061,6 +34175,7 @@ impl<'de> serde::Deserialize<'de> for TrackCompositeEgressRequest { StreamOutputs, SegmentOutputs, ImageOutputs, + Webhooks, File, Stream, Segments, @@ -33095,6 +34210,7 @@ impl<'de> serde::Deserialize<'de> for TrackCompositeEgressRequest { "streamOutputs" | "stream_outputs" => Ok(GeneratedField::StreamOutputs), "segmentOutputs" | "segment_outputs" => Ok(GeneratedField::SegmentOutputs), "imageOutputs" | "image_outputs" => Ok(GeneratedField::ImageOutputs), + "webhooks" => Ok(GeneratedField::Webhooks), "file" => Ok(GeneratedField::File), "stream" => Ok(GeneratedField::Stream), "segments" => Ok(GeneratedField::Segments), @@ -33126,6 +34242,7 @@ impl<'de> serde::Deserialize<'de> for TrackCompositeEgressRequest { let mut stream_outputs__ = None; let mut segment_outputs__ = None; let mut image_outputs__ = None; + let mut webhooks__ = None; let mut output__ = None; let mut options__ = None; while let Some(k) = map_.next_key()? { @@ -33172,6 +34289,12 @@ impl<'de> serde::Deserialize<'de> for TrackCompositeEgressRequest { } image_outputs__ = Some(map_.next_value()?); } + GeneratedField::Webhooks => { + if webhooks__.is_some() { + return Err(serde::de::Error::duplicate_field("webhooks")); + } + webhooks__ = Some(map_.next_value()?); + } GeneratedField::File => { if output__.is_some() { return Err(serde::de::Error::duplicate_field("file")); @@ -33219,6 +34342,7 @@ impl<'de> serde::Deserialize<'de> for TrackCompositeEgressRequest { stream_outputs: stream_outputs__.unwrap_or_default(), segment_outputs: segment_outputs__.unwrap_or_default(), image_outputs: image_outputs__.unwrap_or_default(), + webhooks: webhooks__.unwrap_or_default(), output: output__, options: options__, }) @@ -33241,6 +34365,9 @@ impl serde::Serialize for TrackEgressRequest { if !self.track_id.is_empty() { len += 1; } + if !self.webhooks.is_empty() { + len += 1; + } if self.output.is_some() { len += 1; } @@ -33251,6 +34378,9 @@ impl serde::Serialize for TrackEgressRequest { if !self.track_id.is_empty() { struct_ser.serialize_field("trackId", &self.track_id)?; } + if !self.webhooks.is_empty() { + struct_ser.serialize_field("webhooks", &self.webhooks)?; + } if let Some(v) = self.output.as_ref() { match v { track_egress_request::Output::File(v) => { @@ -33275,6 +34405,7 @@ impl<'de> serde::Deserialize<'de> for TrackEgressRequest { "roomName", "track_id", "trackId", + "webhooks", "file", "websocket_url", "websocketUrl", @@ -33284,6 +34415,7 @@ impl<'de> serde::Deserialize<'de> for TrackEgressRequest { enum GeneratedField { RoomName, TrackId, + Webhooks, File, WebsocketUrl, __SkipField__, @@ -33310,6 +34442,7 @@ impl<'de> serde::Deserialize<'de> for TrackEgressRequest { match value { "roomName" | "room_name" => Ok(GeneratedField::RoomName), "trackId" | "track_id" => Ok(GeneratedField::TrackId), + "webhooks" => Ok(GeneratedField::Webhooks), "file" => Ok(GeneratedField::File), "websocketUrl" | "websocket_url" => Ok(GeneratedField::WebsocketUrl), _ => Ok(GeneratedField::__SkipField__), @@ -33333,6 +34466,7 @@ impl<'de> serde::Deserialize<'de> for TrackEgressRequest { { let mut room_name__ = None; let mut track_id__ = None; + let mut webhooks__ = None; let mut output__ = None; while let Some(k) = map_.next_key()? { match k { @@ -33348,6 +34482,12 @@ impl<'de> serde::Deserialize<'de> for TrackEgressRequest { } track_id__ = Some(map_.next_value()?); } + GeneratedField::Webhooks => { + if webhooks__.is_some() { + return Err(serde::de::Error::duplicate_field("webhooks")); + } + webhooks__ = Some(map_.next_value()?); + } GeneratedField::File => { if output__.is_some() { return Err(serde::de::Error::duplicate_field("file")); @@ -33369,6 +34509,7 @@ impl<'de> serde::Deserialize<'de> for TrackEgressRequest { Ok(TrackEgressRequest { room_name: room_name__.unwrap_or_default(), track_id: track_id__.unwrap_or_default(), + webhooks: webhooks__.unwrap_or_default(), output: output__, }) } @@ -34767,6 +35908,9 @@ impl serde::Serialize for TransferSipParticipantRequest { if !self.headers.is_empty() { len += 1; } + if self.ringing_timeout.is_some() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("livekit.TransferSIPParticipantRequest", len)?; if !self.participant_identity.is_empty() { struct_ser.serialize_field("participantIdentity", &self.participant_identity)?; @@ -34783,6 +35927,9 @@ impl serde::Serialize for TransferSipParticipantRequest { if !self.headers.is_empty() { struct_ser.serialize_field("headers", &self.headers)?; } + if let Some(v) = self.ringing_timeout.as_ref() { + struct_ser.serialize_field("ringingTimeout", v)?; + } struct_ser.end() } } @@ -34802,6 +35949,8 @@ impl<'de> serde::Deserialize<'de> for TransferSipParticipantRequest { "play_dialtone", "playDialtone", "headers", + "ringing_timeout", + "ringingTimeout", ]; #[allow(clippy::enum_variant_names)] @@ -34811,6 +35960,7 @@ impl<'de> serde::Deserialize<'de> for TransferSipParticipantRequest { TransferTo, PlayDialtone, Headers, + RingingTimeout, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -34838,6 +35988,7 @@ impl<'de> serde::Deserialize<'de> for TransferSipParticipantRequest { "transferTo" | "transfer_to" => Ok(GeneratedField::TransferTo), "playDialtone" | "play_dialtone" => Ok(GeneratedField::PlayDialtone), "headers" => Ok(GeneratedField::Headers), + "ringingTimeout" | "ringing_timeout" => Ok(GeneratedField::RingingTimeout), _ => Ok(GeneratedField::__SkipField__), } } @@ -34862,6 +36013,7 @@ impl<'de> serde::Deserialize<'de> for TransferSipParticipantRequest { let mut transfer_to__ = None; let mut play_dialtone__ = None; let mut headers__ = None; + let mut ringing_timeout__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::ParticipantIdentity => { @@ -34896,6 +36048,12 @@ impl<'de> serde::Deserialize<'de> for TransferSipParticipantRequest { map_.next_value::>()? ); } + GeneratedField::RingingTimeout => { + if ringing_timeout__.is_some() { + return Err(serde::de::Error::duplicate_field("ringingTimeout")); + } + ringing_timeout__ = map_.next_value()?; + } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -34907,6 +36065,7 @@ impl<'de> serde::Deserialize<'de> for TransferSipParticipantRequest { transfer_to: transfer_to__.unwrap_or_default(), play_dialtone: play_dialtone__.unwrap_or_default(), headers: headers__.unwrap_or_default(), + ringing_timeout: ringing_timeout__, }) } } @@ -36056,12 +37215,543 @@ impl<'de> serde::Deserialize<'de> for UpdateParticipantRequest { E: serde::de::Error, { match value { - "room" => Ok(GeneratedField::Room), - "identity" => Ok(GeneratedField::Identity), - "metadata" => Ok(GeneratedField::Metadata), - "permission" => Ok(GeneratedField::Permission), - "name" => Ok(GeneratedField::Name), - "attributes" => Ok(GeneratedField::Attributes), + "room" => Ok(GeneratedField::Room), + "identity" => Ok(GeneratedField::Identity), + "metadata" => Ok(GeneratedField::Metadata), + "permission" => Ok(GeneratedField::Permission), + "name" => Ok(GeneratedField::Name), + "attributes" => Ok(GeneratedField::Attributes), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UpdateParticipantRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.UpdateParticipantRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut room__ = None; + let mut identity__ = None; + let mut metadata__ = None; + let mut permission__ = None; + let mut name__ = None; + let mut attributes__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Room => { + if room__.is_some() { + return Err(serde::de::Error::duplicate_field("room")); + } + room__ = Some(map_.next_value()?); + } + GeneratedField::Identity => { + if identity__.is_some() { + return Err(serde::de::Error::duplicate_field("identity")); + } + identity__ = Some(map_.next_value()?); + } + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); + } + metadata__ = Some(map_.next_value()?); + } + GeneratedField::Permission => { + if permission__.is_some() { + return Err(serde::de::Error::duplicate_field("permission")); + } + permission__ = map_.next_value()?; + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::Attributes => { + if attributes__.is_some() { + return Err(serde::de::Error::duplicate_field("attributes")); + } + attributes__ = Some( + map_.next_value::>()? + ); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(UpdateParticipantRequest { + room: room__.unwrap_or_default(), + identity: identity__.unwrap_or_default(), + metadata: metadata__.unwrap_or_default(), + permission: permission__, + name: name__.unwrap_or_default(), + attributes: attributes__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.UpdateParticipantRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UpdateRoomMetadataRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.room.is_empty() { + len += 1; + } + if !self.metadata.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.UpdateRoomMetadataRequest", len)?; + if !self.room.is_empty() { + struct_ser.serialize_field("room", &self.room)?; + } + if !self.metadata.is_empty() { + struct_ser.serialize_field("metadata", &self.metadata)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UpdateRoomMetadataRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "room", + "metadata", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Room, + Metadata, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "room" => Ok(GeneratedField::Room), + "metadata" => Ok(GeneratedField::Metadata), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UpdateRoomMetadataRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.UpdateRoomMetadataRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut room__ = None; + let mut metadata__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Room => { + if room__.is_some() { + return Err(serde::de::Error::duplicate_field("room")); + } + room__ = Some(map_.next_value()?); + } + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); + } + metadata__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(UpdateRoomMetadataRequest { + room: room__.unwrap_or_default(), + metadata: metadata__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.UpdateRoomMetadataRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UpdateSipDispatchRuleRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.sip_dispatch_rule_id.is_empty() { + len += 1; + } + if self.action.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.UpdateSIPDispatchRuleRequest", len)?; + if !self.sip_dispatch_rule_id.is_empty() { + struct_ser.serialize_field("sipDispatchRuleId", &self.sip_dispatch_rule_id)?; + } + if let Some(v) = self.action.as_ref() { + match v { + update_sip_dispatch_rule_request::Action::Replace(v) => { + struct_ser.serialize_field("replace", v)?; + } + update_sip_dispatch_rule_request::Action::Update(v) => { + struct_ser.serialize_field("update", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UpdateSipDispatchRuleRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sip_dispatch_rule_id", + "sipDispatchRuleId", + "replace", + "update", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SipDispatchRuleId, + Replace, + Update, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sipDispatchRuleId" | "sip_dispatch_rule_id" => Ok(GeneratedField::SipDispatchRuleId), + "replace" => Ok(GeneratedField::Replace), + "update" => Ok(GeneratedField::Update), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UpdateSipDispatchRuleRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.UpdateSIPDispatchRuleRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sip_dispatch_rule_id__ = None; + let mut action__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::SipDispatchRuleId => { + if sip_dispatch_rule_id__.is_some() { + return Err(serde::de::Error::duplicate_field("sipDispatchRuleId")); + } + sip_dispatch_rule_id__ = Some(map_.next_value()?); + } + GeneratedField::Replace => { + if action__.is_some() { + return Err(serde::de::Error::duplicate_field("replace")); + } + action__ = map_.next_value::<::std::option::Option<_>>()?.map(update_sip_dispatch_rule_request::Action::Replace) +; + } + GeneratedField::Update => { + if action__.is_some() { + return Err(serde::de::Error::duplicate_field("update")); + } + action__ = map_.next_value::<::std::option::Option<_>>()?.map(update_sip_dispatch_rule_request::Action::Update) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(UpdateSipDispatchRuleRequest { + sip_dispatch_rule_id: sip_dispatch_rule_id__.unwrap_or_default(), + action: action__, + }) + } + } + deserializer.deserialize_struct("livekit.UpdateSIPDispatchRuleRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UpdateSipInboundTrunkRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.sip_trunk_id.is_empty() { + len += 1; + } + if self.action.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.UpdateSIPInboundTrunkRequest", len)?; + if !self.sip_trunk_id.is_empty() { + struct_ser.serialize_field("sipTrunkId", &self.sip_trunk_id)?; + } + if let Some(v) = self.action.as_ref() { + match v { + update_sip_inbound_trunk_request::Action::Replace(v) => { + struct_ser.serialize_field("replace", v)?; + } + update_sip_inbound_trunk_request::Action::Update(v) => { + struct_ser.serialize_field("update", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UpdateSipInboundTrunkRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sip_trunk_id", + "sipTrunkId", + "replace", + "update", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SipTrunkId, + Replace, + Update, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sipTrunkId" | "sip_trunk_id" => Ok(GeneratedField::SipTrunkId), + "replace" => Ok(GeneratedField::Replace), + "update" => Ok(GeneratedField::Update), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UpdateSipInboundTrunkRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.UpdateSIPInboundTrunkRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sip_trunk_id__ = None; + let mut action__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::SipTrunkId => { + if sip_trunk_id__.is_some() { + return Err(serde::de::Error::duplicate_field("sipTrunkId")); + } + sip_trunk_id__ = Some(map_.next_value()?); + } + GeneratedField::Replace => { + if action__.is_some() { + return Err(serde::de::Error::duplicate_field("replace")); + } + action__ = map_.next_value::<::std::option::Option<_>>()?.map(update_sip_inbound_trunk_request::Action::Replace) +; + } + GeneratedField::Update => { + if action__.is_some() { + return Err(serde::de::Error::duplicate_field("update")); + } + action__ = map_.next_value::<::std::option::Option<_>>()?.map(update_sip_inbound_trunk_request::Action::Update) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(UpdateSipInboundTrunkRequest { + sip_trunk_id: sip_trunk_id__.unwrap_or_default(), + action: action__, + }) + } + } + deserializer.deserialize_struct("livekit.UpdateSIPInboundTrunkRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UpdateSipOutboundTrunkRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.sip_trunk_id.is_empty() { + len += 1; + } + if self.action.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.UpdateSIPOutboundTrunkRequest", len)?; + if !self.sip_trunk_id.is_empty() { + struct_ser.serialize_field("sipTrunkId", &self.sip_trunk_id)?; + } + if let Some(v) = self.action.as_ref() { + match v { + update_sip_outbound_trunk_request::Action::Replace(v) => { + struct_ser.serialize_field("replace", v)?; + } + update_sip_outbound_trunk_request::Action::Update(v) => { + struct_ser.serialize_field("update", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UpdateSipOutboundTrunkRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sip_trunk_id", + "sipTrunkId", + "replace", + "update", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SipTrunkId, + Replace, + Update, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sipTrunkId" | "sip_trunk_id" => Ok(GeneratedField::SipTrunkId), + "replace" => Ok(GeneratedField::Replace), + "update" => Ok(GeneratedField::Update), _ => Ok(GeneratedField::__SkipField__), } } @@ -36071,190 +37761,52 @@ impl<'de> serde::Deserialize<'de> for UpdateParticipantRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = UpdateParticipantRequest; + type Value = UpdateSipOutboundTrunkRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.UpdateParticipantRequest") + formatter.write_str("struct livekit.UpdateSIPOutboundTrunkRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut room__ = None; - let mut identity__ = None; - let mut metadata__ = None; - let mut permission__ = None; - let mut name__ = None; - let mut attributes__ = None; + let mut sip_trunk_id__ = None; + let mut action__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Room => { - if room__.is_some() { - return Err(serde::de::Error::duplicate_field("room")); - } - room__ = Some(map_.next_value()?); - } - GeneratedField::Identity => { - if identity__.is_some() { - return Err(serde::de::Error::duplicate_field("identity")); - } - identity__ = Some(map_.next_value()?); - } - GeneratedField::Metadata => { - if metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("metadata")); - } - metadata__ = Some(map_.next_value()?); - } - GeneratedField::Permission => { - if permission__.is_some() { - return Err(serde::de::Error::duplicate_field("permission")); - } - permission__ = map_.next_value()?; - } - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map_.next_value()?); - } - GeneratedField::Attributes => { - if attributes__.is_some() { - return Err(serde::de::Error::duplicate_field("attributes")); + GeneratedField::SipTrunkId => { + if sip_trunk_id__.is_some() { + return Err(serde::de::Error::duplicate_field("sipTrunkId")); } - attributes__ = Some( - map_.next_value::>()? - ); - } - GeneratedField::__SkipField__ => { - let _ = map_.next_value::()?; - } - } - } - Ok(UpdateParticipantRequest { - room: room__.unwrap_or_default(), - identity: identity__.unwrap_or_default(), - metadata: metadata__.unwrap_or_default(), - permission: permission__, - name: name__.unwrap_or_default(), - attributes: attributes__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("livekit.UpdateParticipantRequest", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for UpdateRoomMetadataRequest { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.room.is_empty() { - len += 1; - } - if !self.metadata.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("livekit.UpdateRoomMetadataRequest", len)?; - if !self.room.is_empty() { - struct_ser.serialize_field("room", &self.room)?; - } - if !self.metadata.is_empty() { - struct_ser.serialize_field("metadata", &self.metadata)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for UpdateRoomMetadataRequest { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "room", - "metadata", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Room, - Metadata, - __SkipField__, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "room" => Ok(GeneratedField::Room), - "metadata" => Ok(GeneratedField::Metadata), - _ => Ok(GeneratedField::__SkipField__), + sip_trunk_id__ = Some(map_.next_value()?); } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = UpdateRoomMetadataRequest; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.UpdateRoomMetadataRequest") - } - - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut room__ = None; - let mut metadata__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Room => { - if room__.is_some() { - return Err(serde::de::Error::duplicate_field("room")); + GeneratedField::Replace => { + if action__.is_some() { + return Err(serde::de::Error::duplicate_field("replace")); } - room__ = Some(map_.next_value()?); + action__ = map_.next_value::<::std::option::Option<_>>()?.map(update_sip_outbound_trunk_request::Action::Replace) +; } - GeneratedField::Metadata => { - if metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("metadata")); + GeneratedField::Update => { + if action__.is_some() { + return Err(serde::de::Error::duplicate_field("update")); } - metadata__ = Some(map_.next_value()?); + action__ = map_.next_value::<::std::option::Option<_>>()?.map(update_sip_outbound_trunk_request::Action::Update) +; } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(UpdateRoomMetadataRequest { - room: room__.unwrap_or_default(), - metadata: metadata__.unwrap_or_default(), + Ok(UpdateSipOutboundTrunkRequest { + sip_trunk_id: sip_trunk_id__.unwrap_or_default(), + action: action__, }) } } - deserializer.deserialize_struct("livekit.UpdateRoomMetadataRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.UpdateSIPOutboundTrunkRequest", FIELDS, GeneratedVisitor) } } impl serde::Serialize for UpdateStreamRequest { @@ -38154,6 +39706,9 @@ impl serde::Serialize for WebEgressRequest { if !self.image_outputs.is_empty() { len += 1; } + if !self.webhooks.is_empty() { + len += 1; + } if self.output.is_some() { len += 1; } @@ -38185,6 +39740,9 @@ impl serde::Serialize for WebEgressRequest { if !self.image_outputs.is_empty() { struct_ser.serialize_field("imageOutputs", &self.image_outputs)?; } + if !self.webhooks.is_empty() { + struct_ser.serialize_field("webhooks", &self.webhooks)?; + } if let Some(v) = self.output.as_ref() { match v { web_egress_request::Output::File(v) => { @@ -38235,6 +39793,7 @@ impl<'de> serde::Deserialize<'de> for WebEgressRequest { "segmentOutputs", "image_outputs", "imageOutputs", + "webhooks", "file", "stream", "segments", @@ -38252,6 +39811,7 @@ impl<'de> serde::Deserialize<'de> for WebEgressRequest { StreamOutputs, SegmentOutputs, ImageOutputs, + Webhooks, File, Stream, Segments, @@ -38287,6 +39847,7 @@ impl<'de> serde::Deserialize<'de> for WebEgressRequest { "streamOutputs" | "stream_outputs" => Ok(GeneratedField::StreamOutputs), "segmentOutputs" | "segment_outputs" => Ok(GeneratedField::SegmentOutputs), "imageOutputs" | "image_outputs" => Ok(GeneratedField::ImageOutputs), + "webhooks" => Ok(GeneratedField::Webhooks), "file" => Ok(GeneratedField::File), "stream" => Ok(GeneratedField::Stream), "segments" => Ok(GeneratedField::Segments), @@ -38319,6 +39880,7 @@ impl<'de> serde::Deserialize<'de> for WebEgressRequest { let mut stream_outputs__ = None; let mut segment_outputs__ = None; let mut image_outputs__ = None; + let mut webhooks__ = None; let mut output__ = None; let mut options__ = None; while let Some(k) = map_.next_key()? { @@ -38371,6 +39933,12 @@ impl<'de> serde::Deserialize<'de> for WebEgressRequest { } image_outputs__ = Some(map_.next_value()?); } + GeneratedField::Webhooks => { + if webhooks__.is_some() { + return Err(serde::de::Error::duplicate_field("webhooks")); + } + webhooks__ = Some(map_.next_value()?); + } GeneratedField::File => { if output__.is_some() { return Err(serde::de::Error::duplicate_field("file")); @@ -38419,6 +39987,7 @@ impl<'de> serde::Deserialize<'de> for WebEgressRequest { stream_outputs: stream_outputs__.unwrap_or_default(), segment_outputs: segment_outputs__.unwrap_or_default(), image_outputs: image_outputs__.unwrap_or_default(), + webhooks: webhooks__.unwrap_or_default(), output: output__, options: options__, }) @@ -38427,6 +39996,119 @@ impl<'de> serde::Deserialize<'de> for WebEgressRequest { deserializer.deserialize_struct("livekit.WebEgressRequest", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for WebhookConfig { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.url.is_empty() { + len += 1; + } + if !self.signing_key.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.WebhookConfig", len)?; + if !self.url.is_empty() { + struct_ser.serialize_field("url", &self.url)?; + } + if !self.signing_key.is_empty() { + struct_ser.serialize_field("signingKey", &self.signing_key)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WebhookConfig { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "url", + "signing_key", + "signingKey", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Url, + SigningKey, + __SkipField__, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "url" => Ok(GeneratedField::Url), + "signingKey" | "signing_key" => Ok(GeneratedField::SigningKey), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WebhookConfig; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.WebhookConfig") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut url__ = None; + let mut signing_key__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Url => { + if url__.is_some() { + return Err(serde::de::Error::duplicate_field("url")); + } + url__ = Some(map_.next_value()?); + } + GeneratedField::SigningKey => { + if signing_key__.is_some() { + return Err(serde::de::Error::duplicate_field("signingKey")); + } + signing_key__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(WebhookConfig { + url: url__.unwrap_or_default(), + signing_key: signing_key__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.WebhookConfig", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for WebhookEvent { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result diff --git a/livekit/src/prelude.rs b/livekit/src/prelude.rs index 1c2eab0ff..505cf7e2a 100644 --- a/livekit/src/prelude.rs +++ b/livekit/src/prelude.rs @@ -12,6 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +pub use livekit_protocol::AudioTrackFeature; + pub use crate::{ id::*, participant::{ diff --git a/livekit/src/proto.rs b/livekit/src/proto.rs index 2b3442255..698a27d5a 100644 --- a/livekit/src/proto.rs +++ b/livekit/src/proto.rs @@ -47,6 +47,7 @@ impl From for participant::DisconnectReason { DisconnectReason::UserUnavailable => Self::UserUnavailable, DisconnectReason::UserRejected => Self::UserRejected, DisconnectReason::SipTrunkFailure => Self::SipTrunkFailure, + DisconnectReason::ConnectionTimeout => Self::ConnectionTimeout, } } } diff --git a/livekit/src/room/data_stream/outgoing.rs b/livekit/src/room/data_stream/outgoing.rs index 7984f4e32..180d53caf 100644 --- a/livekit/src/room/data_stream/outgoing.rs +++ b/livekit/src/room/data_stream/outgoing.rs @@ -74,7 +74,7 @@ impl<'a> StreamWriter<'a> for ByteStreamWriter { &self.info } - async fn write(&self, bytes: &[u8]) -> StreamResult<()> { + async fn write(&self, bytes: &'a [u8]) -> StreamResult<()> { let mut stream = self.stream.lock().await; for chunk in bytes.chunks(CHUNK_SIZE) { stream.write_chunk(chunk).await?; @@ -116,7 +116,7 @@ impl<'a> StreamWriter<'a> for TextStreamWriter { &self.info } - async fn write(&self, text: &str) -> StreamResult<()> { + async fn write(&self, text: &'a str) -> StreamResult<()> { let mut stream = self.stream.lock().await; for chunk in text.as_bytes().utf8_aware_chunks(CHUNK_SIZE) { stream.write_chunk(chunk).await?; diff --git a/livekit/src/room/participant/mod.rs b/livekit/src/room/participant/mod.rs index 30cf0544c..1f0d9b703 100644 --- a/livekit/src/room/participant/mod.rs +++ b/livekit/src/room/participant/mod.rs @@ -62,6 +62,7 @@ pub enum DisconnectReason { UserUnavailable, UserRejected, SipTrunkFailure, + ConnectionTimeout, } #[derive(Debug, Clone)] diff --git a/livekit/src/room/publication/local.rs b/livekit/src/room/publication/local.rs index bd222982c..728177913 100644 --- a/livekit/src/room/publication/local.rs +++ b/livekit/src/room/publication/local.rs @@ -14,7 +14,7 @@ use std::{fmt::Debug, sync::Arc}; -use livekit_protocol as proto; +use livekit_protocol::{self as proto, AudioTrackFeature}; use parking_lot::Mutex; use super::TrackPublicationInner; @@ -145,4 +145,8 @@ impl LocalTrackPublication { pub fn encryption_type(&self) -> EncryptionType { self.inner.info.read().encryption_type } + + pub fn audio_features(&self) -> Vec { + self.inner.info.read().audio_features.clone() + } } diff --git a/livekit/src/room/publication/mod.rs b/livekit/src/room/publication/mod.rs index c4db8c59b..530a9106c 100644 --- a/livekit/src/room/publication/mod.rs +++ b/livekit/src/room/publication/mod.rs @@ -14,8 +14,8 @@ use std::sync::Arc; -use livekit_protocol as proto; use livekit_protocol::enum_dispatch; +use livekit_protocol::{self as proto, AudioTrackFeature}; use parking_lot::{Mutex, RwLock}; use super::track::TrackDimension; @@ -59,6 +59,7 @@ impl TrackPublication { pub fn is_muted(self: &Self) -> bool; pub fn is_remote(self: &Self) -> bool; pub fn encryption_type(self: &Self) -> EncryptionType; + pub fn audio_features(self: &Self) -> Vec; pub(crate) fn on_muted(self: &Self, on_mute: impl Fn(TrackPublication) + Send + 'static) -> (); pub(crate) fn on_unmuted(self: &Self, on_unmute: impl Fn(TrackPublication) + Send + 'static) -> (); @@ -94,6 +95,7 @@ struct PublicationInfo { pub muted: bool, pub proto_info: proto::TrackInfo, pub encryption_type: EncryptionType, + pub audio_features: Vec, } pub(crate) type MutedHandler = Box; @@ -120,12 +122,17 @@ pub(super) fn new_inner( source: info.source().into(), kind: info.r#type().try_into().unwrap(), encryption_type: info.encryption().into(), - name: info.name, - sid: info.sid.try_into().unwrap(), + name: info.clone().name, + sid: info.sid.clone().try_into().unwrap(), simulcasted: info.simulcast, dimension: TrackDimension(info.width, info.height), - mime_type: info.mime_type, + mime_type: info.mime_type.clone(), muted: info.muted, + audio_features: info + .audio_features() + .into_iter() + .map(|item| item.try_into().unwrap()) + .collect(), }; Arc::new(TrackPublicationInner { info: RwLock::new(info), events: Default::default() }) @@ -141,11 +148,12 @@ pub(super) fn update_info( info.source = TrackSource::from(new_info.source()); info.encryption_type = new_info.encryption().into(); info.proto_info = new_info.clone(); - info.name = new_info.name; - info.sid = new_info.sid.try_into().unwrap(); + info.name = new_info.name.clone(); + info.sid = new_info.sid.clone().try_into().unwrap(); info.dimension = TrackDimension(new_info.width, new_info.height); - info.mime_type = new_info.mime_type; + info.mime_type = new_info.mime_type.clone(); info.simulcasted = new_info.simulcast; + info.audio_features = new_info.audio_features().collect(); } pub(super) fn set_track( diff --git a/livekit/src/room/publication/remote.rs b/livekit/src/room/publication/remote.rs index fe86ebf1f..6e93fdeb7 100644 --- a/livekit/src/room/publication/remote.rs +++ b/livekit/src/room/publication/remote.rs @@ -14,7 +14,7 @@ use std::{fmt::Debug, sync::Arc}; -use livekit_protocol as proto; +use livekit_protocol::{self as proto, AudioTrackFeature}; use parking_lot::{Mutex, RwLock}; use super::{PermissionStatus, SubscriptionStatus, TrackPublication, TrackPublicationInner}; @@ -368,4 +368,8 @@ impl RemoteTrackPublication { pub fn encryption_type(&self) -> EncryptionType { self.inner.info.read().encryption_type } + + pub fn audio_features(&self) -> Vec { + self.inner.info.read().audio_features.clone() + } } diff --git a/livekit/src/room/track/mod.rs b/livekit/src/room/track/mod.rs index 27992bd8f..936b3fec0 100644 --- a/livekit/src/room/track/mod.rs +++ b/livekit/src/room/track/mod.rs @@ -15,8 +15,8 @@ use std::{fmt::Debug, sync::Arc}; use libwebrtc::{prelude::*, stats::RtcStats}; -use livekit_protocol as proto; use livekit_protocol::enum_dispatch; +use livekit_protocol::{self as proto}; use parking_lot::{Mutex, RwLock}; use thiserror::Error; @@ -145,6 +145,7 @@ struct TrackInfo { pub stream_state: StreamState, pub muted: bool, pub transceiver: Option, + pub audio_features: Vec, } pub(super) struct TrackInner { @@ -168,6 +169,7 @@ pub(super) fn new_inner( stream_state: StreamState::Active, muted: false, transceiver: None, + audio_features: Vec::new(), }), rtc_track, events: Default::default(), @@ -203,6 +205,8 @@ pub(super) fn update_info(inner: &Arc, _track: &Track, new_info: pro let mut info = inner.info.write(); info.kind = TrackKind::try_from(new_info.r#type()).unwrap(); info.source = TrackSource::from(new_info.source()); - info.name = new_info.name; - info.sid = new_info.sid.try_into().unwrap(); + info.name = new_info.name.clone(); + info.sid = new_info.sid.clone().try_into().unwrap(); + info.audio_features = + new_info.audio_features().into_iter().map(|item| item.try_into().unwrap()).collect(); } diff --git a/livekit/src/room/track/remote_audio_track.rs b/livekit/src/room/track/remote_audio_track.rs index a73023de7..cb62fbf1b 100644 --- a/livekit/src/room/track/remote_audio_track.rs +++ b/livekit/src/room/track/remote_audio_track.rs @@ -15,7 +15,7 @@ use std::{fmt::Debug, sync::Arc}; use libwebrtc::{prelude::*, stats::RtcStats}; -use livekit_protocol as proto; +use livekit_protocol::{self as proto, AudioTrackFeature}; use super::{remote_track, TrackInner}; use crate::prelude::*;