From 16d0294abfc99ff44fcb8a0b2cb43958df122596 Mon Sep 17 00:00:00 2001 From: Jacob Gelman <3182119+ladvoc@users.noreply.github.com> Date: Sat, 31 Jan 2026 15:43:17 +1100 Subject: [PATCH 1/3] Upgrade protocol to v1.44.0 --- livekit-protocol/protocol | 2 +- livekit-protocol/src/livekit.rs | 303 +- livekit-protocol/src/livekit.serde.rs | 4985 ++++++++++++++++++------- 3 files changed, 3854 insertions(+), 1436 deletions(-) diff --git a/livekit-protocol/protocol b/livekit-protocol/protocol index fcc48786b..765a80e42 160000 --- a/livekit-protocol/protocol +++ b/livekit-protocol/protocol @@ -1 +1 @@ -Subproject commit fcc48786b42607b8ba87e840a5c1d39e00b5f4e9 +Subproject commit 765a80e4298e376593859c3f11cf748c725f68f9 diff --git a/livekit-protocol/src/livekit.rs b/livekit-protocol/src/livekit.rs index da058ae5a..fe99a4674 100644 --- a/livekit-protocol/src/livekit.rs +++ b/livekit-protocol/src/livekit.rs @@ -88,6 +88,8 @@ pub struct MetricsRecordingHeader { pub duration: u64, #[prost(message, optional, tag="4")] pub start_time: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(map="string, string", tag="5")] + pub room_tags: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } // // Protocol used to record metrics for a specific session. @@ -357,6 +359,8 @@ pub struct ParticipantInfo { pub disconnect_reason: i32, #[prost(enumeration="participant_info::KindDetail", repeated, tag="18")] pub kind_details: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="19")] + pub data_tracks: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `ParticipantInfo`. pub mod participant_info { @@ -410,9 +414,11 @@ pub mod participant_info { /// LiveKit agents Agent = 4, /// Connectors participants - /// - /// NEXT_ID: 8 Connector = 7, + /// Bridge participants + /// + /// NEXT_ID: 9 + Bridge = 8, } impl Kind { /// String value of the enum field names used in the ProtoBuf definition. @@ -427,6 +433,7 @@ pub mod participant_info { Kind::Sip => "SIP", Kind::Agent => "AGENT", Kind::Connector => "CONNECTOR", + Kind::Bridge => "BRIDGE", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -438,6 +445,7 @@ pub mod participant_info { "SIP" => Some(Self::Sip), "AGENT" => Some(Self::Agent), "CONNECTOR" => Some(Self::Connector), + "BRIDGE" => Some(Self::Bridge), _ => None, } } @@ -449,6 +457,8 @@ pub mod participant_info { Forwarded = 1, ConnectorWhatsapp = 2, ConnectorTwilio = 3, + /// NEXT_ID: 5 + BridgeRtsp = 4, } impl KindDetail { /// String value of the enum field names used in the ProtoBuf definition. @@ -461,6 +471,7 @@ pub mod participant_info { KindDetail::Forwarded => "FORWARDED", KindDetail::ConnectorWhatsapp => "CONNECTOR_WHATSAPP", KindDetail::ConnectorTwilio => "CONNECTOR_TWILIO", + KindDetail::BridgeRtsp => "BRIDGE_RTSP", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -470,6 +481,7 @@ pub mod participant_info { "FORWARDED" => Some(Self::Forwarded), "CONNECTOR_WHATSAPP" => Some(Self::ConnectorWhatsapp), "CONNECTOR_TWILIO" => Some(Self::ConnectorTwilio), + "BRIDGE_RTSP" => Some(Self::BridgeRtsp), _ => None, } } @@ -593,6 +605,38 @@ pub struct TrackInfo { #[prost(enumeration="BackupCodecPolicy", tag="20")] pub backup_codec_policy: i32, } +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DataTrackInfo { + /// Client-assigned, 16-bit identifier that will be attached to packets sent by the publisher. + #[prost(uint32, tag="1")] + pub pub_handle: u32, + /// Server-assigned track identifier. + #[prost(string, tag="2")] + pub sid: ::prost::alloc::string::String, + /// Human-readable identifier (e.g., `geoLocation`, `servoPosition.x`, etc.), unique per publisher. + #[prost(string, tag="3")] + pub name: ::prost::alloc::string::String, + /// Method used for end-to-end encryption (E2EE) on packet payloads. + #[prost(enumeration="encryption::Type", tag="4")] + pub encryption: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DataTrackExtensionParticipantSid { + #[prost(enumeration="DataTrackExtensionId", tag="1")] + pub id: i32, + #[prost(string, tag="2")] + pub participant_sid: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DataTrackSubscriptionOptions { + /// Rate in frames per second (FPS) the subscriber wants to receive frames at. + /// If omitted, the subscriber defaults to the publisher's fps + #[prost(uint32, optional, tag="1")] + pub target_fps: ::core::option::Option, +} /// provide information about available spatial layers #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -613,6 +657,8 @@ pub struct VideoLayer { pub spatial_layer: i32, #[prost(string, tag="7")] pub rid: ::prost::alloc::string::String, + #[prost(uint32, tag="8")] + pub repair_ssrc: u32, } /// Nested message and enum types in `VideoLayer`. pub mod video_layer { @@ -1681,6 +1727,32 @@ impl TrackSource { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] +pub enum DataTrackExtensionId { + DteiInvalid = 0, + DteiParticipantSid = 1, +} +impl DataTrackExtensionId { + /// 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 { + DataTrackExtensionId::DteiInvalid => "DTEI_INVALID", + DataTrackExtensionId::DteiParticipantSid => "DTEI_PARTICIPANT_SID", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DTEI_INVALID" => Some(Self::DteiInvalid), + "DTEI_PARTICIPANT_SID" => Some(Self::DteiParticipantSid), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] pub enum VideoQuality { Low = 0, Medium = 1, @@ -3044,7 +3116,7 @@ impl EgressSourceType { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct SignalRequest { - #[prost(oneof="signal_request::Message", tags="1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18")] + #[prost(oneof="signal_request::Message", tags="1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21")] pub message: ::core::option::Option, } /// Nested message and enum types in `SignalRequest`. @@ -3103,12 +3175,21 @@ pub mod signal_request { /// Update local video track settings #[prost(message, tag="18")] UpdateVideoTrack(super::UpdateLocalVideoTrack), + /// Publish a data track + #[prost(message, tag="19")] + PublishDataTrackRequest(super::PublishDataTrackRequest), + /// Unpublish a data track + #[prost(message, tag="20")] + UnpublishDataTrackRequest(super::UnpublishDataTrackRequest), + /// Update subscription state for one or more data tracks + #[prost(message, tag="21")] + UpdateDataSubscription(super::UpdateDataSubscription), } } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct SignalResponse { - #[prost(oneof="signal_response::Message", tags="1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26")] + #[prost(oneof="signal_response::Message", tags="1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29")] pub message: ::core::option::Option, } /// Nested message and enum types in `SignalResponse`. @@ -3194,6 +3275,15 @@ pub mod signal_response { /// when audio subscription changes, used to enable simulcasting of audio codecs based on subscriptions #[prost(message, tag="26")] SubscribedAudioCodecUpdate(super::SubscribedAudioCodecUpdate), + /// Sent in response to `PublishDataTrackRequest`. + #[prost(message, tag="27")] + PublishDataTrackResponse(super::PublishDataTrackResponse), + /// Sent in response to `UnpublishDataTrackRequest` or SFU-initiated unpublish. + #[prost(message, tag="28")] + UnpublishDataTrackResponse(super::UnpublishDataTrackResponse), + /// Sent to data track subscribers to provide mapping from track SIDs to handles. + #[prost(message, tag="29")] + DataTrackSubscriberHandles(super::DataTrackSubscriberHandles), } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -3260,6 +3350,62 @@ pub struct AddTrackRequest { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] +pub struct PublishDataTrackRequest { + /// Client-assigned, 16-bit identifier that will be attached to packets sent by the publisher. + /// This must be non-zero and unique for each data track published by the publisher. + #[prost(uint32, tag="1")] + pub pub_handle: u32, + /// Human-readable identifier (e.g., `geoLocation`, `servoPosition.x`, etc.), unique per publisher. + /// This must be non-empty and no longer than 256 characters. + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, + /// Method used for end-to-end encryption (E2EE) on frame payloads. + #[prost(enumeration="encryption::Type", tag="3")] + pub encryption: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PublishDataTrackResponse { + /// Information about the published track. + #[prost(message, optional, tag="1")] + pub info: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnpublishDataTrackRequest { + /// Publisher handle of the track to unpublish. + #[prost(uint32, tag="1")] + pub pub_handle: u32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnpublishDataTrackResponse { + /// Information about the unpublished track. + #[prost(message, optional, tag="1")] + pub info: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DataTrackSubscriberHandles { + /// Maps handles from incoming packets to the track SIDs that the packets belong to. + #[prost(map="uint32, message", tag="1")] + pub sub_handles: ::std::collections::HashMap, +} +/// Nested message and enum types in `DataTrackSubscriberHandles`. +pub mod data_track_subscriber_handles { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct PublishedDataTrack { + #[prost(string, tag="1")] + pub publisher_identity: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub publisher_sid: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub track_sid: ::prost::alloc::string::String, + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct TrickleRequest { #[prost(string, tag="1")] pub candidate_init: ::prost::alloc::string::String, @@ -3375,6 +3521,27 @@ pub struct UpdateSubscription { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateDataSubscription { + #[prost(message, repeated, tag="1")] + pub updates: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `UpdateDataSubscription`. +pub mod update_data_subscription { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Update { + #[prost(string, tag="1")] + pub track_sid: ::prost::alloc::string::String, + #[prost(bool, tag="2")] + pub subscribe: bool, + /// Options to apply when initially subscribing or updating an existing subscription. + /// When unsubscribing, this field is ignored. + #[prost(message, optional, tag="3")] + pub options: ::core::option::Option, + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct UpdateTrackSettings { #[prost(string, repeated, tag="1")] pub track_sids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, @@ -3651,6 +3818,8 @@ pub struct SyncState { pub track_sids_disabled: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, #[prost(message, repeated, tag="7")] pub datachannel_receive_states: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="8")] + pub publish_data_tracks: ::prost::alloc::vec::Vec, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -3762,7 +3931,7 @@ pub struct RequestResponse { pub reason: i32, #[prost(string, tag="3")] pub message: ::prost::alloc::string::String, - #[prost(oneof="request_response::Request", tags="4, 5, 6, 7, 8, 9")] + #[prost(oneof="request_response::Request", tags="4, 5, 6, 7, 8, 9, 10, 11")] pub request: ::core::option::Option, } /// Nested message and enum types in `RequestResponse`. @@ -3777,6 +3946,10 @@ pub mod request_response { Queued = 4, UnsupportedType = 5, UnclassifiedError = 6, + InvalidHandle = 7, + InvalidName = 8, + DuplicateHandle = 9, + DuplicateName = 10, } impl Reason { /// String value of the enum field names used in the ProtoBuf definition. @@ -3792,6 +3965,10 @@ pub mod request_response { Reason::Queued => "QUEUED", Reason::UnsupportedType => "UNSUPPORTED_TYPE", Reason::UnclassifiedError => "UNCLASSIFIED_ERROR", + Reason::InvalidHandle => "INVALID_HANDLE", + Reason::InvalidName => "INVALID_NAME", + Reason::DuplicateHandle => "DUPLICATE_HANDLE", + Reason::DuplicateName => "DUPLICATE_NAME", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -3804,6 +3981,10 @@ pub mod request_response { "QUEUED" => Some(Self::Queued), "UNSUPPORTED_TYPE" => Some(Self::UnsupportedType), "UNCLASSIFIED_ERROR" => Some(Self::UnclassifiedError), + "INVALID_HANDLE" => Some(Self::InvalidHandle), + "INVALID_NAME" => Some(Self::InvalidName), + "DUPLICATE_HANDLE" => Some(Self::DuplicateHandle), + "DUPLICATE_NAME" => Some(Self::DuplicateName), _ => None, } } @@ -3823,6 +4004,10 @@ pub mod request_response { UpdateAudioTrack(super::UpdateLocalAudioTrack), #[prost(message, tag="9")] UpdateVideoTrack(super::UpdateLocalVideoTrack), + #[prost(message, tag="10")] + PublishDataTrack(super::PublishDataTrackRequest), + #[prost(message, tag="11")] + UnpublishDataTrack(super::UnpublishDataTrackRequest), } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -3842,6 +4027,8 @@ pub struct ConnectionSettings { pub subscriber_allow_pause: ::core::option::Option, #[prost(bool, tag="4")] pub disable_ice_lite: bool, + #[prost(bool, optional, tag="5")] + pub auto_subscribe_data_track: ::core::option::Option, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -4047,7 +4234,7 @@ pub struct JobState { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct WorkerMessage { - #[prost(oneof="worker_message::Message", tags="1, 2, 3, 4, 5, 6, 7")] + #[prost(oneof="worker_message::Message", tags="1, 2, 3, 4, 5, 6, 7, 8, 9")] pub message: ::core::option::Option, } /// Nested message and enum types in `WorkerMessage`. @@ -4073,13 +4260,17 @@ pub mod worker_message { SimulateJob(super::SimulateJobRequest), #[prost(message, tag="7")] MigrateJob(super::MigrateJobRequest), + #[prost(message, tag="8")] + TextResponse(super::TextMessageResponse), + #[prost(message, tag="9")] + PushText(super::PushTextRequest), } } /// from Server to Worker #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ServerMessage { - #[prost(oneof="server_message::Message", tags="1, 2, 3, 5, 4")] + #[prost(oneof="server_message::Message", tags="1, 2, 3, 5, 4, 6")] pub message: ::core::option::Option, } /// Nested message and enum types in `ServerMessage`. @@ -4099,6 +4290,8 @@ pub mod server_message { Termination(super::JobTermination), #[prost(message, tag="4")] Pong(super::WorkerPong), + #[prost(message, tag="6")] + TextRequest(super::TextMessageRequest), } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -4228,6 +4421,42 @@ pub struct JobTermination { #[prost(string, tag="1")] pub job_id: ::prost::alloc::string::String, } +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TextMessageRequest { + #[prost(string, tag="1")] + pub message_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub session_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub agent_name: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub metadata: ::prost::alloc::string::String, + #[prost(bytes="vec", tag="5")] + pub session_data: ::prost::alloc::vec::Vec, + #[prost(string, tag="6")] + pub text: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PushTextRequest { + /// The message_id of the TextMessageRequest that this push is for + #[prost(string, tag="1")] + pub message_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub content: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TextMessageResponse { + /// Indicate the request is completed + #[prost(string, tag="1")] + pub message_id: ::prost::alloc::string::String, + #[prost(bytes="vec", tag="2")] + pub session_data: ::prost::alloc::vec::Vec, + #[prost(string, tag="3")] + pub error: ::prost::alloc::string::String, +} #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum JobType { @@ -4374,7 +4603,7 @@ pub struct AgentDispatch { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct AgentDispatchState { - /// For dispatches of tyoe JT_ROOM, there will be at most 1 job. + /// For dispatches of tyoe JT_ROOM, there will be at most 1 job. /// For dispatches of type JT_PUBLISHER, there will be 1 per publisher. #[prost(message, repeated, tag="1")] pub jobs: ::prost::alloc::vec::Vec, @@ -5678,9 +5907,12 @@ pub struct SipDispatchRuleInfo { pub trunk_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, #[prost(bool, tag="4")] pub hide_phone_number: bool, - /// Dispatch Rule will only accept a call made to these numbers (if set). + /// Dispatch Rule will only accept a call made from these numbers (if set). #[prost(string, repeated, tag="7")] pub inbound_numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Dispatch Rule will only accept a call made to these numbers (if set). + #[prost(string, repeated, tag="13")] + pub numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Human-readable name for the Dispatch Rule. #[prost(string, tag="5")] pub name: ::prost::alloc::string::String, @@ -5700,7 +5932,7 @@ pub struct SipDispatchRuleInfo { pub room_config: ::core::option::Option, #[prost(bool, tag="11")] pub krisp_enabled: bool, - /// NEXT ID: 13 + /// NEXT ID: 14 #[prost(enumeration="SipMediaEncryption", tag="12")] pub media_encryption: i32, } @@ -5947,6 +6179,8 @@ pub struct SipCallInfo { pub call_context: ::prost::alloc::vec::Vec<::pbjson_types::Any>, #[prost(message, optional, tag="27")] pub provider_info: ::core::option::Option, + #[prost(string, tag="28")] + pub sip_call_id: ::prost::alloc::string::String, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -6494,7 +6728,7 @@ impl SipCallDirection { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DialWhatsAppCallRequest { - /// Required - The number of the business that is initiating the call + /// Required - The phone number id of the business that is initiating the call #[prost(string, tag="1")] pub whatsapp_phone_number_id: ::prost::alloc::string::String, /// Required - The number of the user that is supossed to receive the call @@ -6516,6 +6750,7 @@ pub struct DialWhatsAppCallRequest { #[prost(message, repeated, tag="6")] pub agents: ::prost::alloc::vec::Vec, /// Optional - Identity of the participant in LiveKit room + /// This is used for logging purposes, so it is advised to not put PII in this field. #[prost(string, tag="7")] pub participant_identity: ::prost::alloc::string::String, /// Optional - Name of the participant in LiveKit room @@ -6549,9 +6784,49 @@ pub struct DisconnectWhatsAppCallRequest { /// Required - Call ID sent by Meta #[prost(string, tag="1")] pub whatsapp_call_id: ::prost::alloc::string::String, - /// Required - The API key of the business that is disconnecting the call + /// The API key of the whatsapp business. + /// Required if the DisconnectReason is BUSINESS_INITIATED. + /// Optional for USER_INITIATED as no API call to WhatsApp is needed. #[prost(string, tag="2")] pub whatsapp_api_key: ::prost::alloc::string::String, + /// The reason for disconnecting the call + #[prost(enumeration="disconnect_whats_app_call_request::DisconnectReason", tag="3")] + pub disconnect_reason: i32, +} +/// Nested message and enum types in `DisconnectWhatsAppCallRequest`. +pub mod disconnect_whats_app_call_request { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] + #[repr(i32)] + pub enum DisconnectReason { + /// The call is being disconnected by the business + BusinessInitiated = 0, + /// The call is disconnected by the user. + /// This can be tracked as part of call terminate webhook + /// + /// Note that this webhook will also be sent when the call is disconnected by the business. + /// Calling the API twice in such cases will result in an error. + UserInitiated = 1, + } + impl DisconnectReason { + /// 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 { + DisconnectReason::BusinessInitiated => "BUSINESS_INITIATED", + DisconnectReason::UserInitiated => "USER_INITIATED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "BUSINESS_INITIATED" => Some(Self::BusinessInitiated), + "USER_INITIATED" => Some(Self::UserInitiated), + _ => None, + } + } + } } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -6575,7 +6850,7 @@ pub struct ConnectWhatsAppCallResponse { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct AcceptWhatsAppCallRequest { - /// Required - The number of the business that is conencting the call + /// Required - The phone number id of the business that is conencting the call #[prost(string, tag="1")] pub whatsapp_phone_number_id: ::prost::alloc::string::String, /// Required - The API key of the business that is connecting the call @@ -6601,6 +6876,7 @@ pub struct AcceptWhatsAppCallRequest { #[prost(message, repeated, tag="7")] pub agents: ::prost::alloc::vec::Vec, /// Optional - Identity of the participant in LiveKit room + /// This is used for logging purposes, so it is advised to not put PII in this field. #[prost(string, tag="8")] pub participant_identity: ::prost::alloc::string::String, /// Optional - Name of the participant in LiveKit room @@ -6674,6 +6950,7 @@ pub struct ConnectTwilioCallRequest { #[prost(message, repeated, tag="3")] pub agents: ::prost::alloc::vec::Vec, /// Optional identity of the participant in LiveKit room + /// This is used for logging purposes, so it is advised to not put PII in this field. #[prost(string, tag="4")] pub participant_identity: ::prost::alloc::string::String, /// Optional name of the participant in LiveKit room diff --git a/livekit-protocol/src/livekit.serde.rs b/livekit-protocol/src/livekit.serde.rs index ae66f2b6c..7739e401e 100644 --- a/livekit-protocol/src/livekit.serde.rs +++ b/livekit-protocol/src/livekit.serde.rs @@ -4364,6 +4364,9 @@ impl serde::Serialize for ConnectionSettings { if self.disable_ice_lite { len += 1; } + if self.auto_subscribe_data_track.is_some() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("livekit.ConnectionSettings", len)?; if self.auto_subscribe { struct_ser.serialize_field("autoSubscribe", &self.auto_subscribe)?; @@ -4377,6 +4380,9 @@ impl serde::Serialize for ConnectionSettings { if self.disable_ice_lite { struct_ser.serialize_field("disableIceLite", &self.disable_ice_lite)?; } + if let Some(v) = self.auto_subscribe_data_track.as_ref() { + struct_ser.serialize_field("autoSubscribeDataTrack", v)?; + } struct_ser.end() } } @@ -4395,6 +4401,8 @@ impl<'de> serde::Deserialize<'de> for ConnectionSettings { "subscriberAllowPause", "disable_ice_lite", "disableIceLite", + "auto_subscribe_data_track", + "autoSubscribeDataTrack", ]; #[allow(clippy::enum_variant_names)] @@ -4403,6 +4411,7 @@ impl<'de> serde::Deserialize<'de> for ConnectionSettings { AdaptiveStream, SubscriberAllowPause, DisableIceLite, + AutoSubscribeDataTrack, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -4429,6 +4438,7 @@ impl<'de> serde::Deserialize<'de> for ConnectionSettings { "adaptiveStream" | "adaptive_stream" => Ok(GeneratedField::AdaptiveStream), "subscriberAllowPause" | "subscriber_allow_pause" => Ok(GeneratedField::SubscriberAllowPause), "disableIceLite" | "disable_ice_lite" => Ok(GeneratedField::DisableIceLite), + "autoSubscribeDataTrack" | "auto_subscribe_data_track" => Ok(GeneratedField::AutoSubscribeDataTrack), _ => Ok(GeneratedField::__SkipField__), } } @@ -4452,6 +4462,7 @@ impl<'de> serde::Deserialize<'de> for ConnectionSettings { let mut adaptive_stream__ = None; let mut subscriber_allow_pause__ = None; let mut disable_ice_lite__ = None; + let mut auto_subscribe_data_track__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::AutoSubscribe => { @@ -4478,6 +4489,12 @@ impl<'de> serde::Deserialize<'de> for ConnectionSettings { } disable_ice_lite__ = Some(map_.next_value()?); } + GeneratedField::AutoSubscribeDataTrack => { + if auto_subscribe_data_track__.is_some() { + return Err(serde::de::Error::duplicate_field("autoSubscribeDataTrack")); + } + auto_subscribe_data_track__ = map_.next_value()?; + } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -4488,6 +4505,7 @@ impl<'de> serde::Deserialize<'de> for ConnectionSettings { adaptive_stream: adaptive_stream__.unwrap_or_default(), subscriber_allow_pause: subscriber_allow_pause__, disable_ice_lite: disable_ice_lite__.unwrap_or_default(), + auto_subscribe_data_track: auto_subscribe_data_track__, }) } } @@ -8157,120 +8175,78 @@ impl<'de> serde::Deserialize<'de> for data_stream::Trailer { deserializer.deserialize_struct("livekit.DataStream.Trailer", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DeleteAgentDispatchRequest { +impl serde::Serialize for DataTrackExtensionId { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.dispatch_id.is_empty() { - len += 1; - } - if !self.room.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("livekit.DeleteAgentDispatchRequest", len)?; - if !self.dispatch_id.is_empty() { - struct_ser.serialize_field("dispatchId", &self.dispatch_id)?; - } - if !self.room.is_empty() { - struct_ser.serialize_field("room", &self.room)?; - } - struct_ser.end() + let variant = match self { + Self::DteiInvalid => "DTEI_INVALID", + Self::DteiParticipantSid => "DTEI_PARTICIPANT_SID", + }; + serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for DeleteAgentDispatchRequest { +impl<'de> serde::Deserialize<'de> for DataTrackExtensionId { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "dispatch_id", - "dispatchId", - "room", + "DTEI_INVALID", + "DTEI_PARTICIPANT_SID", ]; - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - DispatchId, - Room, - __SkipField__, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; + struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DataTrackExtensionId; - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } + 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 { - "dispatchId" | "dispatch_id" => Ok(GeneratedField::DispatchId), - "room" => Ok(GeneratedField::Room), - _ => Ok(GeneratedField::__SkipField__), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) + 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) + }) } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DeleteAgentDispatchRequest; - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DeleteAgentDispatchRequest") + 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_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, { - let mut dispatch_id__ = None; - let mut room__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::DispatchId => { - if dispatch_id__.is_some() { - return Err(serde::de::Error::duplicate_field("dispatchId")); - } - dispatch_id__ = Some(map_.next_value()?); - } - GeneratedField::Room => { - if room__.is_some() { - return Err(serde::de::Error::duplicate_field("room")); - } - room__ = Some(map_.next_value()?); - } - GeneratedField::__SkipField__ => { - let _ = map_.next_value::()?; - } - } + match value { + "DTEI_INVALID" => Ok(DataTrackExtensionId::DteiInvalid), + "DTEI_PARTICIPANT_SID" => Ok(DataTrackExtensionId::DteiParticipantSid), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } - Ok(DeleteAgentDispatchRequest { - dispatch_id: dispatch_id__.unwrap_or_default(), - room: room__.unwrap_or_default(), - }) } } - deserializer.deserialize_struct("livekit.DeleteAgentDispatchRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for DeleteIngressRequest { +impl serde::Serialize for DataTrackExtensionParticipantSid { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8278,30 +8254,40 @@ impl serde::Serialize for DeleteIngressRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.ingress_id.is_empty() { + if self.id != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.DeleteIngressRequest", len)?; - if !self.ingress_id.is_empty() { - struct_ser.serialize_field("ingressId", &self.ingress_id)?; + if !self.participant_sid.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.DataTrackExtensionParticipantSid", len)?; + if self.id != 0 { + let v = DataTrackExtensionId::try_from(self.id) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.id)))?; + struct_ser.serialize_field("id", &v)?; + } + if !self.participant_sid.is_empty() { + struct_ser.serialize_field("participantSid", &self.participant_sid)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DeleteIngressRequest { +impl<'de> serde::Deserialize<'de> for DataTrackExtensionParticipantSid { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "ingress_id", - "ingressId", + "id", + "participant_sid", + "participantSid", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - IngressId, + Id, + ParticipantSid, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -8324,7 +8310,8 @@ impl<'de> serde::Deserialize<'de> for DeleteIngressRequest { E: serde::de::Error, { match value { - "ingressId" | "ingress_id" => Ok(GeneratedField::IngressId), + "id" => Ok(GeneratedField::Id), + "participantSid" | "participant_sid" => Ok(GeneratedField::ParticipantSid), _ => Ok(GeneratedField::__SkipField__), } } @@ -8334,39 +8321,47 @@ impl<'de> serde::Deserialize<'de> for DeleteIngressRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DeleteIngressRequest; + type Value = DataTrackExtensionParticipantSid; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DeleteIngressRequest") + formatter.write_str("struct livekit.DataTrackExtensionParticipantSid") } - 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 ingress_id__ = None; + let mut id__ = None; + let mut participant_sid__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::IngressId => { - if ingress_id__.is_some() { - return Err(serde::de::Error::duplicate_field("ingressId")); + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); } - ingress_id__ = Some(map_.next_value()?); + id__ = Some(map_.next_value::()? as i32); + } + GeneratedField::ParticipantSid => { + if participant_sid__.is_some() { + return Err(serde::de::Error::duplicate_field("participantSid")); + } + participant_sid__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(DeleteIngressRequest { - ingress_id: ingress_id__.unwrap_or_default(), + Ok(DataTrackExtensionParticipantSid { + id: id__.unwrap_or_default(), + participant_sid: participant_sid__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.DeleteIngressRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.DataTrackExtensionParticipantSid", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DeleteRoomRequest { +impl serde::Serialize for DataTrackInfo { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8374,116 +8369,56 @@ impl serde::Serialize for DeleteRoomRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.room.is_empty() { + if self.pub_handle != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.DeleteRoomRequest", len)?; - if !self.room.is_empty() { - struct_ser.serialize_field("room", &self.room)?; + if !self.sid.is_empty() { + len += 1; } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for DeleteRoomRequest { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "room", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Room, - __SkipField__, + if !self.name.is_empty() { + len += 1; } - 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), - _ => Ok(GeneratedField::__SkipField__), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } + if self.encryption != 0 { + len += 1; } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DeleteRoomRequest; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DeleteRoomRequest") - } - - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut room__ = 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::__SkipField__ => { - let _ = map_.next_value::()?; - } - } - } - Ok(DeleteRoomRequest { - room: room__.unwrap_or_default(), - }) - } + let mut struct_ser = serializer.serialize_struct("livekit.DataTrackInfo", len)?; + if self.pub_handle != 0 { + struct_ser.serialize_field("pubHandle", &self.pub_handle)?; + } + if !self.sid.is_empty() { + struct_ser.serialize_field("sid", &self.sid)?; + } + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if self.encryption != 0 { + let v = encryption::Type::try_from(self.encryption) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encryption)))?; + struct_ser.serialize_field("encryption", &v)?; } - deserializer.deserialize_struct("livekit.DeleteRoomRequest", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for DeleteRoomResponse { - #[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.DeleteRoomResponse", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DeleteRoomResponse { +impl<'de> serde::Deserialize<'de> for DataTrackInfo { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "pub_handle", + "pubHandle", + "sid", + "name", + "encryption", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + PubHandle, + Sid, + Name, + Encryption, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -8505,7 +8440,13 @@ impl<'de> serde::Deserialize<'de> for DeleteRoomResponse { where E: serde::de::Error, { - Ok(GeneratedField::__SkipField__) + match value { + "pubHandle" | "pub_handle" => Ok(GeneratedField::PubHandle), + "sid" => Ok(GeneratedField::Sid), + "name" => Ok(GeneratedField::Name), + "encryption" => Ok(GeneratedField::Encryption), + _ => Ok(GeneratedField::__SkipField__), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -8513,27 +8454,65 @@ impl<'de> serde::Deserialize<'de> for DeleteRoomResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DeleteRoomResponse; + type Value = DataTrackInfo; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DeleteRoomResponse") + formatter.write_str("struct livekit.DataTrackInfo") } - 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>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut pub_handle__ = None; + let mut sid__ = None; + let mut name__ = None; + let mut encryption__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::PubHandle => { + if pub_handle__.is_some() { + return Err(serde::de::Error::duplicate_field("pubHandle")); + } + pub_handle__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Sid => { + if sid__.is_some() { + return Err(serde::de::Error::duplicate_field("sid")); + } + sid__ = Some(map_.next_value()?); + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::Encryption => { + if encryption__.is_some() { + return Err(serde::de::Error::duplicate_field("encryption")); + } + encryption__ = Some(map_.next_value::()? as i32); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } } - Ok(DeleteRoomResponse { + Ok(DataTrackInfo { + pub_handle: pub_handle__.unwrap_or_default(), + sid: sid__.unwrap_or_default(), + name: name__.unwrap_or_default(), + encryption: encryption__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.DeleteRoomResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.DataTrackInfo", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DeleteSipDispatchRuleRequest { +impl serde::Serialize for DataTrackSubscriberHandles { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8541,30 +8520,30 @@ impl serde::Serialize for DeleteSipDispatchRuleRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.sip_dispatch_rule_id.is_empty() { + if !self.sub_handles.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.DeleteSIPDispatchRuleRequest", len)?; - if !self.sip_dispatch_rule_id.is_empty() { - struct_ser.serialize_field("sipDispatchRuleId", &self.sip_dispatch_rule_id)?; + let mut struct_ser = serializer.serialize_struct("livekit.DataTrackSubscriberHandles", len)?; + if !self.sub_handles.is_empty() { + struct_ser.serialize_field("subHandles", &self.sub_handles)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DeleteSipDispatchRuleRequest { +impl<'de> serde::Deserialize<'de> for DataTrackSubscriberHandles { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "sip_dispatch_rule_id", - "sipDispatchRuleId", + "sub_handles", + "subHandles", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - SipDispatchRuleId, + SubHandles, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -8587,7 +8566,7 @@ impl<'de> serde::Deserialize<'de> for DeleteSipDispatchRuleRequest { E: serde::de::Error, { match value { - "sipDispatchRuleId" | "sip_dispatch_rule_id" => Ok(GeneratedField::SipDispatchRuleId), + "subHandles" | "sub_handles" => Ok(GeneratedField::SubHandles), _ => Ok(GeneratedField::__SkipField__), } } @@ -8597,39 +8576,42 @@ impl<'de> serde::Deserialize<'de> for DeleteSipDispatchRuleRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DeleteSipDispatchRuleRequest; + type Value = DataTrackSubscriberHandles; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DeleteSIPDispatchRuleRequest") + formatter.write_str("struct livekit.DataTrackSubscriberHandles") } - 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_dispatch_rule_id__ = None; + let mut sub_handles__ = 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")); + GeneratedField::SubHandles => { + if sub_handles__.is_some() { + return Err(serde::de::Error::duplicate_field("subHandles")); } - sip_dispatch_rule_id__ = Some(map_.next_value()?); + sub_handles__ = Some( + map_.next_value::, _>>()? + .into_iter().map(|(k,v)| (k.0, v)).collect() + ); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(DeleteSipDispatchRuleRequest { - sip_dispatch_rule_id: sip_dispatch_rule_id__.unwrap_or_default(), + Ok(DataTrackSubscriberHandles { + sub_handles: sub_handles__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.DeleteSIPDispatchRuleRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.DataTrackSubscriberHandles", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DeleteSipTrunkRequest { +impl serde::Serialize for data_track_subscriber_handles::PublishedDataTrack { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8637,30 +8619,48 @@ impl serde::Serialize for DeleteSipTrunkRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.sip_trunk_id.is_empty() { + if !self.publisher_identity.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.DeleteSIPTrunkRequest", len)?; - if !self.sip_trunk_id.is_empty() { - struct_ser.serialize_field("sipTrunkId", &self.sip_trunk_id)?; + if !self.publisher_sid.is_empty() { + len += 1; + } + if !self.track_sid.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.DataTrackSubscriberHandles.PublishedDataTrack", len)?; + if !self.publisher_identity.is_empty() { + struct_ser.serialize_field("publisherIdentity", &self.publisher_identity)?; + } + if !self.publisher_sid.is_empty() { + struct_ser.serialize_field("publisherSid", &self.publisher_sid)?; + } + if !self.track_sid.is_empty() { + struct_ser.serialize_field("trackSid", &self.track_sid)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DeleteSipTrunkRequest { +impl<'de> serde::Deserialize<'de> for data_track_subscriber_handles::PublishedDataTrack { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "sip_trunk_id", - "sipTrunkId", + "publisher_identity", + "publisherIdentity", + "publisher_sid", + "publisherSid", + "track_sid", + "trackSid", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - SipTrunkId, + PublisherIdentity, + PublisherSid, + TrackSid, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -8683,7 +8683,9 @@ impl<'de> serde::Deserialize<'de> for DeleteSipTrunkRequest { E: serde::de::Error, { match value { - "sipTrunkId" | "sip_trunk_id" => Ok(GeneratedField::SipTrunkId), + "publisherIdentity" | "publisher_identity" => Ok(GeneratedField::PublisherIdentity), + "publisherSid" | "publisher_sid" => Ok(GeneratedField::PublisherSid), + "trackSid" | "track_sid" => Ok(GeneratedField::TrackSid), _ => Ok(GeneratedField::__SkipField__), } } @@ -8693,39 +8695,55 @@ impl<'de> serde::Deserialize<'de> for DeleteSipTrunkRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DeleteSipTrunkRequest; + type Value = data_track_subscriber_handles::PublishedDataTrack; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DeleteSIPTrunkRequest") + formatter.write_str("struct livekit.DataTrackSubscriberHandles.PublishedDataTrack") } - 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 publisher_identity__ = None; + let mut publisher_sid__ = None; + let mut track_sid__ = 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::PublisherIdentity => { + if publisher_identity__.is_some() { + return Err(serde::de::Error::duplicate_field("publisherIdentity")); } - sip_trunk_id__ = Some(map_.next_value()?); + publisher_identity__ = Some(map_.next_value()?); + } + GeneratedField::PublisherSid => { + if publisher_sid__.is_some() { + return Err(serde::de::Error::duplicate_field("publisherSid")); + } + publisher_sid__ = Some(map_.next_value()?); + } + GeneratedField::TrackSid => { + if track_sid__.is_some() { + return Err(serde::de::Error::duplicate_field("trackSid")); + } + track_sid__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(DeleteSipTrunkRequest { - sip_trunk_id: sip_trunk_id__.unwrap_or_default(), + Ok(data_track_subscriber_handles::PublishedDataTrack { + publisher_identity: publisher_identity__.unwrap_or_default(), + publisher_sid: publisher_sid__.unwrap_or_default(), + track_sid: track_sid__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.DeleteSIPTrunkRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.DataTrackSubscriberHandles.PublishedDataTrack", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Destination { +impl serde::Serialize for DataTrackSubscriptionOptions { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8733,45 +8751,30 @@ impl serde::Serialize for Destination { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.city.is_empty() { - len += 1; - } - if !self.country.is_empty() { + if self.target_fps.is_some() { len += 1; } - if !self.region.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("livekit.Destination", len)?; - if !self.city.is_empty() { - struct_ser.serialize_field("city", &self.city)?; - } - if !self.country.is_empty() { - struct_ser.serialize_field("country", &self.country)?; - } - if !self.region.is_empty() { - struct_ser.serialize_field("region", &self.region)?; + let mut struct_ser = serializer.serialize_struct("livekit.DataTrackSubscriptionOptions", len)?; + if let Some(v) = self.target_fps.as_ref() { + struct_ser.serialize_field("targetFps", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Destination { +impl<'de> serde::Deserialize<'de> for DataTrackSubscriptionOptions { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "city", - "country", - "region", + "target_fps", + "targetFps", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - City, - Country, - Region, + TargetFps, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -8794,9 +8797,7 @@ impl<'de> serde::Deserialize<'de> for Destination { E: serde::de::Error, { match value { - "city" => Ok(GeneratedField::City), - "country" => Ok(GeneratedField::Country), - "region" => Ok(GeneratedField::Region), + "targetFps" | "target_fps" => Ok(GeneratedField::TargetFps), _ => Ok(GeneratedField::__SkipField__), } } @@ -8806,55 +8807,41 @@ impl<'de> serde::Deserialize<'de> for Destination { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Destination; + type Value = DataTrackSubscriptionOptions; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.Destination") + formatter.write_str("struct livekit.DataTrackSubscriptionOptions") } - 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 city__ = None; - let mut country__ = None; - let mut region__ = None; + let mut target_fps__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::City => { - if city__.is_some() { - return Err(serde::de::Error::duplicate_field("city")); - } - city__ = Some(map_.next_value()?); - } - GeneratedField::Country => { - if country__.is_some() { - return Err(serde::de::Error::duplicate_field("country")); - } - country__ = Some(map_.next_value()?); - } - GeneratedField::Region => { - if region__.is_some() { - return Err(serde::de::Error::duplicate_field("region")); + GeneratedField::TargetFps => { + if target_fps__.is_some() { + return Err(serde::de::Error::duplicate_field("targetFps")); } - region__ = Some(map_.next_value()?); + target_fps__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(Destination { - city: city__.unwrap_or_default(), - country: country__.unwrap_or_default(), - region: region__.unwrap_or_default(), + Ok(DataTrackSubscriptionOptions { + target_fps: target_fps__, }) } } - deserializer.deserialize_struct("livekit.Destination", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.DataTrackSubscriptionOptions", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DialWhatsAppCallRequest { +impl serde::Serialize for DeleteAgentDispatchRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8862,128 +8849,38 @@ impl serde::Serialize for DialWhatsAppCallRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.whatsapp_phone_number_id.is_empty() { - len += 1; - } - if !self.whatsapp_to_phone_number.is_empty() { - len += 1; - } - if !self.whatsapp_api_key.is_empty() { - len += 1; - } - if !self.whatsapp_cloud_api_version.is_empty() { - len += 1; - } - if !self.whatsapp_biz_opaque_callback_data.is_empty() { - len += 1; - } - if !self.room_name.is_empty() { - len += 1; - } - if !self.agents.is_empty() { - len += 1; - } - if !self.participant_identity.is_empty() { - len += 1; - } - if !self.participant_name.is_empty() { - len += 1; - } - if !self.participant_metadata.is_empty() { - len += 1; - } - if !self.participant_attributes.is_empty() { + if !self.dispatch_id.is_empty() { len += 1; } - if !self.destination_country.is_empty() { + if !self.room.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.DialWhatsAppCallRequest", len)?; - if !self.whatsapp_phone_number_id.is_empty() { - struct_ser.serialize_field("whatsappPhoneNumberId", &self.whatsapp_phone_number_id)?; - } - if !self.whatsapp_to_phone_number.is_empty() { - struct_ser.serialize_field("whatsappToPhoneNumber", &self.whatsapp_to_phone_number)?; - } - if !self.whatsapp_api_key.is_empty() { - struct_ser.serialize_field("whatsappApiKey", &self.whatsapp_api_key)?; - } - if !self.whatsapp_cloud_api_version.is_empty() { - struct_ser.serialize_field("whatsappCloudApiVersion", &self.whatsapp_cloud_api_version)?; - } - if !self.whatsapp_biz_opaque_callback_data.is_empty() { - struct_ser.serialize_field("whatsappBizOpaqueCallbackData", &self.whatsapp_biz_opaque_callback_data)?; - } - if !self.room_name.is_empty() { - struct_ser.serialize_field("roomName", &self.room_name)?; - } - if !self.agents.is_empty() { - struct_ser.serialize_field("agents", &self.agents)?; - } - if !self.participant_identity.is_empty() { - struct_ser.serialize_field("participantIdentity", &self.participant_identity)?; - } - if !self.participant_name.is_empty() { - struct_ser.serialize_field("participantName", &self.participant_name)?; - } - if !self.participant_metadata.is_empty() { - struct_ser.serialize_field("participantMetadata", &self.participant_metadata)?; - } - if !self.participant_attributes.is_empty() { - struct_ser.serialize_field("participantAttributes", &self.participant_attributes)?; + let mut struct_ser = serializer.serialize_struct("livekit.DeleteAgentDispatchRequest", len)?; + if !self.dispatch_id.is_empty() { + struct_ser.serialize_field("dispatchId", &self.dispatch_id)?; } - if !self.destination_country.is_empty() { - struct_ser.serialize_field("destinationCountry", &self.destination_country)?; + if !self.room.is_empty() { + struct_ser.serialize_field("room", &self.room)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DialWhatsAppCallRequest { +impl<'de> serde::Deserialize<'de> for DeleteAgentDispatchRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "whatsapp_phone_number_id", - "whatsappPhoneNumberId", - "whatsapp_to_phone_number", - "whatsappToPhoneNumber", - "whatsapp_api_key", - "whatsappApiKey", - "whatsapp_cloud_api_version", - "whatsappCloudApiVersion", - "whatsapp_biz_opaque_callback_data", - "whatsappBizOpaqueCallbackData", - "room_name", - "roomName", - "agents", - "participant_identity", - "participantIdentity", - "participant_name", - "participantName", - "participant_metadata", - "participantMetadata", - "participant_attributes", - "participantAttributes", - "destination_country", - "destinationCountry", + "dispatch_id", + "dispatchId", + "room", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WhatsappPhoneNumberId, - WhatsappToPhoneNumber, - WhatsappApiKey, - WhatsappCloudApiVersion, - WhatsappBizOpaqueCallbackData, - RoomName, - Agents, - ParticipantIdentity, - ParticipantName, - ParticipantMetadata, - ParticipantAttributes, - DestinationCountry, + DispatchId, + Room, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -9006,18 +8903,8 @@ impl<'de> serde::Deserialize<'de> for DialWhatsAppCallRequest { E: serde::de::Error, { match value { - "whatsappPhoneNumberId" | "whatsapp_phone_number_id" => Ok(GeneratedField::WhatsappPhoneNumberId), - "whatsappToPhoneNumber" | "whatsapp_to_phone_number" => Ok(GeneratedField::WhatsappToPhoneNumber), - "whatsappApiKey" | "whatsapp_api_key" => Ok(GeneratedField::WhatsappApiKey), - "whatsappCloudApiVersion" | "whatsapp_cloud_api_version" => Ok(GeneratedField::WhatsappCloudApiVersion), - "whatsappBizOpaqueCallbackData" | "whatsapp_biz_opaque_callback_data" => Ok(GeneratedField::WhatsappBizOpaqueCallbackData), - "roomName" | "room_name" => Ok(GeneratedField::RoomName), - "agents" => Ok(GeneratedField::Agents), - "participantIdentity" | "participant_identity" => Ok(GeneratedField::ParticipantIdentity), - "participantName" | "participant_name" => Ok(GeneratedField::ParticipantName), - "participantMetadata" | "participant_metadata" => Ok(GeneratedField::ParticipantMetadata), - "participantAttributes" | "participant_attributes" => Ok(GeneratedField::ParticipantAttributes), - "destinationCountry" | "destination_country" => Ok(GeneratedField::DestinationCountry), + "dispatchId" | "dispatch_id" => Ok(GeneratedField::DispatchId), + "room" => Ok(GeneratedField::Room), _ => Ok(GeneratedField::__SkipField__), } } @@ -9027,129 +8914,47 @@ impl<'de> serde::Deserialize<'de> for DialWhatsAppCallRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DialWhatsAppCallRequest; + type Value = DeleteAgentDispatchRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DialWhatsAppCallRequest") + formatter.write_str("struct livekit.DeleteAgentDispatchRequest") } - 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 whatsapp_phone_number_id__ = None; - let mut whatsapp_to_phone_number__ = None; - let mut whatsapp_api_key__ = None; - let mut whatsapp_cloud_api_version__ = None; - let mut whatsapp_biz_opaque_callback_data__ = None; - let mut room_name__ = None; - let mut agents__ = None; - let mut participant_identity__ = None; - let mut participant_name__ = None; - let mut participant_metadata__ = None; - let mut participant_attributes__ = None; - let mut destination_country__ = None; + let mut dispatch_id__ = None; + let mut room__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::WhatsappPhoneNumberId => { - if whatsapp_phone_number_id__.is_some() { - return Err(serde::de::Error::duplicate_field("whatsappPhoneNumberId")); - } - whatsapp_phone_number_id__ = Some(map_.next_value()?); - } - GeneratedField::WhatsappToPhoneNumber => { - if whatsapp_to_phone_number__.is_some() { - return Err(serde::de::Error::duplicate_field("whatsappToPhoneNumber")); - } - whatsapp_to_phone_number__ = Some(map_.next_value()?); - } - GeneratedField::WhatsappApiKey => { - if whatsapp_api_key__.is_some() { - return Err(serde::de::Error::duplicate_field("whatsappApiKey")); - } - whatsapp_api_key__ = Some(map_.next_value()?); - } - GeneratedField::WhatsappCloudApiVersion => { - if whatsapp_cloud_api_version__.is_some() { - return Err(serde::de::Error::duplicate_field("whatsappCloudApiVersion")); - } - whatsapp_cloud_api_version__ = Some(map_.next_value()?); - } - GeneratedField::WhatsappBizOpaqueCallbackData => { - if whatsapp_biz_opaque_callback_data__.is_some() { - return Err(serde::de::Error::duplicate_field("whatsappBizOpaqueCallbackData")); - } - whatsapp_biz_opaque_callback_data__ = Some(map_.next_value()?); - } - GeneratedField::RoomName => { - if room_name__.is_some() { - return Err(serde::de::Error::duplicate_field("roomName")); - } - room_name__ = Some(map_.next_value()?); - } - GeneratedField::Agents => { - if agents__.is_some() { - return Err(serde::de::Error::duplicate_field("agents")); - } - agents__ = Some(map_.next_value()?); - } - GeneratedField::ParticipantIdentity => { - if participant_identity__.is_some() { - return Err(serde::de::Error::duplicate_field("participantIdentity")); - } - participant_identity__ = Some(map_.next_value()?); - } - GeneratedField::ParticipantName => { - if participant_name__.is_some() { - return Err(serde::de::Error::duplicate_field("participantName")); - } - participant_name__ = Some(map_.next_value()?); - } - GeneratedField::ParticipantMetadata => { - if participant_metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("participantMetadata")); - } - participant_metadata__ = Some(map_.next_value()?); - } - GeneratedField::ParticipantAttributes => { - if participant_attributes__.is_some() { - return Err(serde::de::Error::duplicate_field("participantAttributes")); + GeneratedField::DispatchId => { + if dispatch_id__.is_some() { + return Err(serde::de::Error::duplicate_field("dispatchId")); } - participant_attributes__ = Some( - map_.next_value::>()? - ); + dispatch_id__ = Some(map_.next_value()?); } - GeneratedField::DestinationCountry => { - if destination_country__.is_some() { - return Err(serde::de::Error::duplicate_field("destinationCountry")); + GeneratedField::Room => { + if room__.is_some() { + return Err(serde::de::Error::duplicate_field("room")); } - destination_country__ = Some(map_.next_value()?); + room__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(DialWhatsAppCallRequest { - whatsapp_phone_number_id: whatsapp_phone_number_id__.unwrap_or_default(), - whatsapp_to_phone_number: whatsapp_to_phone_number__.unwrap_or_default(), - whatsapp_api_key: whatsapp_api_key__.unwrap_or_default(), - whatsapp_cloud_api_version: whatsapp_cloud_api_version__.unwrap_or_default(), - whatsapp_biz_opaque_callback_data: whatsapp_biz_opaque_callback_data__.unwrap_or_default(), - room_name: room_name__.unwrap_or_default(), - agents: agents__.unwrap_or_default(), - participant_identity: participant_identity__.unwrap_or_default(), - participant_name: participant_name__.unwrap_or_default(), - participant_metadata: participant_metadata__.unwrap_or_default(), - participant_attributes: participant_attributes__.unwrap_or_default(), - destination_country: destination_country__.unwrap_or_default(), + Ok(DeleteAgentDispatchRequest { + dispatch_id: dispatch_id__.unwrap_or_default(), + room: room__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.DialWhatsAppCallRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.DeleteAgentDispatchRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DialWhatsAppCallResponse { +impl serde::Serialize for DeleteIngressRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9157,39 +8962,30 @@ impl serde::Serialize for DialWhatsAppCallResponse { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.whatsapp_call_id.is_empty() { - len += 1; - } - if !self.room_name.is_empty() { + if !self.ingress_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.DialWhatsAppCallResponse", len)?; - if !self.whatsapp_call_id.is_empty() { - struct_ser.serialize_field("whatsappCallId", &self.whatsapp_call_id)?; - } - if !self.room_name.is_empty() { - struct_ser.serialize_field("roomName", &self.room_name)?; + let mut struct_ser = serializer.serialize_struct("livekit.DeleteIngressRequest", len)?; + if !self.ingress_id.is_empty() { + struct_ser.serialize_field("ingressId", &self.ingress_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DialWhatsAppCallResponse { +impl<'de> serde::Deserialize<'de> for DeleteIngressRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "whatsapp_call_id", - "whatsappCallId", - "room_name", - "roomName", + "ingress_id", + "ingressId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WhatsappCallId, - RoomName, + IngressId, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -9212,8 +9008,7 @@ impl<'de> serde::Deserialize<'de> for DialWhatsAppCallResponse { E: serde::de::Error, { match value { - "whatsappCallId" | "whatsapp_call_id" => Ok(GeneratedField::WhatsappCallId), - "roomName" | "room_name" => Ok(GeneratedField::RoomName), + "ingressId" | "ingress_id" => Ok(GeneratedField::IngressId), _ => Ok(GeneratedField::__SkipField__), } } @@ -9223,47 +9018,39 @@ impl<'de> serde::Deserialize<'de> for DialWhatsAppCallResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DialWhatsAppCallResponse; + type Value = DeleteIngressRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DialWhatsAppCallResponse") + formatter.write_str("struct livekit.DeleteIngressRequest") } - 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 whatsapp_call_id__ = None; - let mut room_name__ = None; + let mut ingress_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::WhatsappCallId => { - if whatsapp_call_id__.is_some() { - return Err(serde::de::Error::duplicate_field("whatsappCallId")); - } - whatsapp_call_id__ = Some(map_.next_value()?); - } - GeneratedField::RoomName => { - if room_name__.is_some() { - return Err(serde::de::Error::duplicate_field("roomName")); + GeneratedField::IngressId => { + if ingress_id__.is_some() { + return Err(serde::de::Error::duplicate_field("ingressId")); } - room_name__ = Some(map_.next_value()?); + ingress_id__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(DialWhatsAppCallResponse { - whatsapp_call_id: whatsapp_call_id__.unwrap_or_default(), - room_name: room_name__.unwrap_or_default(), + Ok(DeleteIngressRequest { + ingress_id: ingress_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.DialWhatsAppCallResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.DeleteIngressRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DirectFileOutput { +impl serde::Serialize for DeleteRoomRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9271,65 +9058,29 @@ impl serde::Serialize for DirectFileOutput { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.filepath.is_empty() { - len += 1; - } - if self.disable_manifest { - len += 1; - } - if self.output.is_some() { + if !self.room.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.DirectFileOutput", len)?; - if !self.filepath.is_empty() { - struct_ser.serialize_field("filepath", &self.filepath)?; - } - if self.disable_manifest { - struct_ser.serialize_field("disableManifest", &self.disable_manifest)?; - } - if let Some(v) = self.output.as_ref() { - match v { - direct_file_output::Output::S3(v) => { - struct_ser.serialize_field("s3", v)?; - } - direct_file_output::Output::Gcp(v) => { - struct_ser.serialize_field("gcp", v)?; - } - direct_file_output::Output::Azure(v) => { - struct_ser.serialize_field("azure", v)?; - } - direct_file_output::Output::AliOss(v) => { - struct_ser.serialize_field("aliOSS", v)?; - } - } + let mut struct_ser = serializer.serialize_struct("livekit.DeleteRoomRequest", len)?; + if !self.room.is_empty() { + struct_ser.serialize_field("room", &self.room)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DirectFileOutput { +impl<'de> serde::Deserialize<'de> for DeleteRoomRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "filepath", - "disable_manifest", - "disableManifest", - "s3", - "gcp", - "azure", - "aliOSS", + "room", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Filepath, - DisableManifest, - S3, - Gcp, - Azure, - AliOss, + Room, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -9352,12 +9103,7 @@ impl<'de> serde::Deserialize<'de> for DirectFileOutput { E: serde::de::Error, { match value { - "filepath" => Ok(GeneratedField::Filepath), - "disableManifest" | "disable_manifest" => Ok(GeneratedField::DisableManifest), - "s3" => Ok(GeneratedField::S3), - "gcp" => Ok(GeneratedField::Gcp), - "azure" => Ok(GeneratedField::Azure), - "aliOSS" => Ok(GeneratedField::AliOss), + "room" => Ok(GeneratedField::Room), _ => Ok(GeneratedField::__SkipField__), } } @@ -9367,115 +9113,61 @@ impl<'de> serde::Deserialize<'de> for DirectFileOutput { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DirectFileOutput; + type Value = DeleteRoomRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DirectFileOutput") + formatter.write_str("struct livekit.DeleteRoomRequest") } - 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 filepath__ = None; - let mut disable_manifest__ = None; - let mut output__ = None; + let mut room__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Filepath => { - if filepath__.is_some() { - return Err(serde::de::Error::duplicate_field("filepath")); - } - filepath__ = Some(map_.next_value()?); - } - GeneratedField::DisableManifest => { - if disable_manifest__.is_some() { - return Err(serde::de::Error::duplicate_field("disableManifest")); - } - disable_manifest__ = Some(map_.next_value()?); - } - GeneratedField::S3 => { - if output__.is_some() { - return Err(serde::de::Error::duplicate_field("s3")); - } - output__ = map_.next_value::<::std::option::Option<_>>()?.map(direct_file_output::Output::S3) -; - } - GeneratedField::Gcp => { - if output__.is_some() { - return Err(serde::de::Error::duplicate_field("gcp")); - } - output__ = map_.next_value::<::std::option::Option<_>>()?.map(direct_file_output::Output::Gcp) -; - } - GeneratedField::Azure => { - if output__.is_some() { - return Err(serde::de::Error::duplicate_field("azure")); - } - output__ = map_.next_value::<::std::option::Option<_>>()?.map(direct_file_output::Output::Azure) -; - } - GeneratedField::AliOss => { - if output__.is_some() { - return Err(serde::de::Error::duplicate_field("aliOSS")); + GeneratedField::Room => { + if room__.is_some() { + return Err(serde::de::Error::duplicate_field("room")); } - output__ = map_.next_value::<::std::option::Option<_>>()?.map(direct_file_output::Output::AliOss) -; + room__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(DirectFileOutput { - filepath: filepath__.unwrap_or_default(), - disable_manifest: disable_manifest__.unwrap_or_default(), - output: output__, + Ok(DeleteRoomRequest { + room: room__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.DirectFileOutput", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.DeleteRoomRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DisabledCodecs { +impl serde::Serialize for DeleteRoomResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.codecs.is_empty() { - len += 1; - } - if !self.publish.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("livekit.DisabledCodecs", len)?; - if !self.codecs.is_empty() { - struct_ser.serialize_field("codecs", &self.codecs)?; - } - if !self.publish.is_empty() { - struct_ser.serialize_field("publish", &self.publish)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("livekit.DeleteRoomResponse", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DisabledCodecs { +impl<'de> serde::Deserialize<'de> for DeleteRoomResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "codecs", - "publish", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Codecs, - Publish, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -9497,11 +9189,7 @@ impl<'de> serde::Deserialize<'de> for DisabledCodecs { where E: serde::de::Error, { - match value { - "codecs" => Ok(GeneratedField::Codecs), - "publish" => Ok(GeneratedField::Publish), - _ => Ok(GeneratedField::__SkipField__), - } + Ok(GeneratedField::__SkipField__) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -9509,160 +9197,123 @@ impl<'de> serde::Deserialize<'de> for DisabledCodecs { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DisabledCodecs; + type Value = DeleteRoomResponse; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DisabledCodecs") + formatter.write_str("struct livekit.DeleteRoomResponse") } - 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 codecs__ = None; - let mut publish__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Codecs => { - if codecs__.is_some() { - return Err(serde::de::Error::duplicate_field("codecs")); - } - codecs__ = Some(map_.next_value()?); - } - GeneratedField::Publish => { - if publish__.is_some() { - return Err(serde::de::Error::duplicate_field("publish")); - } - publish__ = Some(map_.next_value()?); - } - GeneratedField::__SkipField__ => { - let _ = map_.next_value::()?; - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(DisabledCodecs { - codecs: codecs__.unwrap_or_default(), - publish: publish__.unwrap_or_default(), + Ok(DeleteRoomResponse { }) } } - deserializer.deserialize_struct("livekit.DisabledCodecs", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.DeleteRoomResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DisconnectReason { +impl serde::Serialize for DeleteSipDispatchRuleRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::UnknownReason => "UNKNOWN_REASON", - Self::ClientInitiated => "CLIENT_INITIATED", - Self::DuplicateIdentity => "DUPLICATE_IDENTITY", - Self::ServerShutdown => "SERVER_SHUTDOWN", - Self::ParticipantRemoved => "PARTICIPANT_REMOVED", - Self::RoomDeleted => "ROOM_DELETED", - Self::StateMismatch => "STATE_MISMATCH", - Self::JoinFailure => "JOIN_FAILURE", - Self::Migration => "MIGRATION", - Self::SignalClose => "SIGNAL_CLOSE", - Self::RoomClosed => "ROOM_CLOSED", - Self::UserUnavailable => "USER_UNAVAILABLE", - Self::UserRejected => "USER_REJECTED", - Self::SipTrunkFailure => "SIP_TRUNK_FAILURE", - Self::ConnectionTimeout => "CONNECTION_TIMEOUT", - Self::MediaFailure => "MEDIA_FAILURE", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.sip_dispatch_rule_id.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.DeleteSIPDispatchRuleRequest", len)?; + if !self.sip_dispatch_rule_id.is_empty() { + struct_ser.serialize_field("sipDispatchRuleId", &self.sip_dispatch_rule_id)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DisconnectReason { +impl<'de> serde::Deserialize<'de> for DeleteSipDispatchRuleRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "UNKNOWN_REASON", - "CLIENT_INITIATED", - "DUPLICATE_IDENTITY", - "SERVER_SHUTDOWN", - "PARTICIPANT_REMOVED", - "ROOM_DELETED", - "STATE_MISMATCH", - "JOIN_FAILURE", - "MIGRATION", - "SIGNAL_CLOSE", - "ROOM_CLOSED", - "USER_UNAVAILABLE", - "USER_REJECTED", - "SIP_TRUNK_FAILURE", - "CONNECTION_TIMEOUT", - "MEDIA_FAILURE", + "sip_dispatch_rule_id", + "sipDispatchRuleId", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SipDispatchRuleId, + __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 = DisconnectReason; + 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) - } + 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) - }) + #[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), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DeleteSipDispatchRuleRequest; - 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 expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.DeleteSIPDispatchRuleRequest") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "UNKNOWN_REASON" => Ok(DisconnectReason::UnknownReason), - "CLIENT_INITIATED" => Ok(DisconnectReason::ClientInitiated), - "DUPLICATE_IDENTITY" => Ok(DisconnectReason::DuplicateIdentity), - "SERVER_SHUTDOWN" => Ok(DisconnectReason::ServerShutdown), - "PARTICIPANT_REMOVED" => Ok(DisconnectReason::ParticipantRemoved), - "ROOM_DELETED" => Ok(DisconnectReason::RoomDeleted), - "STATE_MISMATCH" => Ok(DisconnectReason::StateMismatch), - "JOIN_FAILURE" => Ok(DisconnectReason::JoinFailure), - "MIGRATION" => Ok(DisconnectReason::Migration), - "SIGNAL_CLOSE" => Ok(DisconnectReason::SignalClose), - "ROOM_CLOSED" => Ok(DisconnectReason::RoomClosed), - "USER_UNAVAILABLE" => Ok(DisconnectReason::UserUnavailable), - "USER_REJECTED" => Ok(DisconnectReason::UserRejected), - "SIP_TRUNK_FAILURE" => Ok(DisconnectReason::SipTrunkFailure), - "CONNECTION_TIMEOUT" => Ok(DisconnectReason::ConnectionTimeout), - "MEDIA_FAILURE" => Ok(DisconnectReason::MediaFailure), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut sip_dispatch_rule_id__ = 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::__SkipField__ => { + let _ = map_.next_value::()?; + } + } } + Ok(DeleteSipDispatchRuleRequest { + sip_dispatch_rule_id: sip_dispatch_rule_id__.unwrap_or_default(), + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("livekit.DeleteSIPDispatchRuleRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DisconnectWhatsAppCallRequest { +impl serde::Serialize for DeleteSipTrunkRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9670,39 +9321,30 @@ impl serde::Serialize for DisconnectWhatsAppCallRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.whatsapp_call_id.is_empty() { - len += 1; - } - if !self.whatsapp_api_key.is_empty() { + if !self.sip_trunk_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.DisconnectWhatsAppCallRequest", len)?; - if !self.whatsapp_call_id.is_empty() { - struct_ser.serialize_field("whatsappCallId", &self.whatsapp_call_id)?; - } - if !self.whatsapp_api_key.is_empty() { - struct_ser.serialize_field("whatsappApiKey", &self.whatsapp_api_key)?; + let mut struct_ser = serializer.serialize_struct("livekit.DeleteSIPTrunkRequest", 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 DisconnectWhatsAppCallRequest { +impl<'de> serde::Deserialize<'de> for DeleteSipTrunkRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "whatsapp_call_id", - "whatsappCallId", - "whatsapp_api_key", - "whatsappApiKey", + "sip_trunk_id", + "sipTrunkId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WhatsappCallId, - WhatsappApiKey, + SipTrunkId, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -9725,8 +9367,7 @@ impl<'de> serde::Deserialize<'de> for DisconnectWhatsAppCallRequest { E: serde::de::Error, { match value { - "whatsappCallId" | "whatsapp_call_id" => Ok(GeneratedField::WhatsappCallId), - "whatsappApiKey" | "whatsapp_api_key" => Ok(GeneratedField::WhatsappApiKey), + "sipTrunkId" | "sip_trunk_id" => Ok(GeneratedField::SipTrunkId), _ => Ok(GeneratedField::__SkipField__), } } @@ -9736,69 +9377,85 @@ impl<'de> serde::Deserialize<'de> for DisconnectWhatsAppCallRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DisconnectWhatsAppCallRequest; + type Value = DeleteSipTrunkRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DisconnectWhatsAppCallRequest") + formatter.write_str("struct livekit.DeleteSIPTrunkRequest") } - 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 whatsapp_call_id__ = None; - let mut whatsapp_api_key__ = None; + let mut sip_trunk_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::WhatsappCallId => { - if whatsapp_call_id__.is_some() { - return Err(serde::de::Error::duplicate_field("whatsappCallId")); - } - whatsapp_call_id__ = Some(map_.next_value()?); - } - GeneratedField::WhatsappApiKey => { - if whatsapp_api_key__.is_some() { - return Err(serde::de::Error::duplicate_field("whatsappApiKey")); + GeneratedField::SipTrunkId => { + if sip_trunk_id__.is_some() { + return Err(serde::de::Error::duplicate_field("sipTrunkId")); } - whatsapp_api_key__ = Some(map_.next_value()?); + sip_trunk_id__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(DisconnectWhatsAppCallRequest { - whatsapp_call_id: whatsapp_call_id__.unwrap_or_default(), - whatsapp_api_key: whatsapp_api_key__.unwrap_or_default(), + Ok(DeleteSipTrunkRequest { + sip_trunk_id: sip_trunk_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.DisconnectWhatsAppCallRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.DeleteSIPTrunkRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DisconnectWhatsAppCallResponse { +impl serde::Serialize for Destination { #[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.DisconnectWhatsAppCallResponse", len)?; + let mut len = 0; + if !self.city.is_empty() { + len += 1; + } + if !self.country.is_empty() { + len += 1; + } + if !self.region.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.Destination", len)?; + if !self.city.is_empty() { + struct_ser.serialize_field("city", &self.city)?; + } + if !self.country.is_empty() { + struct_ser.serialize_field("country", &self.country)?; + } + if !self.region.is_empty() { + struct_ser.serialize_field("region", &self.region)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DisconnectWhatsAppCallResponse { +impl<'de> serde::Deserialize<'de> for Destination { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "city", + "country", + "region", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + City, + Country, + Region, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -9820,7 +9477,12 @@ impl<'de> serde::Deserialize<'de> for DisconnectWhatsAppCallResponse { where E: serde::de::Error, { - Ok(GeneratedField::__SkipField__) + match value { + "city" => Ok(GeneratedField::City), + "country" => Ok(GeneratedField::Country), + "region" => Ok(GeneratedField::Region), + _ => Ok(GeneratedField::__SkipField__), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -9828,27 +9490,55 @@ impl<'de> serde::Deserialize<'de> for DisconnectWhatsAppCallResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DisconnectWhatsAppCallResponse; + type Value = Destination; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.DisconnectWhatsAppCallResponse") + formatter.write_str("struct livekit.Destination") } - 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>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut city__ = None; + let mut country__ = None; + let mut region__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::City => { + if city__.is_some() { + return Err(serde::de::Error::duplicate_field("city")); + } + city__ = Some(map_.next_value()?); + } + GeneratedField::Country => { + if country__.is_some() { + return Err(serde::de::Error::duplicate_field("country")); + } + country__ = Some(map_.next_value()?); + } + GeneratedField::Region => { + if region__.is_some() { + return Err(serde::de::Error::duplicate_field("region")); + } + region__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } } - Ok(DisconnectWhatsAppCallResponse { + Ok(Destination { + city: city__.unwrap_or_default(), + country: country__.unwrap_or_default(), + region: region__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.DisconnectWhatsAppCallResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.Destination", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for EgressInfo { +impl serde::Serialize for DialWhatsAppCallRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9856,64 +9546,1149 @@ impl serde::Serialize for EgressInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.egress_id.is_empty() { + if !self.whatsapp_phone_number_id.is_empty() { len += 1; } - if !self.room_id.is_empty() { + if !self.whatsapp_to_phone_number.is_empty() { len += 1; } - if !self.room_name.is_empty() { + if !self.whatsapp_api_key.is_empty() { len += 1; } - if self.source_type != 0 { + if !self.whatsapp_cloud_api_version.is_empty() { len += 1; } - if self.status != 0 { + if !self.whatsapp_biz_opaque_callback_data.is_empty() { len += 1; } - if self.started_at != 0 { + if !self.room_name.is_empty() { len += 1; } - if self.ended_at != 0 { + if !self.agents.is_empty() { len += 1; } - if self.updated_at != 0 { + if !self.participant_identity.is_empty() { len += 1; } - if !self.details.is_empty() { + if !self.participant_name.is_empty() { len += 1; } - if !self.error.is_empty() { + if !self.participant_metadata.is_empty() { len += 1; } - if self.error_code != 0 { + if !self.participant_attributes.is_empty() { len += 1; } - if !self.stream_results.is_empty() { + if !self.destination_country.is_empty() { len += 1; } - if !self.file_results.is_empty() { - len += 1; + let mut struct_ser = serializer.serialize_struct("livekit.DialWhatsAppCallRequest", len)?; + if !self.whatsapp_phone_number_id.is_empty() { + struct_ser.serialize_field("whatsappPhoneNumberId", &self.whatsapp_phone_number_id)?; } - if !self.segment_results.is_empty() { - len += 1; + if !self.whatsapp_to_phone_number.is_empty() { + struct_ser.serialize_field("whatsappToPhoneNumber", &self.whatsapp_to_phone_number)?; } - if !self.image_results.is_empty() { - len += 1; + if !self.whatsapp_api_key.is_empty() { + struct_ser.serialize_field("whatsappApiKey", &self.whatsapp_api_key)?; } - if !self.manifest_location.is_empty() { - len += 1; + if !self.whatsapp_cloud_api_version.is_empty() { + struct_ser.serialize_field("whatsappCloudApiVersion", &self.whatsapp_cloud_api_version)?; } - if self.backup_storage_used { - len += 1; + if !self.whatsapp_biz_opaque_callback_data.is_empty() { + struct_ser.serialize_field("whatsappBizOpaqueCallbackData", &self.whatsapp_biz_opaque_callback_data)?; } - if self.request.is_some() { - len += 1; + if !self.room_name.is_empty() { + struct_ser.serialize_field("roomName", &self.room_name)?; } - if self.result.is_some() { - len += 1; + if !self.agents.is_empty() { + struct_ser.serialize_field("agents", &self.agents)?; } - let mut struct_ser = serializer.serialize_struct("livekit.EgressInfo", len)?; + if !self.participant_identity.is_empty() { + struct_ser.serialize_field("participantIdentity", &self.participant_identity)?; + } + if !self.participant_name.is_empty() { + struct_ser.serialize_field("participantName", &self.participant_name)?; + } + if !self.participant_metadata.is_empty() { + struct_ser.serialize_field("participantMetadata", &self.participant_metadata)?; + } + if !self.participant_attributes.is_empty() { + struct_ser.serialize_field("participantAttributes", &self.participant_attributes)?; + } + if !self.destination_country.is_empty() { + struct_ser.serialize_field("destinationCountry", &self.destination_country)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DialWhatsAppCallRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "whatsapp_phone_number_id", + "whatsappPhoneNumberId", + "whatsapp_to_phone_number", + "whatsappToPhoneNumber", + "whatsapp_api_key", + "whatsappApiKey", + "whatsapp_cloud_api_version", + "whatsappCloudApiVersion", + "whatsapp_biz_opaque_callback_data", + "whatsappBizOpaqueCallbackData", + "room_name", + "roomName", + "agents", + "participant_identity", + "participantIdentity", + "participant_name", + "participantName", + "participant_metadata", + "participantMetadata", + "participant_attributes", + "participantAttributes", + "destination_country", + "destinationCountry", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WhatsappPhoneNumberId, + WhatsappToPhoneNumber, + WhatsappApiKey, + WhatsappCloudApiVersion, + WhatsappBizOpaqueCallbackData, + RoomName, + Agents, + ParticipantIdentity, + ParticipantName, + ParticipantMetadata, + ParticipantAttributes, + DestinationCountry, + __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 { + "whatsappPhoneNumberId" | "whatsapp_phone_number_id" => Ok(GeneratedField::WhatsappPhoneNumberId), + "whatsappToPhoneNumber" | "whatsapp_to_phone_number" => Ok(GeneratedField::WhatsappToPhoneNumber), + "whatsappApiKey" | "whatsapp_api_key" => Ok(GeneratedField::WhatsappApiKey), + "whatsappCloudApiVersion" | "whatsapp_cloud_api_version" => Ok(GeneratedField::WhatsappCloudApiVersion), + "whatsappBizOpaqueCallbackData" | "whatsapp_biz_opaque_callback_data" => Ok(GeneratedField::WhatsappBizOpaqueCallbackData), + "roomName" | "room_name" => Ok(GeneratedField::RoomName), + "agents" => Ok(GeneratedField::Agents), + "participantIdentity" | "participant_identity" => Ok(GeneratedField::ParticipantIdentity), + "participantName" | "participant_name" => Ok(GeneratedField::ParticipantName), + "participantMetadata" | "participant_metadata" => Ok(GeneratedField::ParticipantMetadata), + "participantAttributes" | "participant_attributes" => Ok(GeneratedField::ParticipantAttributes), + "destinationCountry" | "destination_country" => Ok(GeneratedField::DestinationCountry), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DialWhatsAppCallRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.DialWhatsAppCallRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut whatsapp_phone_number_id__ = None; + let mut whatsapp_to_phone_number__ = None; + let mut whatsapp_api_key__ = None; + let mut whatsapp_cloud_api_version__ = None; + let mut whatsapp_biz_opaque_callback_data__ = None; + let mut room_name__ = None; + let mut agents__ = None; + let mut participant_identity__ = None; + let mut participant_name__ = None; + let mut participant_metadata__ = None; + let mut participant_attributes__ = None; + let mut destination_country__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::WhatsappPhoneNumberId => { + if whatsapp_phone_number_id__.is_some() { + return Err(serde::de::Error::duplicate_field("whatsappPhoneNumberId")); + } + whatsapp_phone_number_id__ = Some(map_.next_value()?); + } + GeneratedField::WhatsappToPhoneNumber => { + if whatsapp_to_phone_number__.is_some() { + return Err(serde::de::Error::duplicate_field("whatsappToPhoneNumber")); + } + whatsapp_to_phone_number__ = Some(map_.next_value()?); + } + GeneratedField::WhatsappApiKey => { + if whatsapp_api_key__.is_some() { + return Err(serde::de::Error::duplicate_field("whatsappApiKey")); + } + whatsapp_api_key__ = Some(map_.next_value()?); + } + GeneratedField::WhatsappCloudApiVersion => { + if whatsapp_cloud_api_version__.is_some() { + return Err(serde::de::Error::duplicate_field("whatsappCloudApiVersion")); + } + whatsapp_cloud_api_version__ = Some(map_.next_value()?); + } + GeneratedField::WhatsappBizOpaqueCallbackData => { + if whatsapp_biz_opaque_callback_data__.is_some() { + return Err(serde::de::Error::duplicate_field("whatsappBizOpaqueCallbackData")); + } + whatsapp_biz_opaque_callback_data__ = Some(map_.next_value()?); + } + GeneratedField::RoomName => { + if room_name__.is_some() { + return Err(serde::de::Error::duplicate_field("roomName")); + } + room_name__ = Some(map_.next_value()?); + } + GeneratedField::Agents => { + if agents__.is_some() { + return Err(serde::de::Error::duplicate_field("agents")); + } + agents__ = Some(map_.next_value()?); + } + GeneratedField::ParticipantIdentity => { + if participant_identity__.is_some() { + return Err(serde::de::Error::duplicate_field("participantIdentity")); + } + participant_identity__ = Some(map_.next_value()?); + } + GeneratedField::ParticipantName => { + if participant_name__.is_some() { + return Err(serde::de::Error::duplicate_field("participantName")); + } + participant_name__ = Some(map_.next_value()?); + } + GeneratedField::ParticipantMetadata => { + if participant_metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("participantMetadata")); + } + participant_metadata__ = Some(map_.next_value()?); + } + GeneratedField::ParticipantAttributes => { + if participant_attributes__.is_some() { + return Err(serde::de::Error::duplicate_field("participantAttributes")); + } + participant_attributes__ = Some( + map_.next_value::>()? + ); + } + GeneratedField::DestinationCountry => { + if destination_country__.is_some() { + return Err(serde::de::Error::duplicate_field("destinationCountry")); + } + destination_country__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(DialWhatsAppCallRequest { + whatsapp_phone_number_id: whatsapp_phone_number_id__.unwrap_or_default(), + whatsapp_to_phone_number: whatsapp_to_phone_number__.unwrap_or_default(), + whatsapp_api_key: whatsapp_api_key__.unwrap_or_default(), + whatsapp_cloud_api_version: whatsapp_cloud_api_version__.unwrap_or_default(), + whatsapp_biz_opaque_callback_data: whatsapp_biz_opaque_callback_data__.unwrap_or_default(), + room_name: room_name__.unwrap_or_default(), + agents: agents__.unwrap_or_default(), + participant_identity: participant_identity__.unwrap_or_default(), + participant_name: participant_name__.unwrap_or_default(), + participant_metadata: participant_metadata__.unwrap_or_default(), + participant_attributes: participant_attributes__.unwrap_or_default(), + destination_country: destination_country__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.DialWhatsAppCallRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DialWhatsAppCallResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.whatsapp_call_id.is_empty() { + len += 1; + } + if !self.room_name.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.DialWhatsAppCallResponse", len)?; + if !self.whatsapp_call_id.is_empty() { + struct_ser.serialize_field("whatsappCallId", &self.whatsapp_call_id)?; + } + if !self.room_name.is_empty() { + struct_ser.serialize_field("roomName", &self.room_name)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DialWhatsAppCallResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "whatsapp_call_id", + "whatsappCallId", + "room_name", + "roomName", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WhatsappCallId, + RoomName, + __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 { + "whatsappCallId" | "whatsapp_call_id" => Ok(GeneratedField::WhatsappCallId), + "roomName" | "room_name" => Ok(GeneratedField::RoomName), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DialWhatsAppCallResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.DialWhatsAppCallResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut whatsapp_call_id__ = None; + let mut room_name__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::WhatsappCallId => { + if whatsapp_call_id__.is_some() { + return Err(serde::de::Error::duplicate_field("whatsappCallId")); + } + whatsapp_call_id__ = Some(map_.next_value()?); + } + GeneratedField::RoomName => { + if room_name__.is_some() { + return Err(serde::de::Error::duplicate_field("roomName")); + } + room_name__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(DialWhatsAppCallResponse { + whatsapp_call_id: whatsapp_call_id__.unwrap_or_default(), + room_name: room_name__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.DialWhatsAppCallResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DirectFileOutput { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.filepath.is_empty() { + len += 1; + } + if self.disable_manifest { + len += 1; + } + if self.output.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.DirectFileOutput", len)?; + if !self.filepath.is_empty() { + struct_ser.serialize_field("filepath", &self.filepath)?; + } + if self.disable_manifest { + struct_ser.serialize_field("disableManifest", &self.disable_manifest)?; + } + if let Some(v) = self.output.as_ref() { + match v { + direct_file_output::Output::S3(v) => { + struct_ser.serialize_field("s3", v)?; + } + direct_file_output::Output::Gcp(v) => { + struct_ser.serialize_field("gcp", v)?; + } + direct_file_output::Output::Azure(v) => { + struct_ser.serialize_field("azure", v)?; + } + direct_file_output::Output::AliOss(v) => { + struct_ser.serialize_field("aliOSS", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DirectFileOutput { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "filepath", + "disable_manifest", + "disableManifest", + "s3", + "gcp", + "azure", + "aliOSS", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Filepath, + DisableManifest, + S3, + Gcp, + Azure, + AliOss, + __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 { + "filepath" => Ok(GeneratedField::Filepath), + "disableManifest" | "disable_manifest" => Ok(GeneratedField::DisableManifest), + "s3" => Ok(GeneratedField::S3), + "gcp" => Ok(GeneratedField::Gcp), + "azure" => Ok(GeneratedField::Azure), + "aliOSS" => Ok(GeneratedField::AliOss), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DirectFileOutput; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.DirectFileOutput") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut filepath__ = None; + let mut disable_manifest__ = None; + let mut output__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Filepath => { + if filepath__.is_some() { + return Err(serde::de::Error::duplicate_field("filepath")); + } + filepath__ = Some(map_.next_value()?); + } + GeneratedField::DisableManifest => { + if disable_manifest__.is_some() { + return Err(serde::de::Error::duplicate_field("disableManifest")); + } + disable_manifest__ = Some(map_.next_value()?); + } + GeneratedField::S3 => { + if output__.is_some() { + return Err(serde::de::Error::duplicate_field("s3")); + } + output__ = map_.next_value::<::std::option::Option<_>>()?.map(direct_file_output::Output::S3) +; + } + GeneratedField::Gcp => { + if output__.is_some() { + return Err(serde::de::Error::duplicate_field("gcp")); + } + output__ = map_.next_value::<::std::option::Option<_>>()?.map(direct_file_output::Output::Gcp) +; + } + GeneratedField::Azure => { + if output__.is_some() { + return Err(serde::de::Error::duplicate_field("azure")); + } + output__ = map_.next_value::<::std::option::Option<_>>()?.map(direct_file_output::Output::Azure) +; + } + GeneratedField::AliOss => { + if output__.is_some() { + return Err(serde::de::Error::duplicate_field("aliOSS")); + } + output__ = map_.next_value::<::std::option::Option<_>>()?.map(direct_file_output::Output::AliOss) +; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(DirectFileOutput { + filepath: filepath__.unwrap_or_default(), + disable_manifest: disable_manifest__.unwrap_or_default(), + output: output__, + }) + } + } + deserializer.deserialize_struct("livekit.DirectFileOutput", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DisabledCodecs { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.codecs.is_empty() { + len += 1; + } + if !self.publish.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.DisabledCodecs", len)?; + if !self.codecs.is_empty() { + struct_ser.serialize_field("codecs", &self.codecs)?; + } + if !self.publish.is_empty() { + struct_ser.serialize_field("publish", &self.publish)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DisabledCodecs { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "codecs", + "publish", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Codecs, + Publish, + __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 { + "codecs" => Ok(GeneratedField::Codecs), + "publish" => Ok(GeneratedField::Publish), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DisabledCodecs; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.DisabledCodecs") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut codecs__ = None; + let mut publish__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Codecs => { + if codecs__.is_some() { + return Err(serde::de::Error::duplicate_field("codecs")); + } + codecs__ = Some(map_.next_value()?); + } + GeneratedField::Publish => { + if publish__.is_some() { + return Err(serde::de::Error::duplicate_field("publish")); + } + publish__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(DisabledCodecs { + codecs: codecs__.unwrap_or_default(), + publish: publish__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.DisabledCodecs", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DisconnectReason { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::UnknownReason => "UNKNOWN_REASON", + Self::ClientInitiated => "CLIENT_INITIATED", + Self::DuplicateIdentity => "DUPLICATE_IDENTITY", + Self::ServerShutdown => "SERVER_SHUTDOWN", + Self::ParticipantRemoved => "PARTICIPANT_REMOVED", + Self::RoomDeleted => "ROOM_DELETED", + Self::StateMismatch => "STATE_MISMATCH", + Self::JoinFailure => "JOIN_FAILURE", + Self::Migration => "MIGRATION", + Self::SignalClose => "SIGNAL_CLOSE", + Self::RoomClosed => "ROOM_CLOSED", + Self::UserUnavailable => "USER_UNAVAILABLE", + Self::UserRejected => "USER_REJECTED", + Self::SipTrunkFailure => "SIP_TRUNK_FAILURE", + Self::ConnectionTimeout => "CONNECTION_TIMEOUT", + Self::MediaFailure => "MEDIA_FAILURE", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for DisconnectReason { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "UNKNOWN_REASON", + "CLIENT_INITIATED", + "DUPLICATE_IDENTITY", + "SERVER_SHUTDOWN", + "PARTICIPANT_REMOVED", + "ROOM_DELETED", + "STATE_MISMATCH", + "JOIN_FAILURE", + "MIGRATION", + "SIGNAL_CLOSE", + "ROOM_CLOSED", + "USER_UNAVAILABLE", + "USER_REJECTED", + "SIP_TRUNK_FAILURE", + "CONNECTION_TIMEOUT", + "MEDIA_FAILURE", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DisconnectReason; + + 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 { + "UNKNOWN_REASON" => Ok(DisconnectReason::UnknownReason), + "CLIENT_INITIATED" => Ok(DisconnectReason::ClientInitiated), + "DUPLICATE_IDENTITY" => Ok(DisconnectReason::DuplicateIdentity), + "SERVER_SHUTDOWN" => Ok(DisconnectReason::ServerShutdown), + "PARTICIPANT_REMOVED" => Ok(DisconnectReason::ParticipantRemoved), + "ROOM_DELETED" => Ok(DisconnectReason::RoomDeleted), + "STATE_MISMATCH" => Ok(DisconnectReason::StateMismatch), + "JOIN_FAILURE" => Ok(DisconnectReason::JoinFailure), + "MIGRATION" => Ok(DisconnectReason::Migration), + "SIGNAL_CLOSE" => Ok(DisconnectReason::SignalClose), + "ROOM_CLOSED" => Ok(DisconnectReason::RoomClosed), + "USER_UNAVAILABLE" => Ok(DisconnectReason::UserUnavailable), + "USER_REJECTED" => Ok(DisconnectReason::UserRejected), + "SIP_TRUNK_FAILURE" => Ok(DisconnectReason::SipTrunkFailure), + "CONNECTION_TIMEOUT" => Ok(DisconnectReason::ConnectionTimeout), + "MEDIA_FAILURE" => Ok(DisconnectReason::MediaFailure), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for DisconnectWhatsAppCallRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.whatsapp_call_id.is_empty() { + len += 1; + } + if !self.whatsapp_api_key.is_empty() { + len += 1; + } + if self.disconnect_reason != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.DisconnectWhatsAppCallRequest", len)?; + if !self.whatsapp_call_id.is_empty() { + struct_ser.serialize_field("whatsappCallId", &self.whatsapp_call_id)?; + } + if !self.whatsapp_api_key.is_empty() { + struct_ser.serialize_field("whatsappApiKey", &self.whatsapp_api_key)?; + } + if self.disconnect_reason != 0 { + let v = disconnect_whats_app_call_request::DisconnectReason::try_from(self.disconnect_reason) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.disconnect_reason)))?; + struct_ser.serialize_field("disconnectReason", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DisconnectWhatsAppCallRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "whatsapp_call_id", + "whatsappCallId", + "whatsapp_api_key", + "whatsappApiKey", + "disconnect_reason", + "disconnectReason", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WhatsappCallId, + WhatsappApiKey, + DisconnectReason, + __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 { + "whatsappCallId" | "whatsapp_call_id" => Ok(GeneratedField::WhatsappCallId), + "whatsappApiKey" | "whatsapp_api_key" => Ok(GeneratedField::WhatsappApiKey), + "disconnectReason" | "disconnect_reason" => Ok(GeneratedField::DisconnectReason), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DisconnectWhatsAppCallRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.DisconnectWhatsAppCallRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut whatsapp_call_id__ = None; + let mut whatsapp_api_key__ = None; + let mut disconnect_reason__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::WhatsappCallId => { + if whatsapp_call_id__.is_some() { + return Err(serde::de::Error::duplicate_field("whatsappCallId")); + } + whatsapp_call_id__ = Some(map_.next_value()?); + } + GeneratedField::WhatsappApiKey => { + if whatsapp_api_key__.is_some() { + return Err(serde::de::Error::duplicate_field("whatsappApiKey")); + } + whatsapp_api_key__ = Some(map_.next_value()?); + } + GeneratedField::DisconnectReason => { + if disconnect_reason__.is_some() { + return Err(serde::de::Error::duplicate_field("disconnectReason")); + } + disconnect_reason__ = Some(map_.next_value::()? as i32); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(DisconnectWhatsAppCallRequest { + whatsapp_call_id: whatsapp_call_id__.unwrap_or_default(), + whatsapp_api_key: whatsapp_api_key__.unwrap_or_default(), + disconnect_reason: disconnect_reason__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.DisconnectWhatsAppCallRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for disconnect_whats_app_call_request::DisconnectReason { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::BusinessInitiated => "BUSINESS_INITIATED", + Self::UserInitiated => "USER_INITIATED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for disconnect_whats_app_call_request::DisconnectReason { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "BUSINESS_INITIATED", + "USER_INITIATED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = disconnect_whats_app_call_request::DisconnectReason; + + 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 { + "BUSINESS_INITIATED" => Ok(disconnect_whats_app_call_request::DisconnectReason::BusinessInitiated), + "USER_INITIATED" => Ok(disconnect_whats_app_call_request::DisconnectReason::UserInitiated), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for DisconnectWhatsAppCallResponse { + #[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.DisconnectWhatsAppCallResponse", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DisconnectWhatsAppCallResponse { + #[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 = DisconnectWhatsAppCallResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.DisconnectWhatsAppCallResponse") + } + + 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(DisconnectWhatsAppCallResponse { + }) + } + } + deserializer.deserialize_struct("livekit.DisconnectWhatsAppCallResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EgressInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.egress_id.is_empty() { + len += 1; + } + if !self.room_id.is_empty() { + len += 1; + } + if !self.room_name.is_empty() { + len += 1; + } + if self.source_type != 0 { + len += 1; + } + if self.status != 0 { + len += 1; + } + if self.started_at != 0 { + len += 1; + } + if self.ended_at != 0 { + len += 1; + } + if self.updated_at != 0 { + len += 1; + } + if !self.details.is_empty() { + len += 1; + } + if !self.error.is_empty() { + len += 1; + } + if self.error_code != 0 { + len += 1; + } + if !self.stream_results.is_empty() { + len += 1; + } + if !self.file_results.is_empty() { + len += 1; + } + if !self.segment_results.is_empty() { + len += 1; + } + if !self.image_results.is_empty() { + len += 1; + } + if !self.manifest_location.is_empty() { + len += 1; + } + if self.backup_storage_used { + len += 1; + } + if self.request.is_some() { + len += 1; + } + if self.result.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.EgressInfo", len)?; if !self.egress_id.is_empty() { struct_ser.serialize_field("egressId", &self.egress_id)?; } @@ -19868,6 +20643,9 @@ impl serde::Serialize for MetricsRecordingHeader { if self.start_time.is_some() { len += 1; } + if !self.room_tags.is_empty() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("livekit.MetricsRecordingHeader", len)?; if !self.room_id.is_empty() { struct_ser.serialize_field("roomId", &self.room_id)?; @@ -19880,6 +20658,9 @@ impl serde::Serialize for MetricsRecordingHeader { if let Some(v) = self.start_time.as_ref() { struct_ser.serialize_field("startTime", v)?; } + if !self.room_tags.is_empty() { + struct_ser.serialize_field("roomTags", &self.room_tags)?; + } struct_ser.end() } } @@ -19895,6 +20676,8 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { "duration", "start_time", "startTime", + "room_tags", + "roomTags", ]; #[allow(clippy::enum_variant_names)] @@ -19902,6 +20685,7 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { RoomId, Duration, StartTime, + RoomTags, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -19927,6 +20711,7 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { "roomId" | "room_id" => Ok(GeneratedField::RoomId), "duration" => Ok(GeneratedField::Duration), "startTime" | "start_time" => Ok(GeneratedField::StartTime), + "roomTags" | "room_tags" => Ok(GeneratedField::RoomTags), _ => Ok(GeneratedField::__SkipField__), } } @@ -19949,6 +20734,7 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { let mut room_id__ = None; let mut duration__ = None; let mut start_time__ = None; + let mut room_tags__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::RoomId => { @@ -19971,6 +20757,14 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { } start_time__ = map_.next_value()?; } + GeneratedField::RoomTags => { + if room_tags__.is_some() { + return Err(serde::de::Error::duplicate_field("roomTags")); + } + room_tags__ = Some( + map_.next_value::>()? + ); + } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -19980,6 +20774,7 @@ impl<'de> serde::Deserialize<'de> for MetricsRecordingHeader { room_id: room_id__.unwrap_or_default(), duration: duration__.unwrap_or_default(), start_time: start_time__, + room_tags: room_tags__.unwrap_or_default(), }) } } @@ -21065,6 +21860,9 @@ impl serde::Serialize for ParticipantInfo { if !self.kind_details.is_empty() { len += 1; } + if !self.data_tracks.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)?; @@ -21128,6 +21926,9 @@ impl serde::Serialize for ParticipantInfo { }).collect::, _>>()?; struct_ser.serialize_field("kindDetails", &v)?; } + if !self.data_tracks.is_empty() { + struct_ser.serialize_field("dataTracks", &self.data_tracks)?; + } struct_ser.end() } } @@ -21159,6 +21960,8 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { "disconnectReason", "kind_details", "kindDetails", + "data_tracks", + "dataTracks", ]; #[allow(clippy::enum_variant_names)] @@ -21179,6 +21982,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { Attributes, DisconnectReason, KindDetails, + DataTracks, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -21217,6 +22021,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { "attributes" => Ok(GeneratedField::Attributes), "disconnectReason" | "disconnect_reason" => Ok(GeneratedField::DisconnectReason), "kindDetails" | "kind_details" => Ok(GeneratedField::KindDetails), + "dataTracks" | "data_tracks" => Ok(GeneratedField::DataTracks), _ => Ok(GeneratedField::__SkipField__), } } @@ -21252,6 +22057,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { let mut attributes__ = None; let mut disconnect_reason__ = None; let mut kind_details__ = None; + let mut data_tracks__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Sid => { @@ -21358,6 +22164,12 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { } kind_details__ = Some(map_.next_value::>()?.into_iter().map(|x| x as i32).collect()); } + GeneratedField::DataTracks => { + if data_tracks__.is_some() { + return Err(serde::de::Error::duplicate_field("dataTracks")); + } + data_tracks__ = Some(map_.next_value()?); + } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -21380,6 +22192,7 @@ impl<'de> serde::Deserialize<'de> for ParticipantInfo { attributes: attributes__.unwrap_or_default(), disconnect_reason: disconnect_reason__.unwrap_or_default(), kind_details: kind_details__.unwrap_or_default(), + data_tracks: data_tracks__.unwrap_or_default(), }) } } @@ -21399,6 +22212,7 @@ impl serde::Serialize for participant_info::Kind { Self::Sip => "SIP", Self::Agent => "AGENT", Self::Connector => "CONNECTOR", + Self::Bridge => "BRIDGE", }; serializer.serialize_str(variant) } @@ -21416,6 +22230,7 @@ impl<'de> serde::Deserialize<'de> for participant_info::Kind { "SIP", "AGENT", "CONNECTOR", + "BRIDGE", ]; struct GeneratedVisitor; @@ -21462,6 +22277,7 @@ impl<'de> serde::Deserialize<'de> for participant_info::Kind { "SIP" => Ok(participant_info::Kind::Sip), "AGENT" => Ok(participant_info::Kind::Agent), "CONNECTOR" => Ok(participant_info::Kind::Connector), + "BRIDGE" => Ok(participant_info::Kind::Bridge), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -21480,6 +22296,7 @@ impl serde::Serialize for participant_info::KindDetail { Self::Forwarded => "FORWARDED", Self::ConnectorWhatsapp => "CONNECTOR_WHATSAPP", Self::ConnectorTwilio => "CONNECTOR_TWILIO", + Self::BridgeRtsp => "BRIDGE_RTSP", }; serializer.serialize_str(variant) } @@ -21495,6 +22312,7 @@ impl<'de> serde::Deserialize<'de> for participant_info::KindDetail { "FORWARDED", "CONNECTOR_WHATSAPP", "CONNECTOR_TWILIO", + "BRIDGE_RTSP", ]; struct GeneratedVisitor; @@ -21539,6 +22357,7 @@ impl<'de> serde::Deserialize<'de> for participant_info::KindDetail { "FORWARDED" => Ok(participant_info::KindDetail::Forwarded), "CONNECTOR_WHATSAPP" => Ok(participant_info::KindDetail::ConnectorWhatsapp), "CONNECTOR_TWILIO" => Ok(participant_info::KindDetail::ConnectorTwilio), + "BRIDGE_RTSP" => Ok(participant_info::KindDetail::BridgeRtsp), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -22789,10 +23608,353 @@ impl<'de> serde::Deserialize<'de> for ProviderInfo { E: serde::de::Error, { match value { - "id" => Ok(GeneratedField::Id), + "id" => Ok(GeneratedField::Id), + "name" => Ok(GeneratedField::Name), + "type" => Ok(GeneratedField::Type), + "preventTransfer" | "prevent_transfer" => Ok(GeneratedField::PreventTransfer), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ProviderInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.ProviderInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut name__ = None; + let mut r#type__ = None; + let mut prevent_transfer__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::Type => { + if r#type__.is_some() { + return Err(serde::de::Error::duplicate_field("type")); + } + r#type__ = Some(map_.next_value::()? as i32); + } + GeneratedField::PreventTransfer => { + if prevent_transfer__.is_some() { + return Err(serde::de::Error::duplicate_field("preventTransfer")); + } + prevent_transfer__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(ProviderInfo { + id: id__.unwrap_or_default(), + name: name__.unwrap_or_default(), + r#type: r#type__.unwrap_or_default(), + prevent_transfer: prevent_transfer__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.ProviderInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ProviderType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "PROVIDER_TYPE_UNKNOWN", + Self::Internal => "PROVIDER_TYPE_INTERNAL", + Self::External => "PROVIDER_TYPE_EXTERNAL", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ProviderType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "PROVIDER_TYPE_UNKNOWN", + "PROVIDER_TYPE_INTERNAL", + "PROVIDER_TYPE_EXTERNAL", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ProviderType; + + 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 { + "PROVIDER_TYPE_UNKNOWN" => Ok(ProviderType::Unknown), + "PROVIDER_TYPE_INTERNAL" => Ok(ProviderType::Internal), + "PROVIDER_TYPE_EXTERNAL" => Ok(ProviderType::External), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ProxyConfig { + #[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.username.is_empty() { + len += 1; + } + if !self.password.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.ProxyConfig", len)?; + if !self.url.is_empty() { + struct_ser.serialize_field("url", &self.url)?; + } + if !self.username.is_empty() { + struct_ser.serialize_field("username", &self.username)?; + } + if !self.password.is_empty() { + struct_ser.serialize_field("password", &self.password)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ProxyConfig { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "url", + "username", + "password", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Url, + Username, + Password, + __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), + "username" => Ok(GeneratedField::Username), + "password" => Ok(GeneratedField::Password), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ProxyConfig; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.ProxyConfig") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut url__ = None; + let mut username__ = None; + let mut password__ = 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::Username => { + if username__.is_some() { + return Err(serde::de::Error::duplicate_field("username")); + } + username__ = Some(map_.next_value()?); + } + GeneratedField::Password => { + if password__.is_some() { + return Err(serde::de::Error::duplicate_field("password")); + } + password__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(ProxyConfig { + url: url__.unwrap_or_default(), + username: username__.unwrap_or_default(), + password: password__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.ProxyConfig", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PublishDataTrackRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.pub_handle != 0 { + len += 1; + } + if !self.name.is_empty() { + len += 1; + } + if self.encryption != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.PublishDataTrackRequest", len)?; + if self.pub_handle != 0 { + struct_ser.serialize_field("pubHandle", &self.pub_handle)?; + } + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if self.encryption != 0 { + let v = encryption::Type::try_from(self.encryption) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encryption)))?; + struct_ser.serialize_field("encryption", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PublishDataTrackRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "pub_handle", + "pubHandle", + "name", + "encryption", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PubHandle, + Name, + Encryption, + __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 { + "pubHandle" | "pub_handle" => Ok(GeneratedField::PubHandle), "name" => Ok(GeneratedField::Name), - "type" => Ok(GeneratedField::Type), - "preventTransfer" | "prevent_transfer" => Ok(GeneratedField::PreventTransfer), + "encryption" => Ok(GeneratedField::Encryption), _ => Ok(GeneratedField::__SkipField__), } } @@ -22802,27 +23964,28 @@ impl<'de> serde::Deserialize<'de> for ProviderInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ProviderInfo; + type Value = PublishDataTrackRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.ProviderInfo") + formatter.write_str("struct livekit.PublishDataTrackRequest") } - 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 id__ = None; + let mut pub_handle__ = None; let mut name__ = None; - let mut r#type__ = None; - let mut prevent_transfer__ = None; + let mut encryption__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Id => { - if id__.is_some() { - return Err(serde::de::Error::duplicate_field("id")); + GeneratedField::PubHandle => { + if pub_handle__.is_some() { + return Err(serde::de::Error::duplicate_field("pubHandle")); } - id__ = Some(map_.next_value()?); + pub_handle__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } GeneratedField::Name => { if name__.is_some() { @@ -22830,109 +23993,123 @@ impl<'de> serde::Deserialize<'de> for ProviderInfo { } name__ = Some(map_.next_value()?); } - GeneratedField::Type => { - if r#type__.is_some() { - return Err(serde::de::Error::duplicate_field("type")); - } - r#type__ = Some(map_.next_value::()? as i32); - } - GeneratedField::PreventTransfer => { - if prevent_transfer__.is_some() { - return Err(serde::de::Error::duplicate_field("preventTransfer")); + GeneratedField::Encryption => { + if encryption__.is_some() { + return Err(serde::de::Error::duplicate_field("encryption")); } - prevent_transfer__ = Some(map_.next_value()?); + encryption__ = Some(map_.next_value::()? as i32); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(ProviderInfo { - id: id__.unwrap_or_default(), + Ok(PublishDataTrackRequest { + pub_handle: pub_handle__.unwrap_or_default(), name: name__.unwrap_or_default(), - r#type: r#type__.unwrap_or_default(), - prevent_transfer: prevent_transfer__.unwrap_or_default(), + encryption: encryption__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.ProviderInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.PublishDataTrackRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ProviderType { +impl serde::Serialize for PublishDataTrackResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Unknown => "PROVIDER_TYPE_UNKNOWN", - Self::Internal => "PROVIDER_TYPE_INTERNAL", - Self::External => "PROVIDER_TYPE_EXTERNAL", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if self.info.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.PublishDataTrackResponse", len)?; + if let Some(v) = self.info.as_ref() { + struct_ser.serialize_field("info", v)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ProviderType { +impl<'de> serde::Deserialize<'de> for PublishDataTrackResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "PROVIDER_TYPE_UNKNOWN", - "PROVIDER_TYPE_INTERNAL", - "PROVIDER_TYPE_EXTERNAL", + "info", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Info, + __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 = ProviderType; + 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) - } + 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) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "info" => Ok(GeneratedField::Info), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PublishDataTrackResponse; - 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 expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.PublishDataTrackResponse") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "PROVIDER_TYPE_UNKNOWN" => Ok(ProviderType::Unknown), - "PROVIDER_TYPE_INTERNAL" => Ok(ProviderType::Internal), - "PROVIDER_TYPE_EXTERNAL" => Ok(ProviderType::External), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut info__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Info => { + if info__.is_some() { + return Err(serde::de::Error::duplicate_field("info")); + } + info__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } } + Ok(PublishDataTrackResponse { + info: info__, + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("livekit.PublishDataTrackResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ProxyConfig { +impl serde::Serialize for PushTextRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -22940,45 +24117,38 @@ impl serde::Serialize for ProxyConfig { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.url.is_empty() { + if !self.message_id.is_empty() { len += 1; } - if !self.username.is_empty() { - len += 1; - } - if !self.password.is_empty() { + if !self.content.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.ProxyConfig", len)?; - if !self.url.is_empty() { - struct_ser.serialize_field("url", &self.url)?; + let mut struct_ser = serializer.serialize_struct("livekit.PushTextRequest", len)?; + if !self.message_id.is_empty() { + struct_ser.serialize_field("messageId", &self.message_id)?; } - if !self.username.is_empty() { - struct_ser.serialize_field("username", &self.username)?; - } - if !self.password.is_empty() { - struct_ser.serialize_field("password", &self.password)?; + if !self.content.is_empty() { + struct_ser.serialize_field("content", &self.content)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ProxyConfig { +impl<'de> serde::Deserialize<'de> for PushTextRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "url", - "username", - "password", + "message_id", + "messageId", + "content", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Url, - Username, - Password, + MessageId, + Content, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -23001,9 +24171,8 @@ impl<'de> serde::Deserialize<'de> for ProxyConfig { E: serde::de::Error, { match value { - "url" => Ok(GeneratedField::Url), - "username" => Ok(GeneratedField::Username), - "password" => Ok(GeneratedField::Password), + "messageId" | "message_id" => Ok(GeneratedField::MessageId), + "content" => Ok(GeneratedField::Content), _ => Ok(GeneratedField::__SkipField__), } } @@ -23013,52 +24182,44 @@ impl<'de> serde::Deserialize<'de> for ProxyConfig { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ProxyConfig; + type Value = PushTextRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.ProxyConfig") + formatter.write_str("struct livekit.PushTextRequest") } - 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 url__ = None; - let mut username__ = None; - let mut password__ = None; + let mut message_id__ = None; + let mut content__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Url => { - if url__.is_some() { - return Err(serde::de::Error::duplicate_field("url")); + GeneratedField::MessageId => { + if message_id__.is_some() { + return Err(serde::de::Error::duplicate_field("messageId")); } - url__ = Some(map_.next_value()?); + message_id__ = Some(map_.next_value()?); } - GeneratedField::Username => { - if username__.is_some() { - return Err(serde::de::Error::duplicate_field("username")); - } - username__ = Some(map_.next_value()?); - } - GeneratedField::Password => { - if password__.is_some() { - return Err(serde::de::Error::duplicate_field("password")); + GeneratedField::Content => { + if content__.is_some() { + return Err(serde::de::Error::duplicate_field("content")); } - password__ = Some(map_.next_value()?); + content__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(ProxyConfig { - url: url__.unwrap_or_default(), - username: username__.unwrap_or_default(), - password: password__.unwrap_or_default(), + Ok(PushTextRequest { + message_id: message_id__.unwrap_or_default(), + content: content__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.ProxyConfig", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.PushTextRequest", FIELDS, GeneratedVisitor) } } impl serde::Serialize for RtcpSenderReportState { @@ -25837,6 +26998,12 @@ impl serde::Serialize for RequestResponse { request_response::Request::UpdateVideoTrack(v) => { struct_ser.serialize_field("updateVideoTrack", v)?; } + request_response::Request::PublishDataTrack(v) => { + struct_ser.serialize_field("publishDataTrack", v)?; + } + request_response::Request::UnpublishDataTrack(v) => { + struct_ser.serialize_field("unpublishDataTrack", v)?; + } } } struct_ser.end() @@ -25863,6 +27030,10 @@ impl<'de> serde::Deserialize<'de> for RequestResponse { "updateAudioTrack", "update_video_track", "updateVideoTrack", + "publish_data_track", + "publishDataTrack", + "unpublish_data_track", + "unpublishDataTrack", ]; #[allow(clippy::enum_variant_names)] @@ -25876,6 +27047,8 @@ impl<'de> serde::Deserialize<'de> for RequestResponse { UpdateMetadata, UpdateAudioTrack, UpdateVideoTrack, + PublishDataTrack, + UnpublishDataTrack, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -25907,6 +27080,8 @@ impl<'de> serde::Deserialize<'de> for RequestResponse { "updateMetadata" | "update_metadata" => Ok(GeneratedField::UpdateMetadata), "updateAudioTrack" | "update_audio_track" => Ok(GeneratedField::UpdateAudioTrack), "updateVideoTrack" | "update_video_track" => Ok(GeneratedField::UpdateVideoTrack), + "publishDataTrack" | "publish_data_track" => Ok(GeneratedField::PublishDataTrack), + "unpublishDataTrack" | "unpublish_data_track" => Ok(GeneratedField::UnpublishDataTrack), _ => Ok(GeneratedField::__SkipField__), } } @@ -25992,6 +27167,20 @@ impl<'de> serde::Deserialize<'de> for RequestResponse { return Err(serde::de::Error::duplicate_field("updateVideoTrack")); } request__ = map_.next_value::<::std::option::Option<_>>()?.map(request_response::Request::UpdateVideoTrack) +; + } + GeneratedField::PublishDataTrack => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("publishDataTrack")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(request_response::Request::PublishDataTrack) +; + } + GeneratedField::UnpublishDataTrack => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("unpublishDataTrack")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(request_response::Request::UnpublishDataTrack) ; } GeneratedField::__SkipField__ => { @@ -26024,6 +27213,10 @@ impl serde::Serialize for request_response::Reason { Self::Queued => "QUEUED", Self::UnsupportedType => "UNSUPPORTED_TYPE", Self::UnclassifiedError => "UNCLASSIFIED_ERROR", + Self::InvalidHandle => "INVALID_HANDLE", + Self::InvalidName => "INVALID_NAME", + Self::DuplicateHandle => "DUPLICATE_HANDLE", + Self::DuplicateName => "DUPLICATE_NAME", }; serializer.serialize_str(variant) } @@ -26042,6 +27235,10 @@ impl<'de> serde::Deserialize<'de> for request_response::Reason { "QUEUED", "UNSUPPORTED_TYPE", "UNCLASSIFIED_ERROR", + "INVALID_HANDLE", + "INVALID_NAME", + "DUPLICATE_HANDLE", + "DUPLICATE_NAME", ]; struct GeneratedVisitor; @@ -26089,6 +27286,10 @@ impl<'de> serde::Deserialize<'de> for request_response::Reason { "QUEUED" => Ok(request_response::Reason::Queued), "UNSUPPORTED_TYPE" => Ok(request_response::Reason::UnsupportedType), "UNCLASSIFIED_ERROR" => Ok(request_response::Reason::UnclassifiedError), + "INVALID_HANDLE" => Ok(request_response::Reason::InvalidHandle), + "INVALID_NAME" => Ok(request_response::Reason::InvalidName), + "DUPLICATE_HANDLE" => Ok(request_response::Reason::DuplicateHandle), + "DUPLICATE_NAME" => Ok(request_response::Reason::DuplicateName), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -28750,6 +29951,9 @@ impl serde::Serialize for SipCallInfo { if self.provider_info.is_some() { len += 1; } + if !self.sip_call_id.is_empty() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("livekit.SIPCallInfo", len)?; if !self.call_id.is_empty() { struct_ser.serialize_field("callId", &self.call_id)?; @@ -28854,6 +30058,9 @@ impl serde::Serialize for SipCallInfo { if let Some(v) = self.provider_info.as_ref() { struct_ser.serialize_field("providerInfo", v)?; } + if !self.sip_call_id.is_empty() { + struct_ser.serialize_field("sipCallId", &self.sip_call_id)?; + } struct_ser.end() } } @@ -28916,6 +30123,8 @@ impl<'de> serde::Deserialize<'de> for SipCallInfo { "callContext", "provider_info", "providerInfo", + "sip_call_id", + "sipCallId", ]; #[allow(clippy::enum_variant_names)] @@ -28947,6 +30156,7 @@ impl<'de> serde::Deserialize<'de> for SipCallInfo { PcapFileLink, CallContext, ProviderInfo, + SipCallId, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -28996,6 +30206,7 @@ impl<'de> serde::Deserialize<'de> for SipCallInfo { "pcapFileLink" | "pcap_file_link" => Ok(GeneratedField::PcapFileLink), "callContext" | "call_context" => Ok(GeneratedField::CallContext), "providerInfo" | "provider_info" => Ok(GeneratedField::ProviderInfo), + "sipCallId" | "sip_call_id" => Ok(GeneratedField::SipCallId), _ => Ok(GeneratedField::__SkipField__), } } @@ -29042,6 +30253,7 @@ impl<'de> serde::Deserialize<'de> for SipCallInfo { let mut pcap_file_link__ = None; let mut call_context__ = None; let mut provider_info__ = None; + let mut sip_call_id__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::CallId => { @@ -29220,6 +30432,12 @@ impl<'de> serde::Deserialize<'de> for SipCallInfo { } provider_info__ = map_.next_value()?; } + GeneratedField::SipCallId => { + if sip_call_id__.is_some() { + return Err(serde::de::Error::duplicate_field("sipCallId")); + } + sip_call_id__ = Some(map_.next_value()?); + } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -29253,6 +30471,7 @@ impl<'de> serde::Deserialize<'de> for SipCallInfo { pcap_file_link: pcap_file_link__.unwrap_or_default(), call_context: call_context__.unwrap_or_default(), provider_info: provider_info__, + sip_call_id: sip_call_id__.unwrap_or_default(), }) } } @@ -29847,6 +31066,9 @@ impl serde::Serialize for SipDispatchRuleInfo { if !self.inbound_numbers.is_empty() { len += 1; } + if !self.numbers.is_empty() { + len += 1; + } if !self.name.is_empty() { len += 1; } @@ -29884,6 +31106,9 @@ impl serde::Serialize for SipDispatchRuleInfo { if !self.inbound_numbers.is_empty() { struct_ser.serialize_field("inboundNumbers", &self.inbound_numbers)?; } + if !self.numbers.is_empty() { + struct_ser.serialize_field("numbers", &self.numbers)?; + } if !self.name.is_empty() { struct_ser.serialize_field("name", &self.name)?; } @@ -29926,6 +31151,7 @@ impl<'de> serde::Deserialize<'de> for SipDispatchRuleInfo { "hidePhoneNumber", "inbound_numbers", "inboundNumbers", + "numbers", "name", "metadata", "attributes", @@ -29946,6 +31172,7 @@ impl<'de> serde::Deserialize<'de> for SipDispatchRuleInfo { TrunkIds, HidePhoneNumber, InboundNumbers, + Numbers, Name, Metadata, Attributes, @@ -29980,6 +31207,7 @@ impl<'de> serde::Deserialize<'de> for SipDispatchRuleInfo { "trunkIds" | "trunk_ids" => Ok(GeneratedField::TrunkIds), "hidePhoneNumber" | "hide_phone_number" => Ok(GeneratedField::HidePhoneNumber), "inboundNumbers" | "inbound_numbers" => Ok(GeneratedField::InboundNumbers), + "numbers" => Ok(GeneratedField::Numbers), "name" => Ok(GeneratedField::Name), "metadata" => Ok(GeneratedField::Metadata), "attributes" => Ok(GeneratedField::Attributes), @@ -30011,6 +31239,7 @@ impl<'de> serde::Deserialize<'de> for SipDispatchRuleInfo { let mut trunk_ids__ = None; let mut hide_phone_number__ = None; let mut inbound_numbers__ = None; + let mut numbers__ = None; let mut name__ = None; let mut metadata__ = None; let mut attributes__ = None; @@ -30050,6 +31279,12 @@ impl<'de> serde::Deserialize<'de> for SipDispatchRuleInfo { } inbound_numbers__ = Some(map_.next_value()?); } + GeneratedField::Numbers => { + if numbers__.is_some() { + return Err(serde::de::Error::duplicate_field("numbers")); + } + numbers__ = Some(map_.next_value()?); + } GeneratedField::Name => { if name__.is_some() { return Err(serde::de::Error::duplicate_field("name")); @@ -30105,6 +31340,7 @@ impl<'de> serde::Deserialize<'de> for SipDispatchRuleInfo { trunk_ids: trunk_ids__.unwrap_or_default(), hide_phone_number: hide_phone_number__.unwrap_or_default(), inbound_numbers: inbound_numbers__.unwrap_or_default(), + numbers: numbers__.unwrap_or_default(), name: name__.unwrap_or_default(), metadata: metadata__.unwrap_or_default(), attributes: attributes__.unwrap_or_default(), @@ -34666,6 +35902,9 @@ impl serde::Serialize for ServerMessage { server_message::Message::Pong(v) => { struct_ser.serialize_field("pong", v)?; } + server_message::Message::TextRequest(v) => { + struct_ser.serialize_field("textRequest", v)?; + } } } struct_ser.end() @@ -34683,6 +35922,8 @@ impl<'de> serde::Deserialize<'de> for ServerMessage { "assignment", "termination", "pong", + "text_request", + "textRequest", ]; #[allow(clippy::enum_variant_names)] @@ -34692,6 +35933,7 @@ impl<'de> serde::Deserialize<'de> for ServerMessage { Assignment, Termination, Pong, + TextRequest, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -34719,6 +35961,7 @@ impl<'de> serde::Deserialize<'de> for ServerMessage { "assignment" => Ok(GeneratedField::Assignment), "termination" => Ok(GeneratedField::Termination), "pong" => Ok(GeneratedField::Pong), + "textRequest" | "text_request" => Ok(GeneratedField::TextRequest), _ => Ok(GeneratedField::__SkipField__), } } @@ -34774,6 +36017,13 @@ impl<'de> serde::Deserialize<'de> for ServerMessage { return Err(serde::de::Error::duplicate_field("pong")); } message__ = map_.next_value::<::std::option::Option<_>>()?.map(server_message::Message::Pong) +; + } + GeneratedField::TextRequest => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("textRequest")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(server_message::Message::TextRequest) ; } GeneratedField::__SkipField__ => { @@ -35007,6 +36257,15 @@ impl serde::Serialize for SignalRequest { signal_request::Message::UpdateVideoTrack(v) => { struct_ser.serialize_field("updateVideoTrack", v)?; } + signal_request::Message::PublishDataTrackRequest(v) => { + struct_ser.serialize_field("publishDataTrackRequest", v)?; + } + signal_request::Message::UnpublishDataTrackRequest(v) => { + struct_ser.serialize_field("unpublishDataTrackRequest", v)?; + } + signal_request::Message::UpdateDataSubscription(v) => { + struct_ser.serialize_field("updateDataSubscription", v)?; + } } } struct_ser.end() @@ -35045,6 +36304,12 @@ impl<'de> serde::Deserialize<'de> for SignalRequest { "updateAudioTrack", "update_video_track", "updateVideoTrack", + "publish_data_track_request", + "publishDataTrackRequest", + "unpublish_data_track_request", + "unpublishDataTrackRequest", + "update_data_subscription", + "updateDataSubscription", ]; #[allow(clippy::enum_variant_names)] @@ -35066,6 +36331,9 @@ impl<'de> serde::Deserialize<'de> for SignalRequest { PingReq, UpdateAudioTrack, UpdateVideoTrack, + PublishDataTrackRequest, + UnpublishDataTrackRequest, + UpdateDataSubscription, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -35105,6 +36373,9 @@ impl<'de> serde::Deserialize<'de> for SignalRequest { "pingReq" | "ping_req" => Ok(GeneratedField::PingReq), "updateAudioTrack" | "update_audio_track" => Ok(GeneratedField::UpdateAudioTrack), "updateVideoTrack" | "update_video_track" => Ok(GeneratedField::UpdateVideoTrack), + "publishDataTrackRequest" | "publish_data_track_request" => Ok(GeneratedField::PublishDataTrackRequest), + "unpublishDataTrackRequest" | "unpublish_data_track_request" => Ok(GeneratedField::UnpublishDataTrackRequest), + "updateDataSubscription" | "update_data_subscription" => Ok(GeneratedField::UpdateDataSubscription), _ => Ok(GeneratedField::__SkipField__), } } @@ -35243,6 +36514,27 @@ impl<'de> serde::Deserialize<'de> for SignalRequest { return Err(serde::de::Error::duplicate_field("updateVideoTrack")); } message__ = map_.next_value::<::std::option::Option<_>>()?.map(signal_request::Message::UpdateVideoTrack) +; + } + GeneratedField::PublishDataTrackRequest => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("publishDataTrackRequest")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(signal_request::Message::PublishDataTrackRequest) +; + } + GeneratedField::UnpublishDataTrackRequest => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("unpublishDataTrackRequest")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(signal_request::Message::UnpublishDataTrackRequest) +; + } + GeneratedField::UpdateDataSubscription => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("updateDataSubscription")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(signal_request::Message::UpdateDataSubscription) ; } GeneratedField::__SkipField__ => { @@ -35349,6 +36641,15 @@ impl serde::Serialize for SignalResponse { signal_response::Message::SubscribedAudioCodecUpdate(v) => { struct_ser.serialize_field("subscribedAudioCodecUpdate", v)?; } + signal_response::Message::PublishDataTrackResponse(v) => { + struct_ser.serialize_field("publishDataTrackResponse", v)?; + } + signal_response::Message::UnpublishDataTrackResponse(v) => { + struct_ser.serialize_field("unpublishDataTrackResponse", v)?; + } + signal_response::Message::DataTrackSubscriberHandles(v) => { + struct_ser.serialize_field("dataTrackSubscriberHandles", v)?; + } } } struct_ser.end() @@ -35402,6 +36703,12 @@ impl<'de> serde::Deserialize<'de> for SignalResponse { "mediaSectionsRequirement", "subscribed_audio_codec_update", "subscribedAudioCodecUpdate", + "publish_data_track_response", + "publishDataTrackResponse", + "unpublish_data_track_response", + "unpublishDataTrackResponse", + "data_track_subscriber_handles", + "dataTrackSubscriberHandles", ]; #[allow(clippy::enum_variant_names)] @@ -35431,6 +36738,9 @@ impl<'de> serde::Deserialize<'de> for SignalResponse { RoomMoved, MediaSectionsRequirement, SubscribedAudioCodecUpdate, + PublishDataTrackResponse, + UnpublishDataTrackResponse, + DataTrackSubscriberHandles, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -35478,6 +36788,9 @@ impl<'de> serde::Deserialize<'de> for SignalResponse { "roomMoved" | "room_moved" => Ok(GeneratedField::RoomMoved), "mediaSectionsRequirement" | "media_sections_requirement" => Ok(GeneratedField::MediaSectionsRequirement), "subscribedAudioCodecUpdate" | "subscribed_audio_codec_update" => Ok(GeneratedField::SubscribedAudioCodecUpdate), + "publishDataTrackResponse" | "publish_data_track_response" => Ok(GeneratedField::PublishDataTrackResponse), + "unpublishDataTrackResponse" | "unpublish_data_track_response" => Ok(GeneratedField::UnpublishDataTrackResponse), + "dataTrackSubscriberHandles" | "data_track_subscriber_handles" => Ok(GeneratedField::DataTrackSubscriberHandles), _ => Ok(GeneratedField::__SkipField__), } } @@ -35671,6 +36984,27 @@ impl<'de> serde::Deserialize<'de> for SignalResponse { return Err(serde::de::Error::duplicate_field("subscribedAudioCodecUpdate")); } message__ = map_.next_value::<::std::option::Option<_>>()?.map(signal_response::Message::SubscribedAudioCodecUpdate) +; + } + GeneratedField::PublishDataTrackResponse => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("publishDataTrackResponse")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(signal_response::Message::PublishDataTrackResponse) +; + } + GeneratedField::UnpublishDataTrackResponse => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("unpublishDataTrackResponse")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(signal_response::Message::UnpublishDataTrackResponse) +; + } + GeneratedField::DataTrackSubscriberHandles => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("dataTrackSubscriberHandles")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(signal_response::Message::DataTrackSubscriberHandles) ; } GeneratedField::__SkipField__ => { @@ -38806,6 +40140,9 @@ impl serde::Serialize for SyncState { if !self.datachannel_receive_states.is_empty() { len += 1; } + if !self.publish_data_tracks.is_empty() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("livekit.SyncState", len)?; if let Some(v) = self.answer.as_ref() { struct_ser.serialize_field("answer", v)?; @@ -38828,6 +40165,9 @@ impl serde::Serialize for SyncState { if !self.datachannel_receive_states.is_empty() { struct_ser.serialize_field("datachannelReceiveStates", &self.datachannel_receive_states)?; } + if !self.publish_data_tracks.is_empty() { + struct_ser.serialize_field("publishDataTracks", &self.publish_data_tracks)?; + } struct_ser.end() } } @@ -38849,6 +40189,8 @@ impl<'de> serde::Deserialize<'de> for SyncState { "trackSidsDisabled", "datachannel_receive_states", "datachannelReceiveStates", + "publish_data_tracks", + "publishDataTracks", ]; #[allow(clippy::enum_variant_names)] @@ -38860,6 +40202,7 @@ impl<'de> serde::Deserialize<'de> for SyncState { Offer, TrackSidsDisabled, DatachannelReceiveStates, + PublishDataTracks, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -38889,6 +40232,7 @@ impl<'de> serde::Deserialize<'de> for SyncState { "offer" => Ok(GeneratedField::Offer), "trackSidsDisabled" | "track_sids_disabled" => Ok(GeneratedField::TrackSidsDisabled), "datachannelReceiveStates" | "datachannel_receive_states" => Ok(GeneratedField::DatachannelReceiveStates), + "publishDataTracks" | "publish_data_tracks" => Ok(GeneratedField::PublishDataTracks), _ => Ok(GeneratedField::__SkipField__), } } @@ -38915,6 +40259,7 @@ impl<'de> serde::Deserialize<'de> for SyncState { let mut offer__ = None; let mut track_sids_disabled__ = None; let mut datachannel_receive_states__ = None; + let mut publish_data_tracks__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Answer => { @@ -38959,6 +40304,12 @@ impl<'de> serde::Deserialize<'de> for SyncState { } datachannel_receive_states__ = Some(map_.next_value()?); } + GeneratedField::PublishDataTracks => { + if publish_data_tracks__.is_some() { + return Err(serde::de::Error::duplicate_field("publishDataTracks")); + } + publish_data_tracks__ = Some(map_.next_value()?); + } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -38972,12 +40323,336 @@ impl<'de> serde::Deserialize<'de> for SyncState { offer: offer__, track_sids_disabled: track_sids_disabled__.unwrap_or_default(), datachannel_receive_states: datachannel_receive_states__.unwrap_or_default(), + publish_data_tracks: publish_data_tracks__.unwrap_or_default(), }) } } deserializer.deserialize_struct("livekit.SyncState", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for TextMessageRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.message_id.is_empty() { + len += 1; + } + if !self.session_id.is_empty() { + len += 1; + } + if !self.agent_name.is_empty() { + len += 1; + } + if !self.metadata.is_empty() { + len += 1; + } + if !self.session_data.is_empty() { + len += 1; + } + if !self.text.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.TextMessageRequest", len)?; + if !self.message_id.is_empty() { + struct_ser.serialize_field("messageId", &self.message_id)?; + } + if !self.session_id.is_empty() { + struct_ser.serialize_field("sessionId", &self.session_id)?; + } + if !self.agent_name.is_empty() { + struct_ser.serialize_field("agentName", &self.agent_name)?; + } + if !self.metadata.is_empty() { + struct_ser.serialize_field("metadata", &self.metadata)?; + } + if !self.session_data.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("sessionData", pbjson::private::base64::encode(&self.session_data).as_str())?; + } + if !self.text.is_empty() { + struct_ser.serialize_field("text", &self.text)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TextMessageRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "message_id", + "messageId", + "session_id", + "sessionId", + "agent_name", + "agentName", + "metadata", + "session_data", + "sessionData", + "text", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + MessageId, + SessionId, + AgentName, + Metadata, + SessionData, + Text, + __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 { + "messageId" | "message_id" => Ok(GeneratedField::MessageId), + "sessionId" | "session_id" => Ok(GeneratedField::SessionId), + "agentName" | "agent_name" => Ok(GeneratedField::AgentName), + "metadata" => Ok(GeneratedField::Metadata), + "sessionData" | "session_data" => Ok(GeneratedField::SessionData), + "text" => Ok(GeneratedField::Text), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TextMessageRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.TextMessageRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message_id__ = None; + let mut session_id__ = None; + let mut agent_name__ = None; + let mut metadata__ = None; + let mut session_data__ = None; + let mut text__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::MessageId => { + if message_id__.is_some() { + return Err(serde::de::Error::duplicate_field("messageId")); + } + message_id__ = Some(map_.next_value()?); + } + GeneratedField::SessionId => { + if session_id__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionId")); + } + session_id__ = Some(map_.next_value()?); + } + GeneratedField::AgentName => { + if agent_name__.is_some() { + return Err(serde::de::Error::duplicate_field("agentName")); + } + agent_name__ = Some(map_.next_value()?); + } + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); + } + metadata__ = Some(map_.next_value()?); + } + GeneratedField::SessionData => { + if session_data__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionData")); + } + session_data__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Text => { + if text__.is_some() { + return Err(serde::de::Error::duplicate_field("text")); + } + text__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(TextMessageRequest { + message_id: message_id__.unwrap_or_default(), + session_id: session_id__.unwrap_or_default(), + agent_name: agent_name__.unwrap_or_default(), + metadata: metadata__.unwrap_or_default(), + session_data: session_data__.unwrap_or_default(), + text: text__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.TextMessageRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TextMessageResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.message_id.is_empty() { + len += 1; + } + if !self.session_data.is_empty() { + len += 1; + } + if !self.error.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.TextMessageResponse", len)?; + if !self.message_id.is_empty() { + struct_ser.serialize_field("messageId", &self.message_id)?; + } + if !self.session_data.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("sessionData", pbjson::private::base64::encode(&self.session_data).as_str())?; + } + if !self.error.is_empty() { + struct_ser.serialize_field("error", &self.error)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TextMessageResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "message_id", + "messageId", + "session_data", + "sessionData", + "error", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + MessageId, + SessionData, + Error, + __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 { + "messageId" | "message_id" => Ok(GeneratedField::MessageId), + "sessionData" | "session_data" => Ok(GeneratedField::SessionData), + "error" => Ok(GeneratedField::Error), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TextMessageResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.TextMessageResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message_id__ = None; + let mut session_data__ = None; + let mut error__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::MessageId => { + if message_id__.is_some() { + return Err(serde::de::Error::duplicate_field("messageId")); + } + message_id__ = Some(map_.next_value()?); + } + GeneratedField::SessionData => { + if session_data__.is_some() { + return Err(serde::de::Error::duplicate_field("sessionData")); + } + session_data__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Error => { + if error__.is_some() { + return Err(serde::de::Error::duplicate_field("error")); + } + error__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(TextMessageResponse { + message_id: message_id__.unwrap_or_default(), + session_data: session_data__.unwrap_or_default(), + error: error__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.TextMessageResponse", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for TimeSeriesMetric { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -40614,41 +42289,483 @@ impl<'de> serde::Deserialize<'de> for TrackSource { } } } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for TrackSubscribed { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.track_sid.is_empty() { - len += 1; + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for TrackSubscribed { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.track_sid.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.TrackSubscribed", len)?; + if !self.track_sid.is_empty() { + struct_ser.serialize_field("trackSid", &self.track_sid)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TrackSubscribed { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "track_sid", + "trackSid", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TrackSid, + __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 { + "trackSid" | "track_sid" => Ok(GeneratedField::TrackSid), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TrackSubscribed; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.TrackSubscribed") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut track_sid__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::TrackSid => { + if track_sid__.is_some() { + return Err(serde::de::Error::duplicate_field("trackSid")); + } + track_sid__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(TrackSubscribed { + track_sid: track_sid__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.TrackSubscribed", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TrackType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Audio => "AUDIO", + Self::Video => "VIDEO", + Self::Data => "DATA", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for TrackType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "AUDIO", + "VIDEO", + "DATA", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TrackType; + + 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 { + "AUDIO" => Ok(TrackType::Audio), + "VIDEO" => Ok(TrackType::Video), + "DATA" => Ok(TrackType::Data), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for TrackUnpublishedResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.track_sid.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.TrackUnpublishedResponse", len)?; + if !self.track_sid.is_empty() { + struct_ser.serialize_field("trackSid", &self.track_sid)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TrackUnpublishedResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "track_sid", + "trackSid", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TrackSid, + __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 { + "trackSid" | "track_sid" => Ok(GeneratedField::TrackSid), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TrackUnpublishedResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.TrackUnpublishedResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut track_sid__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::TrackSid => { + if track_sid__.is_some() { + return Err(serde::de::Error::duplicate_field("trackSid")); + } + track_sid__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(TrackUnpublishedResponse { + track_sid: track_sid__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.TrackUnpublishedResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Transcription { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.transcribed_participant_identity.is_empty() { + len += 1; + } + if !self.track_id.is_empty() { + len += 1; + } + if !self.segments.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.Transcription", len)?; + if !self.transcribed_participant_identity.is_empty() { + struct_ser.serialize_field("transcribedParticipantIdentity", &self.transcribed_participant_identity)?; + } + if !self.track_id.is_empty() { + struct_ser.serialize_field("trackId", &self.track_id)?; + } + if !self.segments.is_empty() { + struct_ser.serialize_field("segments", &self.segments)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Transcription { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "transcribed_participant_identity", + "transcribedParticipantIdentity", + "track_id", + "trackId", + "segments", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TranscribedParticipantIdentity, + TrackId, + Segments, + __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 { + "transcribedParticipantIdentity" | "transcribed_participant_identity" => Ok(GeneratedField::TranscribedParticipantIdentity), + "trackId" | "track_id" => Ok(GeneratedField::TrackId), + "segments" => Ok(GeneratedField::Segments), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Transcription; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.Transcription") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut transcribed_participant_identity__ = None; + let mut track_id__ = None; + let mut segments__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::TranscribedParticipantIdentity => { + if transcribed_participant_identity__.is_some() { + return Err(serde::de::Error::duplicate_field("transcribedParticipantIdentity")); + } + transcribed_participant_identity__ = Some(map_.next_value()?); + } + GeneratedField::TrackId => { + if track_id__.is_some() { + return Err(serde::de::Error::duplicate_field("trackId")); + } + track_id__ = Some(map_.next_value()?); + } + GeneratedField::Segments => { + if segments__.is_some() { + return Err(serde::de::Error::duplicate_field("segments")); + } + segments__ = Some(map_.next_value()?); + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(Transcription { + transcribed_participant_identity: transcribed_participant_identity__.unwrap_or_default(), + track_id: track_id__.unwrap_or_default(), + segments: segments__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("livekit.Transcription", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TranscriptionSegment { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if !self.text.is_empty() { + len += 1; + } + if self.start_time != 0 { + len += 1; + } + if self.end_time != 0 { + len += 1; + } + if self.r#final { + len += 1; + } + if !self.language.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.TranscriptionSegment", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if !self.text.is_empty() { + struct_ser.serialize_field("text", &self.text)?; + } + if self.start_time != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("startTime", ToString::to_string(&self.start_time).as_str())?; + } + if self.end_time != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("endTime", ToString::to_string(&self.end_time).as_str())?; + } + if self.r#final { + struct_ser.serialize_field("final", &self.r#final)?; } - let mut struct_ser = serializer.serialize_struct("livekit.TrackSubscribed", len)?; - if !self.track_sid.is_empty() { - struct_ser.serialize_field("trackSid", &self.track_sid)?; + if !self.language.is_empty() { + struct_ser.serialize_field("language", &self.language)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for TrackSubscribed { +impl<'de> serde::Deserialize<'de> for TranscriptionSegment { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "track_sid", - "trackSid", + "id", + "text", + "start_time", + "startTime", + "end_time", + "endTime", + "final", + "language", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - TrackSid, + Id, + Text, + StartTime, + EndTime, + Final, + Language, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -40671,7 +42788,12 @@ impl<'de> serde::Deserialize<'de> for TrackSubscribed { E: serde::de::Error, { match value { - "trackSid" | "track_sid" => Ok(GeneratedField::TrackSid), + "id" => Ok(GeneratedField::Id), + "text" => Ok(GeneratedField::Text), + "startTime" | "start_time" => Ok(GeneratedField::StartTime), + "endTime" | "end_time" => Ok(GeneratedField::EndTime), + "final" => Ok(GeneratedField::Final), + "language" => Ok(GeneratedField::Language), _ => Ok(GeneratedField::__SkipField__), } } @@ -40681,113 +42803,270 @@ impl<'de> serde::Deserialize<'de> for TrackSubscribed { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = TrackSubscribed; + type Value = TranscriptionSegment; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.TrackSubscribed") + formatter.write_str("struct livekit.TranscriptionSegment") } - 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 track_sid__ = None; + let mut id__ = None; + let mut text__ = None; + let mut start_time__ = None; + let mut end_time__ = None; + let mut r#final__ = None; + let mut language__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::TrackSid => { - if track_sid__.is_some() { - return Err(serde::de::Error::duplicate_field("trackSid")); + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); } - track_sid__ = Some(map_.next_value()?); + id__ = Some(map_.next_value()?); + } + GeneratedField::Text => { + if text__.is_some() { + return Err(serde::de::Error::duplicate_field("text")); + } + text__ = Some(map_.next_value()?); + } + GeneratedField::StartTime => { + if start_time__.is_some() { + return Err(serde::de::Error::duplicate_field("startTime")); + } + start_time__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::EndTime => { + if end_time__.is_some() { + return Err(serde::de::Error::duplicate_field("endTime")); + } + end_time__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Final => { + if r#final__.is_some() { + return Err(serde::de::Error::duplicate_field("final")); + } + r#final__ = Some(map_.next_value()?); + } + GeneratedField::Language => { + if language__.is_some() { + return Err(serde::de::Error::duplicate_field("language")); + } + language__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(TrackSubscribed { - track_sid: track_sid__.unwrap_or_default(), + Ok(TranscriptionSegment { + id: id__.unwrap_or_default(), + text: text__.unwrap_or_default(), + start_time: start_time__.unwrap_or_default(), + end_time: end_time__.unwrap_or_default(), + r#final: r#final__.unwrap_or_default(), + language: language__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.TrackSubscribed", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.TranscriptionSegment", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for TrackType { +impl serde::Serialize for TransferSipParticipantRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Audio => "AUDIO", - Self::Video => "VIDEO", - Self::Data => "DATA", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.participant_identity.is_empty() { + len += 1; + } + if !self.room_name.is_empty() { + len += 1; + } + if !self.transfer_to.is_empty() { + len += 1; + } + if self.play_dialtone { + len += 1; + } + 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)?; + } + if !self.room_name.is_empty() { + struct_ser.serialize_field("roomName", &self.room_name)?; + } + if !self.transfer_to.is_empty() { + struct_ser.serialize_field("transferTo", &self.transfer_to)?; + } + if self.play_dialtone { + struct_ser.serialize_field("playDialtone", &self.play_dialtone)?; + } + 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() } } -impl<'de> serde::Deserialize<'de> for TrackType { +impl<'de> serde::Deserialize<'de> for TransferSipParticipantRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "AUDIO", - "VIDEO", - "DATA", + "participant_identity", + "participantIdentity", + "room_name", + "roomName", + "transfer_to", + "transferTo", + "play_dialtone", + "playDialtone", + "headers", + "ringing_timeout", + "ringingTimeout", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ParticipantIdentity, + RoomName, + TransferTo, + PlayDialtone, + Headers, + RingingTimeout, + __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 = TrackType; + 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) - } + 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) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "participantIdentity" | "participant_identity" => Ok(GeneratedField::ParticipantIdentity), + "roomName" | "room_name" => Ok(GeneratedField::RoomName), + "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__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TransferSipParticipantRequest; - 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 expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct livekit.TransferSIPParticipantRequest") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "AUDIO" => Ok(TrackType::Audio), - "VIDEO" => Ok(TrackType::Video), - "DATA" => Ok(TrackType::Data), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut participant_identity__ = None; + let mut room_name__ = None; + 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 => { + if participant_identity__.is_some() { + return Err(serde::de::Error::duplicate_field("participantIdentity")); + } + participant_identity__ = Some(map_.next_value()?); + } + GeneratedField::RoomName => { + if room_name__.is_some() { + return Err(serde::de::Error::duplicate_field("roomName")); + } + room_name__ = Some(map_.next_value()?); + } + GeneratedField::TransferTo => { + if transfer_to__.is_some() { + return Err(serde::de::Error::duplicate_field("transferTo")); + } + transfer_to__ = Some(map_.next_value()?); + } + GeneratedField::PlayDialtone => { + if play_dialtone__.is_some() { + return Err(serde::de::Error::duplicate_field("playDialtone")); + } + play_dialtone__ = Some(map_.next_value()?); + } + GeneratedField::Headers => { + if headers__.is_some() { + return Err(serde::de::Error::duplicate_field("headers")); + } + headers__ = Some( + 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::()?; + } + } } + Ok(TransferSipParticipantRequest { + participant_identity: participant_identity__.unwrap_or_default(), + room_name: room_name__.unwrap_or_default(), + transfer_to: transfer_to__.unwrap_or_default(), + play_dialtone: play_dialtone__.unwrap_or_default(), + headers: headers__.unwrap_or_default(), + ringing_timeout: ringing_timeout__, + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("livekit.TransferSIPParticipantRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for TrackUnpublishedResponse { +impl serde::Serialize for TrickleRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -40795,30 +43074,47 @@ impl serde::Serialize for TrackUnpublishedResponse { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.track_sid.is_empty() { + if !self.candidate_init.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.TrackUnpublishedResponse", len)?; - if !self.track_sid.is_empty() { - struct_ser.serialize_field("trackSid", &self.track_sid)?; + if self.target != 0 { + len += 1; + } + if self.r#final { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("livekit.TrickleRequest", len)?; + if !self.candidate_init.is_empty() { + struct_ser.serialize_field("candidateInit", &self.candidate_init)?; + } + if self.target != 0 { + let v = SignalTarget::try_from(self.target) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.target)))?; + struct_ser.serialize_field("target", &v)?; + } + if self.r#final { + struct_ser.serialize_field("final", &self.r#final)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for TrackUnpublishedResponse { +impl<'de> serde::Deserialize<'de> for TrickleRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "track_sid", - "trackSid", + "candidateInit", + "target", + "final", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - TrackSid, + CandidateInit, + Target, + Final, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -40841,7 +43137,9 @@ impl<'de> serde::Deserialize<'de> for TrackUnpublishedResponse { E: serde::de::Error, { match value { - "trackSid" | "track_sid" => Ok(GeneratedField::TrackSid), + "candidateInit" => Ok(GeneratedField::CandidateInit), + "target" => Ok(GeneratedField::Target), + "final" => Ok(GeneratedField::Final), _ => Ok(GeneratedField::__SkipField__), } } @@ -40851,39 +43149,55 @@ impl<'de> serde::Deserialize<'de> for TrackUnpublishedResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = TrackUnpublishedResponse; + type Value = TrickleRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.TrackUnpublishedResponse") + formatter.write_str("struct livekit.TrickleRequest") } - 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 track_sid__ = None; + let mut candidate_init__ = None; + let mut target__ = None; + let mut r#final__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::TrackSid => { - if track_sid__.is_some() { - return Err(serde::de::Error::duplicate_field("trackSid")); + GeneratedField::CandidateInit => { + if candidate_init__.is_some() { + return Err(serde::de::Error::duplicate_field("candidateInit")); } - track_sid__ = Some(map_.next_value()?); + candidate_init__ = Some(map_.next_value()?); + } + GeneratedField::Target => { + if target__.is_some() { + return Err(serde::de::Error::duplicate_field("target")); + } + target__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Final => { + if r#final__.is_some() { + return Err(serde::de::Error::duplicate_field("final")); + } + r#final__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(TrackUnpublishedResponse { - track_sid: track_sid__.unwrap_or_default(), + Ok(TrickleRequest { + candidate_init: candidate_init__.unwrap_or_default(), + target: target__.unwrap_or_default(), + r#final: r#final__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.TrackUnpublishedResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.TrickleRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Transcription { +impl serde::Serialize for UnpublishDataTrackRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -40891,47 +43205,30 @@ impl serde::Serialize for Transcription { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.transcribed_participant_identity.is_empty() { + if self.pub_handle != 0 { len += 1; } - if !self.track_id.is_empty() { - len += 1; - } - if !self.segments.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("livekit.Transcription", len)?; - if !self.transcribed_participant_identity.is_empty() { - struct_ser.serialize_field("transcribedParticipantIdentity", &self.transcribed_participant_identity)?; - } - if !self.track_id.is_empty() { - struct_ser.serialize_field("trackId", &self.track_id)?; - } - if !self.segments.is_empty() { - struct_ser.serialize_field("segments", &self.segments)?; + let mut struct_ser = serializer.serialize_struct("livekit.UnpublishDataTrackRequest", len)?; + if self.pub_handle != 0 { + struct_ser.serialize_field("pubHandle", &self.pub_handle)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Transcription { +impl<'de> serde::Deserialize<'de> for UnpublishDataTrackRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "transcribed_participant_identity", - "transcribedParticipantIdentity", - "track_id", - "trackId", - "segments", + "pub_handle", + "pubHandle", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - TranscribedParticipantIdentity, - TrackId, - Segments, + PubHandle, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -40954,9 +43251,7 @@ impl<'de> serde::Deserialize<'de> for Transcription { E: serde::de::Error, { match value { - "transcribedParticipantIdentity" | "transcribed_participant_identity" => Ok(GeneratedField::TranscribedParticipantIdentity), - "trackId" | "track_id" => Ok(GeneratedField::TrackId), - "segments" => Ok(GeneratedField::Segments), + "pubHandle" | "pub_handle" => Ok(GeneratedField::PubHandle), _ => Ok(GeneratedField::__SkipField__), } } @@ -40966,55 +43261,41 @@ impl<'de> serde::Deserialize<'de> for Transcription { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Transcription; + type Value = UnpublishDataTrackRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.Transcription") + formatter.write_str("struct livekit.UnpublishDataTrackRequest") } - 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 transcribed_participant_identity__ = None; - let mut track_id__ = None; - let mut segments__ = None; + let mut pub_handle__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::TranscribedParticipantIdentity => { - if transcribed_participant_identity__.is_some() { - return Err(serde::de::Error::duplicate_field("transcribedParticipantIdentity")); - } - transcribed_participant_identity__ = Some(map_.next_value()?); - } - GeneratedField::TrackId => { - if track_id__.is_some() { - return Err(serde::de::Error::duplicate_field("trackId")); - } - track_id__ = Some(map_.next_value()?); - } - GeneratedField::Segments => { - if segments__.is_some() { - return Err(serde::de::Error::duplicate_field("segments")); + GeneratedField::PubHandle => { + if pub_handle__.is_some() { + return Err(serde::de::Error::duplicate_field("pubHandle")); } - segments__ = Some(map_.next_value()?); + pub_handle__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(Transcription { - transcribed_participant_identity: transcribed_participant_identity__.unwrap_or_default(), - track_id: track_id__.unwrap_or_default(), - segments: segments__.unwrap_or_default(), + Ok(UnpublishDataTrackRequest { + pub_handle: pub_handle__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.Transcription", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.UnpublishDataTrackRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for TranscriptionSegment { +impl serde::Serialize for UnpublishDataTrackResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -41022,75 +43303,29 @@ impl serde::Serialize for TranscriptionSegment { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.id.is_empty() { - len += 1; - } - if !self.text.is_empty() { - len += 1; - } - if self.start_time != 0 { + if self.info.is_some() { len += 1; } - if self.end_time != 0 { - len += 1; - } - if self.r#final { - len += 1; - } - if !self.language.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("livekit.TranscriptionSegment", len)?; - if !self.id.is_empty() { - struct_ser.serialize_field("id", &self.id)?; - } - if !self.text.is_empty() { - struct_ser.serialize_field("text", &self.text)?; - } - if self.start_time != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("startTime", ToString::to_string(&self.start_time).as_str())?; - } - if self.end_time != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("endTime", ToString::to_string(&self.end_time).as_str())?; - } - if self.r#final { - struct_ser.serialize_field("final", &self.r#final)?; - } - if !self.language.is_empty() { - struct_ser.serialize_field("language", &self.language)?; + let mut struct_ser = serializer.serialize_struct("livekit.UnpublishDataTrackResponse", len)?; + if let Some(v) = self.info.as_ref() { + struct_ser.serialize_field("info", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for TranscriptionSegment { +impl<'de> serde::Deserialize<'de> for UnpublishDataTrackResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "id", - "text", - "start_time", - "startTime", - "end_time", - "endTime", - "final", - "language", + "info", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Id, - Text, - StartTime, - EndTime, - Final, - Language, + Info, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -41113,12 +43348,7 @@ impl<'de> serde::Deserialize<'de> for TranscriptionSegment { E: serde::de::Error, { match value { - "id" => Ok(GeneratedField::Id), - "text" => Ok(GeneratedField::Text), - "startTime" | "start_time" => Ok(GeneratedField::StartTime), - "endTime" | "end_time" => Ok(GeneratedField::EndTime), - "final" => Ok(GeneratedField::Final), - "language" => Ok(GeneratedField::Language), + "info" => Ok(GeneratedField::Info), _ => Ok(GeneratedField::__SkipField__), } } @@ -41128,83 +43358,39 @@ impl<'de> serde::Deserialize<'de> for TranscriptionSegment { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = TranscriptionSegment; + type Value = UnpublishDataTrackResponse; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.TranscriptionSegment") + formatter.write_str("struct livekit.UnpublishDataTrackResponse") } - 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 id__ = None; - let mut text__ = None; - let mut start_time__ = None; - let mut end_time__ = None; - let mut r#final__ = None; - let mut language__ = None; + let mut info__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Id => { - if id__.is_some() { - return Err(serde::de::Error::duplicate_field("id")); - } - id__ = Some(map_.next_value()?); - } - GeneratedField::Text => { - if text__.is_some() { - return Err(serde::de::Error::duplicate_field("text")); - } - text__ = Some(map_.next_value()?); - } - GeneratedField::StartTime => { - if start_time__.is_some() { - return Err(serde::de::Error::duplicate_field("startTime")); - } - start_time__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::EndTime => { - if end_time__.is_some() { - return Err(serde::de::Error::duplicate_field("endTime")); - } - end_time__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Final => { - if r#final__.is_some() { - return Err(serde::de::Error::duplicate_field("final")); - } - r#final__ = Some(map_.next_value()?); - } - GeneratedField::Language => { - if language__.is_some() { - return Err(serde::de::Error::duplicate_field("language")); + GeneratedField::Info => { + if info__.is_some() { + return Err(serde::de::Error::duplicate_field("info")); } - language__ = Some(map_.next_value()?); + info__ = map_.next_value()?; } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(TranscriptionSegment { - id: id__.unwrap_or_default(), - text: text__.unwrap_or_default(), - start_time: start_time__.unwrap_or_default(), - end_time: end_time__.unwrap_or_default(), - r#final: r#final__.unwrap_or_default(), - language: language__.unwrap_or_default(), + Ok(UnpublishDataTrackResponse { + info: info__, }) } } - deserializer.deserialize_struct("livekit.TranscriptionSegment", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.UnpublishDataTrackResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for TransferSipParticipantRequest { +impl serde::Serialize for UpdateDataSubscription { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -41212,74 +43398,29 @@ impl serde::Serialize for TransferSipParticipantRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.participant_identity.is_empty() { - len += 1; - } - if !self.room_name.is_empty() { - len += 1; - } - if !self.transfer_to.is_empty() { - len += 1; - } - if self.play_dialtone { - len += 1; - } - if !self.headers.is_empty() { - len += 1; - } - if self.ringing_timeout.is_some() { + if !self.updates.is_empty() { 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)?; - } - if !self.room_name.is_empty() { - struct_ser.serialize_field("roomName", &self.room_name)?; - } - if !self.transfer_to.is_empty() { - struct_ser.serialize_field("transferTo", &self.transfer_to)?; - } - if self.play_dialtone { - struct_ser.serialize_field("playDialtone", &self.play_dialtone)?; - } - 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)?; + let mut struct_ser = serializer.serialize_struct("livekit.UpdateDataSubscription", len)?; + if !self.updates.is_empty() { + struct_ser.serialize_field("updates", &self.updates)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for TransferSipParticipantRequest { +impl<'de> serde::Deserialize<'de> for UpdateDataSubscription { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "participant_identity", - "participantIdentity", - "room_name", - "roomName", - "transfer_to", - "transferTo", - "play_dialtone", - "playDialtone", - "headers", - "ringing_timeout", - "ringingTimeout", + "updates", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ParticipantIdentity, - RoomName, - TransferTo, - PlayDialtone, - Headers, - RingingTimeout, + Updates, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -41302,12 +43443,7 @@ impl<'de> serde::Deserialize<'de> for TransferSipParticipantRequest { E: serde::de::Error, { match value { - "participantIdentity" | "participant_identity" => Ok(GeneratedField::ParticipantIdentity), - "roomName" | "room_name" => Ok(GeneratedField::RoomName), - "transferTo" | "transfer_to" => Ok(GeneratedField::TransferTo), - "playDialtone" | "play_dialtone" => Ok(GeneratedField::PlayDialtone), - "headers" => Ok(GeneratedField::Headers), - "ringingTimeout" | "ringing_timeout" => Ok(GeneratedField::RingingTimeout), + "updates" => Ok(GeneratedField::Updates), _ => Ok(GeneratedField::__SkipField__), } } @@ -41317,81 +43453,39 @@ impl<'de> serde::Deserialize<'de> for TransferSipParticipantRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = TransferSipParticipantRequest; + type Value = UpdateDataSubscription; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.TransferSIPParticipantRequest") + formatter.write_str("struct livekit.UpdateDataSubscription") } - 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 participant_identity__ = None; - let mut room_name__ = None; - let mut transfer_to__ = None; - let mut play_dialtone__ = None; - let mut headers__ = None; - let mut ringing_timeout__ = None; + let mut updates__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ParticipantIdentity => { - if participant_identity__.is_some() { - return Err(serde::de::Error::duplicate_field("participantIdentity")); - } - participant_identity__ = Some(map_.next_value()?); - } - GeneratedField::RoomName => { - if room_name__.is_some() { - return Err(serde::de::Error::duplicate_field("roomName")); - } - room_name__ = Some(map_.next_value()?); - } - GeneratedField::TransferTo => { - if transfer_to__.is_some() { - return Err(serde::de::Error::duplicate_field("transferTo")); - } - transfer_to__ = Some(map_.next_value()?); - } - GeneratedField::PlayDialtone => { - if play_dialtone__.is_some() { - return Err(serde::de::Error::duplicate_field("playDialtone")); - } - play_dialtone__ = Some(map_.next_value()?); - } - GeneratedField::Headers => { - if headers__.is_some() { - return Err(serde::de::Error::duplicate_field("headers")); - } - headers__ = Some( - map_.next_value::>()? - ); - } - GeneratedField::RingingTimeout => { - if ringing_timeout__.is_some() { - return Err(serde::de::Error::duplicate_field("ringingTimeout")); + GeneratedField::Updates => { + if updates__.is_some() { + return Err(serde::de::Error::duplicate_field("updates")); } - ringing_timeout__ = map_.next_value()?; + updates__ = Some(map_.next_value()?); } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(TransferSipParticipantRequest { - participant_identity: participant_identity__.unwrap_or_default(), - room_name: room_name__.unwrap_or_default(), - transfer_to: transfer_to__.unwrap_or_default(), - play_dialtone: play_dialtone__.unwrap_or_default(), - headers: headers__.unwrap_or_default(), - ringing_timeout: ringing_timeout__, + Ok(UpdateDataSubscription { + updates: updates__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("livekit.TransferSIPParticipantRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.UpdateDataSubscription", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for TrickleRequest { +impl serde::Serialize for update_data_subscription::Update { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -41399,47 +43493,46 @@ impl serde::Serialize for TrickleRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.candidate_init.is_empty() { + if !self.track_sid.is_empty() { len += 1; } - if self.target != 0 { + if self.subscribe { len += 1; } - if self.r#final { + if self.options.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("livekit.TrickleRequest", len)?; - if !self.candidate_init.is_empty() { - struct_ser.serialize_field("candidateInit", &self.candidate_init)?; + let mut struct_ser = serializer.serialize_struct("livekit.UpdateDataSubscription.Update", len)?; + if !self.track_sid.is_empty() { + struct_ser.serialize_field("trackSid", &self.track_sid)?; } - if self.target != 0 { - let v = SignalTarget::try_from(self.target) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.target)))?; - struct_ser.serialize_field("target", &v)?; + if self.subscribe { + struct_ser.serialize_field("subscribe", &self.subscribe)?; } - if self.r#final { - struct_ser.serialize_field("final", &self.r#final)?; + if let Some(v) = self.options.as_ref() { + struct_ser.serialize_field("options", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for TrickleRequest { +impl<'de> serde::Deserialize<'de> for update_data_subscription::Update { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "candidateInit", - "target", - "final", + "track_sid", + "trackSid", + "subscribe", + "options", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - CandidateInit, - Target, - Final, + TrackSid, + Subscribe, + Options, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -41462,9 +43555,9 @@ impl<'de> serde::Deserialize<'de> for TrickleRequest { E: serde::de::Error, { match value { - "candidateInit" => Ok(GeneratedField::CandidateInit), - "target" => Ok(GeneratedField::Target), - "final" => Ok(GeneratedField::Final), + "trackSid" | "track_sid" => Ok(GeneratedField::TrackSid), + "subscribe" => Ok(GeneratedField::Subscribe), + "options" => Ok(GeneratedField::Options), _ => Ok(GeneratedField::__SkipField__), } } @@ -41474,52 +43567,52 @@ impl<'de> serde::Deserialize<'de> for TrickleRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = TrickleRequest; + type Value = update_data_subscription::Update; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct livekit.TrickleRequest") + formatter.write_str("struct livekit.UpdateDataSubscription.Update") } - 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 candidate_init__ = None; - let mut target__ = None; - let mut r#final__ = None; + let mut track_sid__ = None; + let mut subscribe__ = None; + let mut options__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::CandidateInit => { - if candidate_init__.is_some() { - return Err(serde::de::Error::duplicate_field("candidateInit")); + GeneratedField::TrackSid => { + if track_sid__.is_some() { + return Err(serde::de::Error::duplicate_field("trackSid")); } - candidate_init__ = Some(map_.next_value()?); + track_sid__ = Some(map_.next_value()?); } - GeneratedField::Target => { - if target__.is_some() { - return Err(serde::de::Error::duplicate_field("target")); + GeneratedField::Subscribe => { + if subscribe__.is_some() { + return Err(serde::de::Error::duplicate_field("subscribe")); } - target__ = Some(map_.next_value::()? as i32); + subscribe__ = Some(map_.next_value()?); } - GeneratedField::Final => { - if r#final__.is_some() { - return Err(serde::de::Error::duplicate_field("final")); + GeneratedField::Options => { + if options__.is_some() { + return Err(serde::de::Error::duplicate_field("options")); } - r#final__ = Some(map_.next_value()?); + options__ = map_.next_value()?; } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } } } - Ok(TrickleRequest { - candidate_init: candidate_init__.unwrap_or_default(), - target: target__.unwrap_or_default(), - r#final: r#final__.unwrap_or_default(), + Ok(update_data_subscription::Update { + track_sid: track_sid__.unwrap_or_default(), + subscribe: subscribe__.unwrap_or_default(), + options: options__, }) } } - deserializer.deserialize_struct("livekit.TrickleRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("livekit.UpdateDataSubscription.Update", FIELDS, GeneratedVisitor) } } impl serde::Serialize for UpdateIngressRequest { @@ -44772,6 +46865,9 @@ impl serde::Serialize for VideoLayer { if !self.rid.is_empty() { len += 1; } + if self.repair_ssrc != 0 { + len += 1; + } let mut struct_ser = serializer.serialize_struct("livekit.VideoLayer", len)?; if self.quality != 0 { let v = VideoQuality::try_from(self.quality) @@ -44796,6 +46892,9 @@ impl serde::Serialize for VideoLayer { if !self.rid.is_empty() { struct_ser.serialize_field("rid", &self.rid)?; } + if self.repair_ssrc != 0 { + struct_ser.serialize_field("repairSsrc", &self.repair_ssrc)?; + } struct_ser.end() } } @@ -44814,6 +46913,8 @@ impl<'de> serde::Deserialize<'de> for VideoLayer { "spatial_layer", "spatialLayer", "rid", + "repair_ssrc", + "repairSsrc", ]; #[allow(clippy::enum_variant_names)] @@ -44825,6 +46926,7 @@ impl<'de> serde::Deserialize<'de> for VideoLayer { Ssrc, SpatialLayer, Rid, + RepairSsrc, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -44854,6 +46956,7 @@ impl<'de> serde::Deserialize<'de> for VideoLayer { "ssrc" => Ok(GeneratedField::Ssrc), "spatialLayer" | "spatial_layer" => Ok(GeneratedField::SpatialLayer), "rid" => Ok(GeneratedField::Rid), + "repairSsrc" | "repair_ssrc" => Ok(GeneratedField::RepairSsrc), _ => Ok(GeneratedField::__SkipField__), } } @@ -44880,6 +46983,7 @@ impl<'de> serde::Deserialize<'de> for VideoLayer { let mut ssrc__ = None; let mut spatial_layer__ = None; let mut rid__ = None; + let mut repair_ssrc__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Quality => { @@ -44934,6 +47038,14 @@ impl<'de> serde::Deserialize<'de> for VideoLayer { } rid__ = Some(map_.next_value()?); } + GeneratedField::RepairSsrc => { + if repair_ssrc__.is_some() { + return Err(serde::de::Error::duplicate_field("repairSsrc")); + } + repair_ssrc__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } GeneratedField::__SkipField__ => { let _ = map_.next_value::()?; } @@ -44947,6 +47059,7 @@ impl<'de> serde::Deserialize<'de> for VideoLayer { ssrc: ssrc__.unwrap_or_default(), spatial_layer: spatial_layer__.unwrap_or_default(), rid: rid__.unwrap_or_default(), + repair_ssrc: repair_ssrc__.unwrap_or_default(), }) } } @@ -46022,6 +48135,12 @@ impl serde::Serialize for WorkerMessage { worker_message::Message::MigrateJob(v) => { struct_ser.serialize_field("migrateJob", v)?; } + worker_message::Message::TextResponse(v) => { + struct_ser.serialize_field("textResponse", v)?; + } + worker_message::Message::PushText(v) => { + struct_ser.serialize_field("pushText", v)?; + } } } struct_ser.end() @@ -46045,6 +48164,10 @@ impl<'de> serde::Deserialize<'de> for WorkerMessage { "simulateJob", "migrate_job", "migrateJob", + "text_response", + "textResponse", + "push_text", + "pushText", ]; #[allow(clippy::enum_variant_names)] @@ -46056,6 +48179,8 @@ impl<'de> serde::Deserialize<'de> for WorkerMessage { Ping, SimulateJob, MigrateJob, + TextResponse, + PushText, __SkipField__, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -46085,6 +48210,8 @@ impl<'de> serde::Deserialize<'de> for WorkerMessage { "ping" => Ok(GeneratedField::Ping), "simulateJob" | "simulate_job" => Ok(GeneratedField::SimulateJob), "migrateJob" | "migrate_job" => Ok(GeneratedField::MigrateJob), + "textResponse" | "text_response" => Ok(GeneratedField::TextResponse), + "pushText" | "push_text" => Ok(GeneratedField::PushText), _ => Ok(GeneratedField::__SkipField__), } } @@ -46154,6 +48281,20 @@ impl<'de> serde::Deserialize<'de> for WorkerMessage { return Err(serde::de::Error::duplicate_field("migrateJob")); } message__ = map_.next_value::<::std::option::Option<_>>()?.map(worker_message::Message::MigrateJob) +; + } + GeneratedField::TextResponse => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("textResponse")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(worker_message::Message::TextResponse) +; + } + GeneratedField::PushText => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("pushText")); + } + message__ = map_.next_value::<::std::option::Option<_>>()?.map(worker_message::Message::PushText) ; } GeneratedField::__SkipField__ => { From cb8f8a8f123150126c276e26c71be37cb29af197 Mon Sep 17 00:00:00 2001 From: Jacob Gelman <3182119+ladvoc@users.noreply.github.com> Date: Sat, 31 Jan 2026 15:49:24 +1100 Subject: [PATCH 2/3] Integrate --- livekit-api/src/services/connector.rs | 1 + livekit-ffi/protocol/participant.proto | 2 ++ livekit-ffi/src/conversion/participant.rs | 2 ++ livekit/src/proto.rs | 4 ++++ livekit/src/room/mod.rs | 1 + livekit/src/room/participant/mod.rs | 2 ++ 6 files changed, 12 insertions(+) diff --git a/livekit-api/src/services/connector.rs b/livekit-api/src/services/connector.rs index 551e689d8..02eec319b 100644 --- a/livekit-api/src/services/connector.rs +++ b/livekit-api/src/services/connector.rs @@ -164,6 +164,7 @@ impl ConnectorClient { proto::DisconnectWhatsAppCallRequest { whatsapp_call_id: call_id.into(), whatsapp_api_key: api_key.into(), + ..Default::default() }, self.base .auth_header(VideoGrants { room_create: true, ..Default::default() }, None)?, diff --git a/livekit-ffi/protocol/participant.proto b/livekit-ffi/protocol/participant.proto index 589c508cf..36d1ecc27 100644 --- a/livekit-ffi/protocol/participant.proto +++ b/livekit-ffi/protocol/participant.proto @@ -44,6 +44,7 @@ enum ParticipantKind { PARTICIPANT_KIND_SIP = 3; PARTICIPANT_KIND_AGENT = 4; PARTICIPANT_KIND_CONNECTOR = 5; + PARTICIPANT_KIND_BRIDGE = 6; } enum ParticipantKindDetail { @@ -51,6 +52,7 @@ enum ParticipantKindDetail { PARTICIPANT_KIND_DETAIL_FORWARDED = 1; PARTICIPANT_KIND_DETAIL_CONNECTOR_WHATSAPP = 2; PARTICIPANT_KIND_DETAIL_CONNECTOR_TWILIO = 3; + PARTICIPANT_KIND_DETAIL_BRIDGE_RTSP = 4; } enum DisconnectReason { diff --git a/livekit-ffi/src/conversion/participant.rs b/livekit-ffi/src/conversion/participant.rs index 89cca3685..69af59b89 100644 --- a/livekit-ffi/src/conversion/participant.rs +++ b/livekit-ffi/src/conversion/participant.rs @@ -58,6 +58,7 @@ impl From for proto::ParticipantKind { ParticipantKind::Egress => proto::ParticipantKind::Egress, ParticipantKind::Agent => proto::ParticipantKind::Agent, ParticipantKind::Connector => proto::ParticipantKind::Connector, + ParticipantKind::Bridge => proto::ParticipantKind::Bridge } } } @@ -71,6 +72,7 @@ impl From for proto::ParticipantKindDetail { proto::ParticipantKindDetail::ConnectorWhatsapp } ParticipantKindDetail::ConnectorTwilio => proto::ParticipantKindDetail::ConnectorTwilio, + ParticipantKindDetail::BridgeRtsp => proto::ParticipantKindDetail::BridgeRtsp } } } diff --git a/livekit/src/proto.rs b/livekit/src/proto.rs index 20ca31e03..65575a4e7 100644 --- a/livekit/src/proto.rs +++ b/livekit/src/proto.rs @@ -155,6 +155,7 @@ impl From for participant::ParticipantKind { participant_info::Kind::Sip => participant::ParticipantKind::Sip, participant_info::Kind::Agent => participant::ParticipantKind::Agent, participant_info::Kind::Connector => participant::ParticipantKind::Connector, + participant_info::Kind::Bridge => participant::ParticipantKind::Bridge } } } @@ -174,6 +175,9 @@ impl From for participant::ParticipantKindDetail { participant_info::KindDetail::ConnectorTwilio => { participant::ParticipantKindDetail::ConnectorTwilio } + participant_info::KindDetail::BridgeRtsp => { + participant::ParticipantKindDetail::BridgeRtsp + } } } } diff --git a/livekit/src/room/mod.rs b/livekit/src/room/mod.rs index ff5276d6d..831664ebe 100644 --- a/livekit/src/room/mod.rs +++ b/livekit/src/room/mod.rs @@ -1227,6 +1227,7 @@ impl RoomSession { publish_tracks: self.local_participant.published_tracks_info(), data_channels: dcs, datachannel_receive_states: session.data_channel_receive_states(), + publish_data_tracks: Default::default() }; log::debug!("sending sync state {:?}", sync_state); diff --git a/livekit/src/room/participant/mod.rs b/livekit/src/room/participant/mod.rs index f4006644b..4fabfb89d 100644 --- a/livekit/src/room/participant/mod.rs +++ b/livekit/src/room/participant/mod.rs @@ -45,6 +45,7 @@ pub enum ParticipantKind { Sip, Agent, Connector, + Bridge } #[derive(Debug, Clone, Copy, Eq, PartialEq)] @@ -53,6 +54,7 @@ pub enum ParticipantKindDetail { Forwarded, ConnectorWhatsapp, ConnectorTwilio, + BridgeRtsp } #[derive(Debug, Clone, Copy, Eq, PartialEq)] From ca66c69c827dcb0a584a82c3fb3368012b1cef1f Mon Sep 17 00:00:00 2001 From: github-actions <41898282+github-actions[bot]@users.noreply.github.com> Date: Sat, 31 Jan 2026 04:50:29 +0000 Subject: [PATCH 3/3] generated protobuf --- .../src/proto/participant_pb.ts | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/livekit-ffi-node-bindings/src/proto/participant_pb.ts b/livekit-ffi-node-bindings/src/proto/participant_pb.ts index 90d956f9f..ef9eb0ce9 100644 --- a/livekit-ffi-node-bindings/src/proto/participant_pb.ts +++ b/livekit-ffi-node-bindings/src/proto/participant_pb.ts @@ -55,6 +55,11 @@ export enum ParticipantKind { * @generated from enum value: PARTICIPANT_KIND_CONNECTOR = 5; */ CONNECTOR = 5, + + /** + * @generated from enum value: PARTICIPANT_KIND_BRIDGE = 6; + */ + BRIDGE = 6, } // Retrieve enum metadata with: proto2.getEnumType(ParticipantKind) proto2.util.setEnumType(ParticipantKind, "livekit.proto.ParticipantKind", [ @@ -64,6 +69,7 @@ proto2.util.setEnumType(ParticipantKind, "livekit.proto.ParticipantKind", [ { no: 3, name: "PARTICIPANT_KIND_SIP" }, { no: 4, name: "PARTICIPANT_KIND_AGENT" }, { no: 5, name: "PARTICIPANT_KIND_CONNECTOR" }, + { no: 6, name: "PARTICIPANT_KIND_BRIDGE" }, ]); /** @@ -89,6 +95,11 @@ export enum ParticipantKindDetail { * @generated from enum value: PARTICIPANT_KIND_DETAIL_CONNECTOR_TWILIO = 3; */ CONNECTOR_TWILIO = 3, + + /** + * @generated from enum value: PARTICIPANT_KIND_DETAIL_BRIDGE_RTSP = 4; + */ + BRIDGE_RTSP = 4, } // Retrieve enum metadata with: proto2.getEnumType(ParticipantKindDetail) proto2.util.setEnumType(ParticipantKindDetail, "livekit.proto.ParticipantKindDetail", [ @@ -96,6 +107,7 @@ proto2.util.setEnumType(ParticipantKindDetail, "livekit.proto.ParticipantKindDet { no: 1, name: "PARTICIPANT_KIND_DETAIL_FORWARDED" }, { no: 2, name: "PARTICIPANT_KIND_DETAIL_CONNECTOR_WHATSAPP" }, { no: 3, name: "PARTICIPANT_KIND_DETAIL_CONNECTOR_TWILIO" }, + { no: 4, name: "PARTICIPANT_KIND_DETAIL_BRIDGE_RTSP" }, ]); /**