livekit_protocol/

livekit.rs

// @generated
// This file is @generated by prost-build.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MetricsBatch {
    /// time at which this batch is sent based on a monotonic clock (millisecond resolution)
    #[prost(int64, tag = "1")]
    pub timestamp_ms: i64,
    #[prost(message, optional, tag = "2")]
    pub normalized_timestamp: ::core::option::Option<::pbjson_types::Timestamp>,
    /// To avoid repeating string values, we store them in a separate list and reference them by index
    /// This is useful for storing participant identities, track names, etc.
    /// There is also a predefined list of labels that can be used to reference common metrics.
    /// They have reserved indices from 0 to (METRIC_LABEL_PREDEFINED_MAX_VALUE - 1).
    /// Indexes pointing at str_data should start from METRIC_LABEL_PREDEFINED_MAX_VALUE,
    /// such that str_data\[0\] == index of METRIC_LABEL_PREDEFINED_MAX_VALUE.
    #[prost(string, repeated, tag = "3")]
    pub str_data: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "4")]
    pub time_series: ::prost::alloc::vec::Vec<TimeSeriesMetric>,
    #[prost(message, repeated, tag = "5")]
    pub events: ::prost::alloc::vec::Vec<EventMetric>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TimeSeriesMetric {
    /// Metric name e.g "speech_probablity". The string value is not directly stored in the message, but referenced by index
    /// in the `str_data` field of `MetricsBatch`
    #[prost(uint32, tag = "1")]
    pub label: u32,
    /// index into `str_data`
    #[prost(uint32, tag = "2")]
    pub participant_identity: u32,
    /// index into `str_data`
    #[prost(uint32, tag = "3")]
    pub track_sid: u32,
    #[prost(message, repeated, tag = "4")]
    pub samples: ::prost::alloc::vec::Vec<MetricSample>,
    /// index into 'str_data'
    #[prost(uint32, tag = "5")]
    pub rid: u32,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct MetricSample {
    /// time of metric based on a monotonic clock (in milliseconds)
    #[prost(int64, tag = "1")]
    pub timestamp_ms: i64,
    #[prost(message, optional, tag = "2")]
    pub normalized_timestamp: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(float, tag = "3")]
    pub value: f32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EventMetric {
    #[prost(uint32, tag = "1")]
    pub label: u32,
    /// index into `str_data`
    #[prost(uint32, tag = "2")]
    pub participant_identity: u32,
    /// index into `str_data`
    #[prost(uint32, tag = "3")]
    pub track_sid: u32,
    /// start time of event based on a monotonic clock (in milliseconds)
    #[prost(int64, tag = "4")]
    pub start_timestamp_ms: i64,
    /// end time of event based on a monotonic clock (in milliseconds), if needed
    #[prost(int64, optional, tag = "5")]
    pub end_timestamp_ms: ::core::option::Option<i64>,
    #[prost(message, optional, tag = "6")]
    pub normalized_start_timestamp: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "7")]
    pub normalized_end_timestamp: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(string, tag = "8")]
    pub metadata: ::prost::alloc::string::String,
    /// index into 'str_data'
    #[prost(uint32, tag = "9")]
    pub rid: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MetricsRecordingHeader {
    #[prost(string, tag = "1")]
    pub room_id: ::prost::alloc::string::String,
    /// milliseconds
    #[prost(uint64, tag = "3")]
    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>,
    #[prost(string, tag = "6")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "7")]
    pub room_start_time: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(string, tag = "8")]
    pub job_id: ::prost::alloc::string::String,
    /// session is a simulation; the collector skips PII redaction for it unless redaction_enabled is set
    #[prost(bool, tag = "9")]
    pub simulated: bool,
    /// force PII redaction on for this session (only ever enables, never disables)
    #[prost(bool, tag = "10")]
    pub redaction_enabled: bool,
}
//
// Protocol used to record metrics for a specific session.
//
// Clients send their timestamp in their own monotonically increasing time (e.g `performance.now` on JS).
// These timestamps are then augmented by the SFU to its time base.
//
// A metric can be linked to a specific track by setting `track_sid`.

/// index from [0: MAX_LABEL_PREDEFINED_MAX_VALUE) are for predefined labels (`MetricLabel`)
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MetricLabel {
    /// time to first token from LLM
    AgentsLlmTtft = 0,
    /// time to final transcription
    AgentsSttTtft = 1,
    /// time to first byte
    AgentsTtsTtfb = 2,
    /// Number of video freezes
    ClientVideoSubscriberFreezeCount = 3,
    /// total duration of freezes
    ClientVideoSubscriberTotalFreezeDuration = 4,
    /// number of video pauses
    ClientVideoSubscriberPauseCount = 5,
    /// total duration of pauses
    ClientVideoSubscriberTotalPausesDuration = 6,
    /// number of concealed (synthesized) audio samples
    ClientAudioSubscriberConcealedSamples = 7,
    /// number of silent concealed samples
    ClientAudioSubscriberSilentConcealedSamples = 8,
    /// number of concealment events
    ClientAudioSubscriberConcealmentEvents = 9,
    /// number of interruptions
    ClientAudioSubscriberInterruptionCount = 10,
    /// total duration of interruptions
    ClientAudioSubscriberTotalInterruptionDuration = 11,
    /// total time spent in jitter buffer
    ClientSubscriberJitterBufferDelay = 12,
    /// total time spent in jitter buffer
    ClientSubscriberJitterBufferEmittedCount = 13,
    /// total duration spent in bandwidth quality limitation
    ClientVideoPublisherQualityLimitationDurationBandwidth = 14,
    /// total duration spent in cpu quality limitation
    ClientVideoPublisherQualityLimitationDurationCpu = 15,
    /// total duration spent in other quality limitation
    ClientVideoPublisherQualityLimitationDurationOther = 16,
    /// Publisher RTT (participant -> server)
    PublisherRtt = 17,
    /// RTT between publisher node and subscriber node (could involve intermedia node(s))
    ServerMeshRtt = 18,
    /// Subscribe RTT (server -> participant)
    SubscriberRtt = 19,
    PredefinedMaxValue = 4096,
}
impl MetricLabel {
    /// 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 {
            Self::AgentsLlmTtft => "AGENTS_LLM_TTFT",
            Self::AgentsSttTtft => "AGENTS_STT_TTFT",
            Self::AgentsTtsTtfb => "AGENTS_TTS_TTFB",
            Self::ClientVideoSubscriberFreezeCount => "CLIENT_VIDEO_SUBSCRIBER_FREEZE_COUNT",
            Self::ClientVideoSubscriberTotalFreezeDuration => "CLIENT_VIDEO_SUBSCRIBER_TOTAL_FREEZE_DURATION",
            Self::ClientVideoSubscriberPauseCount => "CLIENT_VIDEO_SUBSCRIBER_PAUSE_COUNT",
            Self::ClientVideoSubscriberTotalPausesDuration => "CLIENT_VIDEO_SUBSCRIBER_TOTAL_PAUSES_DURATION",
            Self::ClientAudioSubscriberConcealedSamples => "CLIENT_AUDIO_SUBSCRIBER_CONCEALED_SAMPLES",
            Self::ClientAudioSubscriberSilentConcealedSamples => "CLIENT_AUDIO_SUBSCRIBER_SILENT_CONCEALED_SAMPLES",
            Self::ClientAudioSubscriberConcealmentEvents => "CLIENT_AUDIO_SUBSCRIBER_CONCEALMENT_EVENTS",
            Self::ClientAudioSubscriberInterruptionCount => "CLIENT_AUDIO_SUBSCRIBER_INTERRUPTION_COUNT",
            Self::ClientAudioSubscriberTotalInterruptionDuration => "CLIENT_AUDIO_SUBSCRIBER_TOTAL_INTERRUPTION_DURATION",
            Self::ClientSubscriberJitterBufferDelay => "CLIENT_SUBSCRIBER_JITTER_BUFFER_DELAY",
            Self::ClientSubscriberJitterBufferEmittedCount => "CLIENT_SUBSCRIBER_JITTER_BUFFER_EMITTED_COUNT",
            Self::ClientVideoPublisherQualityLimitationDurationBandwidth => "CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_BANDWIDTH",
            Self::ClientVideoPublisherQualityLimitationDurationCpu => "CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_CPU",
            Self::ClientVideoPublisherQualityLimitationDurationOther => "CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_OTHER",
            Self::PublisherRtt => "PUBLISHER_RTT",
            Self::ServerMeshRtt => "SERVER_MESH_RTT",
            Self::SubscriberRtt => "SUBSCRIBER_RTT",
            Self::PredefinedMaxValue => "METRIC_LABEL_PREDEFINED_MAX_VALUE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AGENTS_LLM_TTFT" => Some(Self::AgentsLlmTtft),
            "AGENTS_STT_TTFT" => Some(Self::AgentsSttTtft),
            "AGENTS_TTS_TTFB" => Some(Self::AgentsTtsTtfb),
            "CLIENT_VIDEO_SUBSCRIBER_FREEZE_COUNT" => Some(Self::ClientVideoSubscriberFreezeCount),
            "CLIENT_VIDEO_SUBSCRIBER_TOTAL_FREEZE_DURATION" => Some(Self::ClientVideoSubscriberTotalFreezeDuration),
            "CLIENT_VIDEO_SUBSCRIBER_PAUSE_COUNT" => Some(Self::ClientVideoSubscriberPauseCount),
            "CLIENT_VIDEO_SUBSCRIBER_TOTAL_PAUSES_DURATION" => Some(Self::ClientVideoSubscriberTotalPausesDuration),
            "CLIENT_AUDIO_SUBSCRIBER_CONCEALED_SAMPLES" => Some(Self::ClientAudioSubscriberConcealedSamples),
            "CLIENT_AUDIO_SUBSCRIBER_SILENT_CONCEALED_SAMPLES" => Some(Self::ClientAudioSubscriberSilentConcealedSamples),
            "CLIENT_AUDIO_SUBSCRIBER_CONCEALMENT_EVENTS" => Some(Self::ClientAudioSubscriberConcealmentEvents),
            "CLIENT_AUDIO_SUBSCRIBER_INTERRUPTION_COUNT" => Some(Self::ClientAudioSubscriberInterruptionCount),
            "CLIENT_AUDIO_SUBSCRIBER_TOTAL_INTERRUPTION_DURATION" => Some(Self::ClientAudioSubscriberTotalInterruptionDuration),
            "CLIENT_SUBSCRIBER_JITTER_BUFFER_DELAY" => Some(Self::ClientSubscriberJitterBufferDelay),
            "CLIENT_SUBSCRIBER_JITTER_BUFFER_EMITTED_COUNT" => Some(Self::ClientSubscriberJitterBufferEmittedCount),
            "CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_BANDWIDTH" => Some(Self::ClientVideoPublisherQualityLimitationDurationBandwidth),
            "CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_CPU" => Some(Self::ClientVideoPublisherQualityLimitationDurationCpu),
            "CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_OTHER" => Some(Self::ClientVideoPublisherQualityLimitationDurationOther),
            "PUBLISHER_RTT" => Some(Self::PublisherRtt),
            "SERVER_MESH_RTT" => Some(Self::ServerMeshRtt),
            "SUBSCRIBER_RTT" => Some(Self::SubscriberRtt),
            "METRIC_LABEL_PREDEFINED_MAX_VALUE" => Some(Self::PredefinedMaxValue),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Pagination {
    /// list entities which IDs are greater
    #[prost(string, tag = "1")]
    pub after_id: ::prost::alloc::string::String,
    #[prost(int32, tag = "2")]
    pub limit: i32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TokenPagination {
    #[prost(string, tag = "1")]
    pub token: ::prost::alloc::string::String,
}
/// ListUpdate is used for updated APIs where 'repeated string' field is modified.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListUpdate {
    /// set the field to a new list
    #[prost(string, repeated, tag = "1")]
    pub set: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// append items to a list, avoiding duplicates
    #[prost(string, repeated, tag = "2")]
    pub add: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// delete items from a list
    #[prost(string, repeated, tag = "3")]
    pub remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// sets the list to an empty list
    #[prost(bool, tag = "4")]
    pub clear: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Room {
    #[prost(string, tag = "1")]
    pub sid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(uint32, tag = "3")]
    pub empty_timeout: u32,
    #[prost(uint32, tag = "14")]
    pub departure_timeout: u32,
    #[prost(uint32, tag = "4")]
    pub max_participants: u32,
    #[prost(int64, tag = "5")]
    pub creation_time: i64,
    #[prost(int64, tag = "15")]
    pub creation_time_ms: i64,
    #[prost(string, tag = "6")]
    pub turn_password: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "7")]
    pub enabled_codecs: ::prost::alloc::vec::Vec<Codec>,
    #[prost(string, tag = "8")]
    pub metadata: ::prost::alloc::string::String,
    #[prost(uint32, tag = "9")]
    pub num_participants: u32,
    #[prost(uint32, tag = "11")]
    pub num_publishers: u32,
    #[prost(bool, tag = "10")]
    pub active_recording: bool,
    #[prost(message, optional, tag = "13")]
    pub version: ::core::option::Option<TimedVersion>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Codec {
    #[prost(string, tag = "1")]
    pub mime: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub fmtp_line: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlayoutDelay {
    #[prost(bool, tag = "1")]
    pub enabled: bool,
    #[prost(uint32, tag = "2")]
    pub min: u32,
    #[prost(uint32, tag = "3")]
    pub max: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ParticipantPermission {
    /// allow participant to subscribe to other tracks in the room
    #[prost(bool, tag = "1")]
    pub can_subscribe: bool,
    /// allow participant to publish new tracks to room
    #[prost(bool, tag = "2")]
    pub can_publish: bool,
    /// allow participant to publish data
    #[prost(bool, tag = "3")]
    pub can_publish_data: bool,
    /// sources that are allowed to be published
    #[prost(enumeration = "TrackSource", repeated, tag = "9")]
    pub can_publish_sources: ::prost::alloc::vec::Vec<i32>,
    /// indicates that it's hidden to others
    #[prost(bool, tag = "7")]
    pub hidden: bool,
    /// indicates it's a recorder instance
    /// deprecated: use ParticipantInfo.kind instead
    #[deprecated]
    #[prost(bool, tag = "8")]
    pub recorder: bool,
    /// indicates that participant can update own metadata and attributes
    #[prost(bool, tag = "10")]
    pub can_update_metadata: bool,
    /// indicates that participant is an agent
    /// deprecated: use ParticipantInfo.kind instead
    #[deprecated]
    #[prost(bool, tag = "11")]
    pub agent: bool,
    /// if a participant can subscribe to metrics
    #[prost(bool, tag = "12")]
    pub can_subscribe_metrics: bool,
    /// if a participant can manage an agent session via RemoteSession (control and access state)
    #[prost(bool, tag = "13")]
    pub can_manage_agent_session: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParticipantInfo {
    #[prost(string, tag = "1")]
    pub sid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub identity: ::prost::alloc::string::String,
    #[prost(enumeration = "participant_info::State", tag = "3")]
    pub state: i32,
    #[prost(message, repeated, tag = "4")]
    pub tracks: ::prost::alloc::vec::Vec<TrackInfo>,
    #[prost(string, tag = "5")]
    pub metadata: ::prost::alloc::string::String,
    /// timestamp when participant joined room, in seconds
    #[prost(int64, tag = "6")]
    pub joined_at: i64,
    /// timestamp when participant joined room, in milliseconds
    #[prost(int64, tag = "17")]
    pub joined_at_ms: i64,
    #[prost(string, tag = "9")]
    pub name: ::prost::alloc::string::String,
    #[prost(uint32, tag = "10")]
    pub version: u32,
    #[prost(message, optional, tag = "11")]
    pub permission: ::core::option::Option<ParticipantPermission>,
    #[prost(string, tag = "12")]
    pub region: ::prost::alloc::string::String,
    /// indicates the participant has an active publisher connection
    /// and can publish to the server
    #[prost(bool, tag = "13")]
    pub is_publisher: bool,
    #[prost(enumeration = "participant_info::Kind", tag = "14")]
    pub kind: i32,
    #[prost(map = "string, string", tag = "15")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    #[prost(enumeration = "DisconnectReason", tag = "16")]
    pub disconnect_reason: i32,
    #[prost(enumeration = "participant_info::KindDetail", repeated, tag = "18")]
    pub kind_details: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, repeated, tag = "19")]
    pub data_tracks: ::prost::alloc::vec::Vec<DataTrackInfo>,
    /// protocol version used for client feature compatibility
    #[prost(int32, tag = "20")]
    pub client_protocol: i32,
    /// capabilities the participant's client advertises, mirrored from ClientInfo.
    /// Lets other participants perform client-side feature detection.
    #[prost(enumeration = "client_info::Capability", repeated, tag = "21")]
    pub capabilities: ::prost::alloc::vec::Vec<i32>,
}
/// Nested message and enum types in `ParticipantInfo`.
pub mod participant_info {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum State {
        /// websocket' connected, but not offered yet
        Joining = 0,
        /// server received client offer
        Joined = 1,
        /// ICE connectivity established
        Active = 2,
        /// WS disconnected
        Disconnected = 3,
    }
    impl State {
        /// 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 {
                Self::Joining => "JOINING",
                Self::Joined => "JOINED",
                Self::Active => "ACTIVE",
                Self::Disconnected => "DISCONNECTED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "JOINING" => Some(Self::Joining),
                "JOINED" => Some(Self::Joined),
                "ACTIVE" => Some(Self::Active),
                "DISCONNECTED" => Some(Self::Disconnected),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Kind {
        /// standard participants, e.g. web clients
        Standard = 0,
        /// only ingests streams
        Ingress = 1,
        /// only consumes streams
        Egress = 2,
        /// SIP participants
        Sip = 3,
        /// LiveKit agents
        Agent = 4,
        /// Connectors participants
        Connector = 7,
        /// Bridge participants
        ///
        /// NEXT_ID: 9
        Bridge = 8,
    }
    impl Kind {
        /// 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 {
                Self::Standard => "STANDARD",
                Self::Ingress => "INGRESS",
                Self::Egress => "EGRESS",
                Self::Sip => "SIP",
                Self::Agent => "AGENT",
                Self::Connector => "CONNECTOR",
                Self::Bridge => "BRIDGE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STANDARD" => Some(Self::Standard),
                "INGRESS" => Some(Self::Ingress),
                "EGRESS" => Some(Self::Egress),
                "SIP" => Some(Self::Sip),
                "AGENT" => Some(Self::Agent),
                "CONNECTOR" => Some(Self::Connector),
                "BRIDGE" => Some(Self::Bridge),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum KindDetail {
        CloudAgent = 0,
        Forwarded = 1,
        ConnectorWhatsapp = 2,
        ConnectorTwilio = 3,
        BridgeRtsp = 4,
        /// NEXT_ID: 6
        Simulation = 5,
    }
    impl KindDetail {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::CloudAgent => "CLOUD_AGENT",
                Self::Forwarded => "FORWARDED",
                Self::ConnectorWhatsapp => "CONNECTOR_WHATSAPP",
                Self::ConnectorTwilio => "CONNECTOR_TWILIO",
                Self::BridgeRtsp => "BRIDGE_RTSP",
                Self::Simulation => "SIMULATION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CLOUD_AGENT" => Some(Self::CloudAgent),
                "FORWARDED" => Some(Self::Forwarded),
                "CONNECTOR_WHATSAPP" => Some(Self::ConnectorWhatsapp),
                "CONNECTOR_TWILIO" => Some(Self::ConnectorTwilio),
                "BRIDGE_RTSP" => Some(Self::BridgeRtsp),
                "SIMULATION" => Some(Self::Simulation),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Encryption {
}
/// Nested message and enum types in `Encryption`.
pub mod encryption {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Type {
        None = 0,
        Gcm = 1,
        Custom = 2,
    }
    impl Type {
        /// 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 {
                Self::None => "NONE",
                Self::Gcm => "GCM",
                Self::Custom => "CUSTOM",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "NONE" => Some(Self::None),
                "GCM" => Some(Self::Gcm),
                "CUSTOM" => Some(Self::Custom),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SimulcastCodecInfo {
    #[prost(string, tag = "1")]
    pub mime_type: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub mid: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub cid: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "4")]
    pub layers: ::prost::alloc::vec::Vec<VideoLayer>,
    #[prost(enumeration = "video_layer::Mode", tag = "5")]
    pub video_layer_mode: i32,
    /// cid (client side id for track) could be different between
    /// signalling (AddTrackRequest) and SDP offer. This field
    /// will be populated only if it is different to avoid
    /// duplication and keep the representation concise.
    #[prost(string, tag = "6")]
    pub sdp_cid: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TrackInfo {
    #[prost(string, tag = "1")]
    pub sid: ::prost::alloc::string::String,
    #[prost(enumeration = "TrackType", tag = "2")]
    pub r#type: i32,
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    #[prost(bool, tag = "4")]
    pub muted: bool,
    /// original width of video (unset for audio)
    /// clients may receive a lower resolution version with simulcast
    #[prost(uint32, tag = "5")]
    pub width: u32,
    /// original height of video (unset for audio)
    #[prost(uint32, tag = "6")]
    pub height: u32,
    /// true if track is simulcasted
    ///
    /// see `video_layer_mode` in `codecs`
    #[deprecated]
    #[prost(bool, tag = "7")]
    pub simulcast: bool,
    /// true if DTX (Discontinuous Transmission) is disabled for audio
    ///
    /// deprecated in favor of `audio_features`
    #[deprecated]
    #[prost(bool, tag = "8")]
    pub disable_dtx: bool,
    /// source of media
    #[prost(enumeration = "TrackSource", tag = "9")]
    pub source: i32,
    /// see `codecs` for layers of individual codec
    #[deprecated]
    #[prost(message, repeated, tag = "10")]
    pub layers: ::prost::alloc::vec::Vec<VideoLayer>,
    /// mime type of codec
    #[prost(string, tag = "11")]
    pub mime_type: ::prost::alloc::string::String,
    #[prost(string, tag = "12")]
    pub mid: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "13")]
    pub codecs: ::prost::alloc::vec::Vec<SimulcastCodecInfo>,
    /// deprecated in favor of `audio_features`
    #[deprecated]
    #[prost(bool, tag = "14")]
    pub stereo: bool,
    /// true if RED (Redundant Encoding) is disabled for audio
    #[prost(bool, tag = "15")]
    pub disable_red: bool,
    #[prost(enumeration = "encryption::Type", tag = "16")]
    pub encryption: i32,
    #[prost(string, tag = "17")]
    pub stream: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "18")]
    pub version: ::core::option::Option<TimedVersion>,
    #[prost(enumeration = "AudioTrackFeature", repeated, tag = "19")]
    pub audio_features: ::prost::alloc::vec::Vec<i32>,
    #[prost(enumeration = "BackupCodecPolicy", tag = "20")]
    pub backup_codec_policy: i32,
    #[prost(enumeration = "PacketTrailerFeature", repeated, tag = "21")]
    pub packet_trailer_features: ::prost::alloc::vec::Vec<i32>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::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,
    /// Encoding for frame payloads on this track. If unspecified, the track is untyped.
    #[prost(message, optional, tag = "5")]
    pub frame_encoding: ::core::option::Option<DataTrackFrameEncoding>,
    /// ID of the schema used by frames on this track if the track is typed.
    #[prost(message, optional, tag = "6")]
    pub schema: ::core::option::Option<DataTrackSchemaId>,
}
/// Encoding for frame payloads.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataTrackFrameEncoding {
    #[prost(oneof = "data_track_frame_encoding::Value", tags = "1, 2")]
    pub value: ::core::option::Option<data_track_frame_encoding::Value>,
}
/// Nested message and enum types in `DataTrackFrameEncoding`.
pub mod data_track_frame_encoding {
    /// Well-known encoding for frame payloads.
    ///
    /// Mirrors the well-known message encodings from the MCAP spec:
    /// <https://mcap.dev/spec/registry#message-encodings>
    ///
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum WellKnownFrameEncoding {
        Unspecified = 0,
        /// ROS 1: must be described by `ROS1_MSG` schema encoding.
        Ros1 = 1,
        /// CDR: must be described by `ROS2_MSG`, `ROS2_IDL`, or `OMG_IDL` schema encoding.
        Cdr = 2,
        /// Protocol Buffer: must be described by `PROTOBUF` schema encoding.
        Protobuf = 3,
        /// FlatBuffer: must be described by `FLATBUFFER` schema encoding.
        Flatbuffer = 4,
        /// CBOR: self-describing.
        Cbor = 5,
        /// MessagePack: self-describing.
        Msgpack = 6,
        /// JSON: self-describing or described by `JSON_SCHEMA` schema encoding.
        Json = 7,
    }
    impl WellKnownFrameEncoding {
        /// 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 {
                Self::Unspecified => "WELL_KNOWN_FRAME_ENCODING_UNSPECIFIED",
                Self::Ros1 => "WELL_KNOWN_FRAME_ENCODING_ROS1",
                Self::Cdr => "WELL_KNOWN_FRAME_ENCODING_CDR",
                Self::Protobuf => "WELL_KNOWN_FRAME_ENCODING_PROTOBUF",
                Self::Flatbuffer => "WELL_KNOWN_FRAME_ENCODING_FLATBUFFER",
                Self::Cbor => "WELL_KNOWN_FRAME_ENCODING_CBOR",
                Self::Msgpack => "WELL_KNOWN_FRAME_ENCODING_MSGPACK",
                Self::Json => "WELL_KNOWN_FRAME_ENCODING_JSON",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "WELL_KNOWN_FRAME_ENCODING_UNSPECIFIED" => Some(Self::Unspecified),
                "WELL_KNOWN_FRAME_ENCODING_ROS1" => Some(Self::Ros1),
                "WELL_KNOWN_FRAME_ENCODING_CDR" => Some(Self::Cdr),
                "WELL_KNOWN_FRAME_ENCODING_PROTOBUF" => Some(Self::Protobuf),
                "WELL_KNOWN_FRAME_ENCODING_FLATBUFFER" => Some(Self::Flatbuffer),
                "WELL_KNOWN_FRAME_ENCODING_CBOR" => Some(Self::Cbor),
                "WELL_KNOWN_FRAME_ENCODING_MSGPACK" => Some(Self::Msgpack),
                "WELL_KNOWN_FRAME_ENCODING_JSON" => Some(Self::Json),
                _ => None,
            }
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Value {
        #[prost(enumeration = "WellKnownFrameEncoding", tag = "1")]
        WellKnown(i32),
        /// Identifier of a custom encoding not covered by the well-known cases.
        /// This must be non-empty and no longer than 32 characters.
        #[prost(string, tag = "2")]
        Custom(::prost::alloc::string::String),
    }
}
/// Encoding for schema definition.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataTrackSchemaEncoding {
    #[prost(oneof = "data_track_schema_encoding::Value", tags = "1, 2")]
    pub value: ::core::option::Option<data_track_schema_encoding::Value>,
}
/// Nested message and enum types in `DataTrackSchemaEncoding`.
pub mod data_track_schema_encoding {
    /// Well-known encoding for schema definition.
    ///
    /// Mirrors the well-known schema encodings from the MCAP spec:
    /// <https://mcap.dev/spec/registry#schema-encodings>
    ///
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum WellKnownSchemaEncoding {
        Unspecified = 0,
        /// Protocol Buffer IDL: describes `PROTOBUF` frame encoding.
        Protobuf = 1,
        /// FlatBuffer IDL: describes `FLATBUFFER` frame encoding.
        Flatbuffer = 2,
        /// ROS 1 Message: describes `ROS1` frame encoding.
        Ros1Msg = 3,
        /// ROS 2 Message: describes `CDR` frame encoding.
        Ros2Msg = 4,
        /// ROS 2 IDL: describes `CDR` frame encoding.
        Ros2Idl = 5,
        /// OMG IDL: describes `CDR` frame encoding.
        OmgIdl = 6,
        /// JSON Schema: describes `JSON` frame encoding.
        JsonSchema = 7,
    }
    impl WellKnownSchemaEncoding {
        /// 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 {
                Self::Unspecified => "WELL_KNOWN_SCHEMA_ENCODING_UNSPECIFIED",
                Self::Protobuf => "WELL_KNOWN_SCHEMA_ENCODING_PROTOBUF",
                Self::Flatbuffer => "WELL_KNOWN_SCHEMA_ENCODING_FLATBUFFER",
                Self::Ros1Msg => "WELL_KNOWN_SCHEMA_ENCODING_ROS1_MSG",
                Self::Ros2Msg => "WELL_KNOWN_SCHEMA_ENCODING_ROS2_MSG",
                Self::Ros2Idl => "WELL_KNOWN_SCHEMA_ENCODING_ROS2_IDL",
                Self::OmgIdl => "WELL_KNOWN_SCHEMA_ENCODING_OMG_IDL",
                Self::JsonSchema => "WELL_KNOWN_SCHEMA_ENCODING_JSON_SCHEMA",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "WELL_KNOWN_SCHEMA_ENCODING_UNSPECIFIED" => Some(Self::Unspecified),
                "WELL_KNOWN_SCHEMA_ENCODING_PROTOBUF" => Some(Self::Protobuf),
                "WELL_KNOWN_SCHEMA_ENCODING_FLATBUFFER" => Some(Self::Flatbuffer),
                "WELL_KNOWN_SCHEMA_ENCODING_ROS1_MSG" => Some(Self::Ros1Msg),
                "WELL_KNOWN_SCHEMA_ENCODING_ROS2_MSG" => Some(Self::Ros2Msg),
                "WELL_KNOWN_SCHEMA_ENCODING_ROS2_IDL" => Some(Self::Ros2Idl),
                "WELL_KNOWN_SCHEMA_ENCODING_OMG_IDL" => Some(Self::OmgIdl),
                "WELL_KNOWN_SCHEMA_ENCODING_JSON_SCHEMA" => Some(Self::JsonSchema),
                _ => None,
            }
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Value {
        #[prost(enumeration = "WellKnownSchemaEncoding", tag = "1")]
        WellKnown(i32),
        /// Identifier of a custom encoding not covered by the well-known cases.
        /// This must be non-empty and no longer than 32 characters.
        #[prost(string, tag = "2")]
        Custom(::prost::alloc::string::String),
    }
}
/// Identifier for a data track schema.
///
/// Schemas with the same name but different encodings are distinct.
///
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataTrackSchemaId {
    /// This must be non-empty and no longer than 256 characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub encoding: ::core::option::Option<DataTrackSchemaEncoding>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataTrackExtensionParticipantSid {
    #[prost(enumeration = "DataTrackExtensionId", tag = "1")]
    pub id: i32,
    #[prost(string, tag = "2")]
    pub participant_sid: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::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<u32>,
}
/// Key used to uniquely identify a data blob for storage and retrieval.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataBlobKey {
    #[prost(oneof = "data_blob_key::Key", tags = "1, 2")]
    pub key: ::core::option::Option<data_blob_key::Key>,
}
/// Nested message and enum types in `DataBlobKey`.
pub mod data_blob_key {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Key {
        /// Generic string key, blob contains arbitrary data.
        #[prost(string, tag = "1")]
        Generic(::prost::alloc::string::String),
        /// Data track schema identifier, blob contains schema definition.
        #[prost(message, tag = "2")]
        SchemaId(super::DataTrackSchemaId),
    }
}
/// A blob of data stored in a room identified by a unique key.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataBlob {
    /// Unique key the data blob is identified by.
    #[prost(message, optional, tag = "1")]
    pub key: ::core::option::Option<DataBlobKey>,
    /// Contents of the data blob. This must not exceed 50 KB.
    #[prost(bytes = "vec", tag = "2")]
    pub contents: ::prost::alloc::vec::Vec<u8>,
}
/// provide information about available spatial layers
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VideoLayer {
    /// for tracks with a single layer, this should be HIGH
    #[prost(enumeration = "VideoQuality", tag = "1")]
    pub quality: i32,
    #[prost(uint32, tag = "2")]
    pub width: u32,
    #[prost(uint32, tag = "3")]
    pub height: u32,
    /// target bitrate in bit per second (bps), server will measure actual
    #[prost(uint32, tag = "4")]
    pub bitrate: u32,
    #[prost(uint32, tag = "5")]
    pub ssrc: u32,
    #[prost(int32, tag = "6")]
    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 {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Mode {
        Unused = 0,
        OneSpatialLayerPerStream = 1,
        MultipleSpatialLayersPerStream = 2,
        OneSpatialLayerPerStreamIncompleteRtcpSr = 3,
    }
    impl Mode {
        /// 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 {
                Self::Unused => "MODE_UNUSED",
                Self::OneSpatialLayerPerStream => "ONE_SPATIAL_LAYER_PER_STREAM",
                Self::MultipleSpatialLayersPerStream => "MULTIPLE_SPATIAL_LAYERS_PER_STREAM",
                Self::OneSpatialLayerPerStreamIncompleteRtcpSr => "ONE_SPATIAL_LAYER_PER_STREAM_INCOMPLETE_RTCP_SR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MODE_UNUSED" => Some(Self::Unused),
                "ONE_SPATIAL_LAYER_PER_STREAM" => Some(Self::OneSpatialLayerPerStream),
                "MULTIPLE_SPATIAL_LAYERS_PER_STREAM" => Some(Self::MultipleSpatialLayersPerStream),
                "ONE_SPATIAL_LAYER_PER_STREAM_INCOMPLETE_RTCP_SR" => Some(Self::OneSpatialLayerPerStreamIncompleteRtcpSr),
                _ => None,
            }
        }
    }
}
/// new DataPacket API
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataPacket {
    #[deprecated]
    #[prost(enumeration = "data_packet::Kind", tag = "1")]
    pub kind: i32,
    /// participant identity of user that sent the message
    #[prost(string, tag = "4")]
    pub participant_identity: ::prost::alloc::string::String,
    /// identities of participants who will receive the message (sent to all by default)
    #[prost(string, repeated, tag = "5")]
    pub destination_identities: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// sequence number of reliable packet
    #[prost(uint32, tag = "16")]
    pub sequence: u32,
    /// sid of the user that sent the message
    #[prost(string, tag = "17")]
    pub participant_sid: ::prost::alloc::string::String,
    #[prost(oneof = "data_packet::Value", tags = "2, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 18")]
    pub value: ::core::option::Option<data_packet::Value>,
}
/// Nested message and enum types in `DataPacket`.
pub mod data_packet {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Kind {
        Reliable = 0,
        Lossy = 1,
    }
    impl Kind {
        /// 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 {
                Self::Reliable => "RELIABLE",
                Self::Lossy => "LOSSY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RELIABLE" => Some(Self::Reliable),
                "LOSSY" => Some(Self::Lossy),
                _ => None,
            }
        }
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag = "2")]
        User(super::UserPacket),
        #[deprecated]
        #[prost(message, tag = "3")]
        Speaker(super::ActiveSpeakerUpdate),
        #[prost(message, tag = "6")]
        SipDtmf(super::SipDtmf),
        #[prost(message, tag = "7")]
        Transcription(super::Transcription),
        #[prost(message, tag = "8")]
        Metrics(super::MetricsBatch),
        #[prost(message, tag = "9")]
        ChatMessage(super::ChatMessage),
        #[prost(message, tag = "10")]
        RpcRequest(super::RpcRequest),
        #[prost(message, tag = "11")]
        RpcAck(super::RpcAck),
        #[prost(message, tag = "12")]
        RpcResponse(super::RpcResponse),
        #[prost(message, tag = "13")]
        StreamHeader(super::data_stream::Header),
        #[prost(message, tag = "14")]
        StreamChunk(super::data_stream::Chunk),
        #[prost(message, tag = "15")]
        StreamTrailer(super::data_stream::Trailer),
        #[prost(message, tag = "18")]
        EncryptedPacket(super::EncryptedPacket),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EncryptedPacket {
    #[prost(enumeration = "encryption::Type", tag = "1")]
    pub encryption_type: i32,
    #[prost(bytes = "vec", tag = "2")]
    pub iv: ::prost::alloc::vec::Vec<u8>,
    #[prost(uint32, tag = "3")]
    pub key_index: u32,
    /// This is an encrypted EncryptedPacketPayload message representation
    #[prost(bytes = "vec", tag = "4")]
    pub encrypted_value: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EncryptedPacketPayload {
    #[prost(oneof = "encrypted_packet_payload::Value", tags = "1, 3, 4, 5, 6, 7, 8, 9")]
    pub value: ::core::option::Option<encrypted_packet_payload::Value>,
}
/// Nested message and enum types in `EncryptedPacketPayload`.
pub mod encrypted_packet_payload {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag = "1")]
        User(super::UserPacket),
        #[prost(message, tag = "3")]
        ChatMessage(super::ChatMessage),
        #[prost(message, tag = "4")]
        RpcRequest(super::RpcRequest),
        #[prost(message, tag = "5")]
        RpcAck(super::RpcAck),
        #[prost(message, tag = "6")]
        RpcResponse(super::RpcResponse),
        #[prost(message, tag = "7")]
        StreamHeader(super::data_stream::Header),
        #[prost(message, tag = "8")]
        StreamChunk(super::data_stream::Chunk),
        #[prost(message, tag = "9")]
        StreamTrailer(super::data_stream::Trailer),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActiveSpeakerUpdate {
    #[prost(message, repeated, tag = "1")]
    pub speakers: ::prost::alloc::vec::Vec<SpeakerInfo>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SpeakerInfo {
    #[prost(string, tag = "1")]
    pub sid: ::prost::alloc::string::String,
    /// audio level, 0-1.0, 1 is loudest
    #[prost(float, tag = "2")]
    pub level: f32,
    /// true if speaker is currently active
    #[prost(bool, tag = "3")]
    pub active: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UserPacket {
    /// participant ID of user that sent the message
    #[deprecated]
    #[prost(string, tag = "1")]
    pub participant_sid: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(string, tag = "5")]
    pub participant_identity: ::prost::alloc::string::String,
    /// user defined payload
    #[prost(bytes = "vec", tag = "2")]
    pub payload: ::prost::alloc::vec::Vec<u8>,
    /// the ID of the participants who will receive the message (sent to all by default)
    #[deprecated]
    #[prost(string, repeated, tag = "3")]
    pub destination_sids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// identities of participants who will receive the message (sent to all by default)
    #[deprecated]
    #[prost(string, repeated, tag = "6")]
    pub destination_identities: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// topic under which the message was published
    #[prost(string, optional, tag = "4")]
    pub topic: ::core::option::Option<::prost::alloc::string::String>,
    /// Unique ID to identify the message
    #[prost(string, optional, tag = "8")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    /// start and end time allow relating the message to specific media time
    #[prost(uint64, optional, tag = "9")]
    pub start_time: ::core::option::Option<u64>,
    #[prost(uint64, optional, tag = "10")]
    pub end_time: ::core::option::Option<u64>,
    /// added by SDK to enable de-duping of messages, for INTERNAL USE ONLY
    #[prost(bytes = "vec", tag = "11")]
    pub nonce: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipDtmf {
    #[prost(uint32, tag = "3")]
    pub code: u32,
    #[prost(string, tag = "4")]
    pub digit: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Transcription {
    /// Participant that got its speech transcribed
    #[prost(string, tag = "2")]
    pub transcribed_participant_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub track_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "4")]
    pub segments: ::prost::alloc::vec::Vec<TranscriptionSegment>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TranscriptionSegment {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub text: ::prost::alloc::string::String,
    #[prost(uint64, tag = "3")]
    pub start_time: u64,
    #[prost(uint64, tag = "4")]
    pub end_time: u64,
    #[prost(bool, tag = "5")]
    pub r#final: bool,
    #[prost(string, tag = "6")]
    pub language: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ChatMessage {
    /// uuid
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(int64, tag = "2")]
    pub timestamp: i64,
    /// populated only if the intent is to edit/update an existing message
    #[prost(int64, optional, tag = "3")]
    pub edit_timestamp: ::core::option::Option<i64>,
    #[prost(string, tag = "4")]
    pub message: ::prost::alloc::string::String,
    /// true to remove message
    #[prost(bool, tag = "5")]
    pub deleted: bool,
    /// true if the chat message has been generated by an agent from a participant's audio transcription
    #[prost(bool, tag = "6")]
    pub generated: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RpcRequest {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub method: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub payload: ::prost::alloc::string::String,
    #[prost(uint32, tag = "4")]
    pub response_timeout_ms: u32,
    #[prost(uint32, tag = "5")]
    pub version: u32,
    /// Compressed payload data. When set, this field is used instead of `payload`.
    #[prost(bytes = "vec", tag = "6")]
    pub compressed_payload: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RpcAck {
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RpcResponse {
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    #[prost(oneof = "rpc_response::Value", tags = "2, 3, 4")]
    pub value: ::core::option::Option<rpc_response::Value>,
}
/// Nested message and enum types in `RpcResponse`.
pub mod rpc_response {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Value {
        #[prost(string, tag = "2")]
        Payload(::prost::alloc::string::String),
        #[prost(message, tag = "3")]
        Error(super::RpcError),
        /// Compressed payload data. When set, this field is used instead of `payload`.
        #[prost(bytes, tag = "4")]
        CompressedPayload(::prost::alloc::vec::Vec<u8>),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RpcError {
    #[prost(uint32, tag = "1")]
    pub code: u32,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub data: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ParticipantTracks {
    /// participant ID of participant to whom the tracks belong
    #[prost(string, tag = "1")]
    pub participant_sid: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "2")]
    pub track_sids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// details about the server
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ServerInfo {
    #[prost(enumeration = "server_info::Edition", tag = "1")]
    pub edition: i32,
    #[prost(string, tag = "2")]
    pub version: ::prost::alloc::string::String,
    #[prost(int32, tag = "3")]
    pub protocol: i32,
    #[prost(string, tag = "4")]
    pub region: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub node_id: ::prost::alloc::string::String,
    /// additional debugging information. sent only if server is in development mode
    #[prost(string, tag = "6")]
    pub debug_info: ::prost::alloc::string::String,
    #[prost(int32, tag = "7")]
    pub agent_protocol: i32,
}
/// Nested message and enum types in `ServerInfo`.
pub mod server_info {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Edition {
        Standard = 0,
        Cloud = 1,
    }
    impl Edition {
        /// 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 {
                Self::Standard => "Standard",
                Self::Cloud => "Cloud",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "Standard" => Some(Self::Standard),
                "Cloud" => Some(Self::Cloud),
                _ => None,
            }
        }
    }
}
/// details about the client
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ClientInfo {
    #[prost(enumeration = "client_info::Sdk", tag = "1")]
    pub sdk: i32,
    #[prost(string, tag = "2")]
    pub version: ::prost::alloc::string::String,
    #[prost(int32, tag = "3")]
    pub protocol: i32,
    #[prost(string, tag = "4")]
    pub os: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub os_version: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub device_model: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub browser: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub browser_version: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub address: ::prost::alloc::string::String,
    /// wifi, wired, cellular, vpn, empty if not known
    #[prost(string, tag = "10")]
    pub network: ::prost::alloc::string::String,
    /// comma separated list of additional LiveKit SDKs in use of this client, with versions
    /// e.g. "components-js:1.2.3,track-processors-js:1.2.3"
    #[prost(string, tag = "11")]
    pub other_sdks: ::prost::alloc::string::String,
    /// client protocol version
    #[prost(int32, tag = "12")]
    pub client_protocol: i32,
    /// capabilities the client advertises. Populated automatically by each SDK;
    /// not a user-configurable setting.
    #[prost(enumeration = "client_info::Capability", repeated, tag = "13")]
    pub capabilities: ::prost::alloc::vec::Vec<i32>,
}
/// Nested message and enum types in `ClientInfo`.
pub mod client_info {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Sdk {
        Unknown = 0,
        Js = 1,
        Swift = 2,
        Android = 3,
        Flutter = 4,
        Go = 5,
        Unity = 6,
        ReactNative = 7,
        Rust = 8,
        Python = 9,
        Cpp = 10,
        UnityWeb = 11,
        Node = 12,
        Unreal = 13,
        Esp32 = 14,
    }
    impl Sdk {
        /// 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 {
                Self::Unknown => "UNKNOWN",
                Self::Js => "JS",
                Self::Swift => "SWIFT",
                Self::Android => "ANDROID",
                Self::Flutter => "FLUTTER",
                Self::Go => "GO",
                Self::Unity => "UNITY",
                Self::ReactNative => "REACT_NATIVE",
                Self::Rust => "RUST",
                Self::Python => "PYTHON",
                Self::Cpp => "CPP",
                Self::UnityWeb => "UNITY_WEB",
                Self::Node => "NODE",
                Self::Unreal => "UNREAL",
                Self::Esp32 => "ESP32",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UNKNOWN" => Some(Self::Unknown),
                "JS" => Some(Self::Js),
                "SWIFT" => Some(Self::Swift),
                "ANDROID" => Some(Self::Android),
                "FLUTTER" => Some(Self::Flutter),
                "GO" => Some(Self::Go),
                "UNITY" => Some(Self::Unity),
                "REACT_NATIVE" => Some(Self::ReactNative),
                "RUST" => Some(Self::Rust),
                "PYTHON" => Some(Self::Python),
                "CPP" => Some(Self::Cpp),
                "UNITY_WEB" => Some(Self::UnityWeb),
                "NODE" => Some(Self::Node),
                "UNREAL" => Some(Self::Unreal),
                "ESP32" => Some(Self::Esp32),
                _ => None,
            }
        }
    }
    /// Optional capabilities advertised by the client at connect time. The SFU
    /// uses these flags to decide whether to enable features that require
    /// client-side support (e.g. passing RTP packet trailers through to the
    /// subscriber instead of stripping them).
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Capability {
        CapUnused = 0,
        CapPacketTrailer = 1,
        CapCompressionDeflateRaw = 2,
    }
    impl Capability {
        /// 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 {
                Self::CapUnused => "CAP_UNUSED",
                Self::CapPacketTrailer => "CAP_PACKET_TRAILER",
                Self::CapCompressionDeflateRaw => "CAP_COMPRESSION_DEFLATE_RAW",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CAP_UNUSED" => Some(Self::CapUnused),
                "CAP_PACKET_TRAILER" => Some(Self::CapPacketTrailer),
                "CAP_COMPRESSION_DEFLATE_RAW" => Some(Self::CapCompressionDeflateRaw),
                _ => None,
            }
        }
    }
}
/// server provided client configuration
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClientConfiguration {
    #[prost(message, optional, tag = "1")]
    pub video: ::core::option::Option<VideoConfiguration>,
    #[prost(message, optional, tag = "2")]
    pub screen: ::core::option::Option<VideoConfiguration>,
    #[prost(enumeration = "ClientConfigSetting", tag = "3")]
    pub resume_connection: i32,
    #[prost(message, optional, tag = "4")]
    pub disabled_codecs: ::core::option::Option<DisabledCodecs>,
    #[prost(enumeration = "ClientConfigSetting", tag = "5")]
    pub force_relay: i32,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VideoConfiguration {
    #[prost(enumeration = "ClientConfigSetting", tag = "1")]
    pub hardware_encoder: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DisabledCodecs {
    /// disabled for both publish and subscribe
    #[prost(message, repeated, tag = "1")]
    pub codecs: ::prost::alloc::vec::Vec<Codec>,
    /// only disable for publish
    #[prost(message, repeated, tag = "2")]
    pub publish: ::prost::alloc::vec::Vec<Codec>,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RtpDrift {
    #[prost(message, optional, tag = "1")]
    pub start_time: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(double, tag = "3")]
    pub duration: f64,
    #[prost(uint64, tag = "4")]
    pub start_timestamp: u64,
    #[prost(uint64, tag = "5")]
    pub end_timestamp: u64,
    #[prost(uint64, tag = "6")]
    pub rtp_clock_ticks: u64,
    #[prost(int64, tag = "7")]
    pub drift_samples: i64,
    #[prost(double, tag = "8")]
    pub drift_ms: f64,
    #[prost(double, tag = "9")]
    pub clock_rate: f64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RtpStats {
    #[prost(message, optional, tag = "1")]
    pub start_time: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(double, tag = "3")]
    pub duration: f64,
    #[prost(uint32, tag = "4")]
    pub packets: u32,
    #[prost(double, tag = "5")]
    pub packet_rate: f64,
    #[prost(uint64, tag = "6")]
    pub bytes: u64,
    #[prost(uint64, tag = "39")]
    pub header_bytes: u64,
    #[prost(double, tag = "7")]
    pub bitrate: f64,
    #[prost(uint32, tag = "8")]
    pub packets_lost: u32,
    #[prost(double, tag = "9")]
    pub packet_loss_rate: f64,
    #[prost(float, tag = "10")]
    pub packet_loss_percentage: f32,
    #[prost(uint32, tag = "11")]
    pub packets_duplicate: u32,
    #[prost(double, tag = "12")]
    pub packet_duplicate_rate: f64,
    #[prost(uint64, tag = "13")]
    pub bytes_duplicate: u64,
    #[prost(uint64, tag = "40")]
    pub header_bytes_duplicate: u64,
    #[prost(double, tag = "14")]
    pub bitrate_duplicate: f64,
    #[prost(uint32, tag = "15")]
    pub packets_padding: u32,
    #[prost(double, tag = "16")]
    pub packet_padding_rate: f64,
    #[prost(uint64, tag = "17")]
    pub bytes_padding: u64,
    #[prost(uint64, tag = "41")]
    pub header_bytes_padding: u64,
    #[prost(double, tag = "18")]
    pub bitrate_padding: f64,
    #[prost(uint32, tag = "19")]
    pub packets_out_of_order: u32,
    #[prost(uint32, tag = "20")]
    pub frames: u32,
    #[prost(double, tag = "21")]
    pub frame_rate: f64,
    #[prost(double, tag = "22")]
    pub jitter_current: f64,
    #[prost(double, tag = "23")]
    pub jitter_max: f64,
    #[prost(map = "int32, uint32", tag = "24")]
    pub gap_histogram: ::std::collections::HashMap<i32, u32>,
    #[prost(uint32, tag = "25")]
    pub nacks: u32,
    #[prost(uint32, tag = "37")]
    pub nack_acks: u32,
    #[prost(uint32, tag = "26")]
    pub nack_misses: u32,
    #[prost(uint32, tag = "38")]
    pub nack_repeated: u32,
    #[prost(uint32, tag = "27")]
    pub plis: u32,
    #[prost(message, optional, tag = "28")]
    pub last_pli: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(uint32, tag = "29")]
    pub firs: u32,
    #[prost(message, optional, tag = "30")]
    pub last_fir: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(uint32, tag = "31")]
    pub rtt_current: u32,
    #[prost(uint32, tag = "32")]
    pub rtt_max: u32,
    #[prost(uint32, tag = "33")]
    pub key_frames: u32,
    #[prost(message, optional, tag = "34")]
    pub last_key_frame: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(uint32, tag = "35")]
    pub layer_lock_plis: u32,
    #[prost(message, optional, tag = "36")]
    pub last_layer_lock_pli: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "44")]
    pub packet_drift: ::core::option::Option<RtpDrift>,
    #[prost(message, optional, tag = "45")]
    pub ntp_report_drift: ::core::option::Option<RtpDrift>,
    #[prost(message, optional, tag = "46")]
    pub rebased_report_drift: ::core::option::Option<RtpDrift>,
    /// NEXT_ID: 48
    #[prost(message, optional, tag = "47")]
    pub received_report_drift: ::core::option::Option<RtpDrift>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RtcpSenderReportState {
    #[prost(uint32, tag = "1")]
    pub rtp_timestamp: u32,
    #[prost(uint64, tag = "2")]
    pub rtp_timestamp_ext: u64,
    #[prost(uint64, tag = "3")]
    pub ntp_timestamp: u64,
    /// time at which this happened
    #[prost(int64, tag = "4")]
    pub at: i64,
    #[prost(int64, tag = "5")]
    pub at_adjusted: i64,
    #[prost(uint32, tag = "6")]
    pub packets: u32,
    #[prost(uint64, tag = "7")]
    pub octets: u64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RtpForwarderState {
    #[prost(bool, tag = "1")]
    pub started: bool,
    #[prost(int32, tag = "2")]
    pub reference_layer_spatial: i32,
    #[prost(int64, tag = "3")]
    pub pre_start_time: i64,
    #[prost(uint64, tag = "4")]
    pub ext_first_timestamp: u64,
    #[prost(uint64, tag = "5")]
    pub dummy_start_timestamp_offset: u64,
    #[prost(message, optional, tag = "6")]
    pub rtp_munger: ::core::option::Option<RtpMungerState>,
    #[prost(message, repeated, tag = "8")]
    pub sender_report_state: ::prost::alloc::vec::Vec<RtcpSenderReportState>,
    #[prost(oneof = "rtp_forwarder_state::CodecMunger", tags = "7")]
    pub codec_munger: ::core::option::Option<rtp_forwarder_state::CodecMunger>,
}
/// Nested message and enum types in `RTPForwarderState`.
pub mod rtp_forwarder_state {
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum CodecMunger {
        #[prost(message, tag = "7")]
        Vp8Munger(super::Vp8MungerState),
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RtpMungerState {
    #[prost(uint64, tag = "1")]
    pub ext_last_sequence_number: u64,
    #[prost(uint64, tag = "2")]
    pub ext_second_last_sequence_number: u64,
    #[prost(uint64, tag = "3")]
    pub ext_last_timestamp: u64,
    #[prost(uint64, tag = "4")]
    pub ext_second_last_timestamp: u64,
    #[prost(bool, tag = "5")]
    pub last_marker: bool,
    #[prost(bool, tag = "6")]
    pub second_last_marker: bool,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Vp8MungerState {
    #[prost(int32, tag = "1")]
    pub ext_last_picture_id: i32,
    #[prost(bool, tag = "2")]
    pub picture_id_used: bool,
    #[prost(uint32, tag = "3")]
    pub last_tl0_pic_idx: u32,
    #[prost(bool, tag = "4")]
    pub tl0_pic_idx_used: bool,
    #[prost(bool, tag = "5")]
    pub tid_used: bool,
    #[prost(uint32, tag = "6")]
    pub last_key_idx: u32,
    #[prost(bool, tag = "7")]
    pub key_idx_used: bool,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TimedVersion {
    #[prost(int64, tag = "1")]
    pub unix_micro: i64,
    #[prost(int32, tag = "2")]
    pub ticks: i32,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataStream {
}
/// Nested message and enum types in `DataStream`.
pub mod data_stream {
    /// header properties specific to text streams
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct TextHeader {
        #[prost(enumeration = "OperationType", tag = "1")]
        pub operation_type: i32,
        /// Optional: Version for updates/edits
        #[prost(int32, tag = "2")]
        pub version: i32,
        /// Optional: Reply to specific message
        #[prost(string, tag = "3")]
        pub reply_to_stream_id: ::prost::alloc::string::String,
        /// file attachments for text streams
        #[prost(string, repeated, tag = "4")]
        pub attached_stream_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// true if the text has been generated by an agent from a participant's audio transcription
        #[prost(bool, tag = "5")]
        pub generated: bool,
    }
    /// header properties specific to byte or file streams
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ByteHeader {
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
    }
    /// main DataStream.Header that contains a oneof for specific headers
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Header {
        /// unique identifier for this data stream
        #[prost(string, tag = "1")]
        pub stream_id: ::prost::alloc::string::String,
        /// using int64 for Unix timestamp
        #[prost(int64, tag = "2")]
        pub timestamp: i64,
        #[prost(string, tag = "3")]
        pub topic: ::prost::alloc::string::String,
        #[prost(string, tag = "4")]
        pub mime_type: ::prost::alloc::string::String,
        /// only populated for finite streams, if it's a stream of unknown size this stays empty
        #[prost(uint64, optional, tag = "5")]
        pub total_length: ::core::option::Option<u64>,
        ///   this is set on the DataPacket
        #[deprecated]
        #[prost(enumeration = "super::encryption::Type", tag = "7")]
        pub encryption_type: i32,
        /// user defined attributes map that can carry additional info
        #[prost(map = "string, string", tag = "8")]
        pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
        /// Optional inline content so that a data stream can be sent as a single packet for short payloads.
        ///
        /// content as binary (bytes)
        #[prost(bytes = "vec", optional, tag = "11")]
        pub inline_content: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
        #[prost(enumeration = "CompressionType", tag = "12")]
        pub compression: i32,
        /// oneof to choose between specific header types
        #[prost(oneof = "header::ContentHeader", tags = "9, 10")]
        pub content_header: ::core::option::Option<header::ContentHeader>,
    }
    /// Nested message and enum types in `Header`.
    pub mod header {
        /// oneof to choose between specific header types
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum ContentHeader {
            #[prost(message, tag = "9")]
            TextHeader(super::TextHeader),
            #[prost(message, tag = "10")]
            ByteHeader(super::ByteHeader),
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Chunk {
        /// unique identifier for this data stream to map it to the correct header
        #[prost(string, tag = "1")]
        pub stream_id: ::prost::alloc::string::String,
        #[prost(uint64, tag = "2")]
        pub chunk_index: u64,
        /// content as binary (bytes)
        #[prost(bytes = "vec", tag = "3")]
        pub content: ::prost::alloc::vec::Vec<u8>,
        /// a version indicating that this chunk_index has been retroactively modified and the original one needs to be replaced
        #[prost(int32, tag = "4")]
        pub version: i32,
        /// this is set on the DataPacket
        #[deprecated]
        #[prost(bytes = "vec", optional, tag = "5")]
        pub iv: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Trailer {
        /// unique identifier for this data stream
        #[prost(string, tag = "1")]
        pub stream_id: ::prost::alloc::string::String,
        /// reason why the stream was closed (could contain "error" / "interrupted" / empty for expected end)
        #[prost(string, tag = "2")]
        pub reason: ::prost::alloc::string::String,
        /// finalizing updates for the stream, can also include additional insights for errors or endTime for transcription
        #[prost(map = "string, string", tag = "3")]
        pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    }
    /// enum for operation types (specific to TextHeader)
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum OperationType {
        Create = 0,
        Update = 1,
        Delete = 2,
        Reaction = 3,
    }
    impl OperationType {
        /// 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 {
                Self::Create => "CREATE",
                Self::Update => "UPDATE",
                Self::Delete => "DELETE",
                Self::Reaction => "REACTION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CREATE" => Some(Self::Create),
                "UPDATE" => Some(Self::Update),
                "DELETE" => Some(Self::Delete),
                "REACTION" => Some(Self::Reaction),
                _ => None,
            }
        }
    }
    /// The compression type of the whole data stream
    ///
    /// This will only get populated when send to participants with a
    /// client protocol >= 2 which advertise a client capability of CAP_COMPRESSION_DEFLATE_RAW
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum CompressionType {
        None = 0,
        /// DEFLATE_RAW = DEFLATE without header+checksum/trailer
        DeflateRaw = 1,
    }
    impl CompressionType {
        /// 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 {
                Self::None => "NONE",
                Self::DeflateRaw => "DEFLATE_RAW",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "NONE" => Some(Self::None),
                "DEFLATE_RAW" => Some(Self::DeflateRaw),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FilterParams {
    #[prost(string, repeated, tag = "1")]
    pub include_events: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "2")]
    pub exclude_events: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebhookConfig {
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub signing_key: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub filter_params: ::core::option::Option<FilterParams>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SubscribedAudioCodec {
    #[prost(string, tag = "1")]
    pub codec: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub enabled: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AudioCodec {
    DefaultAc = 0,
    Opus = 1,
    Aac = 2,
    AcMp3 = 3,
}
impl AudioCodec {
    /// 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 {
            Self::DefaultAc => "DEFAULT_AC",
            Self::Opus => "OPUS",
            Self::Aac => "AAC",
            Self::AcMp3 => "AC_MP3",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DEFAULT_AC" => Some(Self::DefaultAc),
            "OPUS" => Some(Self::Opus),
            "AAC" => Some(Self::Aac),
            "AC_MP3" => Some(Self::AcMp3),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum VideoCodec {
    DefaultVc = 0,
    H264Baseline = 1,
    H264Main = 2,
    H264High = 3,
    Vp8 = 4,
}
impl VideoCodec {
    /// 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 {
            Self::DefaultVc => "DEFAULT_VC",
            Self::H264Baseline => "H264_BASELINE",
            Self::H264Main => "H264_MAIN",
            Self::H264High => "H264_HIGH",
            Self::Vp8 => "VP8",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DEFAULT_VC" => Some(Self::DefaultVc),
            "H264_BASELINE" => Some(Self::H264Baseline),
            "H264_MAIN" => Some(Self::H264Main),
            "H264_HIGH" => Some(Self::H264High),
            "VP8" => Some(Self::Vp8),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ImageCodec {
    IcDefault = 0,
    IcJpeg = 1,
}
impl ImageCodec {
    /// 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 {
            Self::IcDefault => "IC_DEFAULT",
            Self::IcJpeg => "IC_JPEG",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "IC_DEFAULT" => Some(Self::IcDefault),
            "IC_JPEG" => Some(Self::IcJpeg),
            _ => None,
        }
    }
}
/// Policy for publisher to handle subscribers that are unable to support the primary codec of a track
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum BackupCodecPolicy {
    /// default behavior, the track prefer to regress to backup codec and all subscribers will receive the backup codec,
    /// the sfu will try to regress codec if possible but not assured.
    PreferRegression = 0,
    /// encoding/send the primary and backup codec simultaneously
    Simulcast = 1,
    /// force the track to regress to backup codec, this option can be used in video conference or the publisher has limited bandwidth/encoding power
    Regression = 2,
}
impl BackupCodecPolicy {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// 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 {
            Self::PreferRegression => "PREFER_REGRESSION",
            Self::Simulcast => "SIMULCAST",
            Self::Regression => "REGRESSION",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PREFER_REGRESSION" => Some(Self::PreferRegression),
            "SIMULCAST" => Some(Self::Simulcast),
            "REGRESSION" => Some(Self::Regression),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TrackType {
    Audio = 0,
    Video = 1,
    Data = 2,
}
impl TrackType {
    /// 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 {
            Self::Audio => "AUDIO",
            Self::Video => "VIDEO",
            Self::Data => "DATA",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AUDIO" => Some(Self::Audio),
            "VIDEO" => Some(Self::Video),
            "DATA" => Some(Self::Data),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TrackSource {
    Unknown = 0,
    Camera = 1,
    Microphone = 2,
    ScreenShare = 3,
    ScreenShareAudio = 4,
}
impl TrackSource {
    /// 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 {
            Self::Unknown => "UNKNOWN",
            Self::Camera => "CAMERA",
            Self::Microphone => "MICROPHONE",
            Self::ScreenShare => "SCREEN_SHARE",
            Self::ScreenShareAudio => "SCREEN_SHARE_AUDIO",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UNKNOWN" => Some(Self::Unknown),
            "CAMERA" => Some(Self::Camera),
            "MICROPHONE" => Some(Self::Microphone),
            "SCREEN_SHARE" => Some(Self::ScreenShare),
            "SCREEN_SHARE_AUDIO" => Some(Self::ScreenShareAudio),
            _ => None,
        }
    }
}
#[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 {
            Self::DteiInvalid => "DTEI_INVALID",
            Self::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<Self> {
        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,
    High = 2,
    Off = 3,
}
impl VideoQuality {
    /// 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 {
            Self::Low => "LOW",
            Self::Medium => "MEDIUM",
            Self::High => "HIGH",
            Self::Off => "OFF",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "LOW" => Some(Self::Low),
            "MEDIUM" => Some(Self::Medium),
            "HIGH" => Some(Self::High),
            "OFF" => Some(Self::Off),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ConnectionQuality {
    Poor = 0,
    Good = 1,
    Excellent = 2,
    Lost = 3,
}
impl ConnectionQuality {
    /// 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 {
            Self::Poor => "POOR",
            Self::Good => "GOOD",
            Self::Excellent => "EXCELLENT",
            Self::Lost => "LOST",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "POOR" => Some(Self::Poor),
            "GOOD" => Some(Self::Good),
            "EXCELLENT" => Some(Self::Excellent),
            "LOST" => Some(Self::Lost),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ClientConfigSetting {
    Unset = 0,
    Disabled = 1,
    Enabled = 2,
}
impl ClientConfigSetting {
    /// 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 {
            Self::Unset => "UNSET",
            Self::Disabled => "DISABLED",
            Self::Enabled => "ENABLED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UNSET" => Some(Self::Unset),
            "DISABLED" => Some(Self::Disabled),
            "ENABLED" => Some(Self::Enabled),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DisconnectReason {
    UnknownReason = 0,
    /// the client initiated the disconnect
    ClientInitiated = 1,
    /// another participant with the same identity has joined the room
    DuplicateIdentity = 2,
    /// the server instance is shutting down
    ServerShutdown = 3,
    /// RoomService.RemoveParticipant was called
    ParticipantRemoved = 4,
    /// RoomService.DeleteRoom was called
    RoomDeleted = 5,
    /// the client is attempting to resume a session, but server is not aware of it
    StateMismatch = 6,
    /// client was unable to connect fully
    JoinFailure = 7,
    /// Cloud-only, the server requested Participant to migrate the connection elsewhere
    Migration = 8,
    /// the signal websocket was closed unexpectedly
    SignalClose = 9,
    /// the room was closed, due to all Standard and Ingress participants having left
    RoomClosed = 10,
    /// SIP callee did not respond in time
    UserUnavailable = 11,
    /// SIP callee rejected the call (busy)
    UserRejected = 12,
    /// SIP protocol failure or unexpected response
    SipTrunkFailure = 13,
    /// server timed out a participant session
    ConnectionTimeout = 14,
    /// media stream failure or media timeout
    MediaFailure = 15,
    /// agent encountered an error
    AgentError = 16,
}
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 {
            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",
            Self::AgentError => "AGENT_ERROR",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UNKNOWN_REASON" => Some(Self::UnknownReason),
            "CLIENT_INITIATED" => Some(Self::ClientInitiated),
            "DUPLICATE_IDENTITY" => Some(Self::DuplicateIdentity),
            "SERVER_SHUTDOWN" => Some(Self::ServerShutdown),
            "PARTICIPANT_REMOVED" => Some(Self::ParticipantRemoved),
            "ROOM_DELETED" => Some(Self::RoomDeleted),
            "STATE_MISMATCH" => Some(Self::StateMismatch),
            "JOIN_FAILURE" => Some(Self::JoinFailure),
            "MIGRATION" => Some(Self::Migration),
            "SIGNAL_CLOSE" => Some(Self::SignalClose),
            "ROOM_CLOSED" => Some(Self::RoomClosed),
            "USER_UNAVAILABLE" => Some(Self::UserUnavailable),
            "USER_REJECTED" => Some(Self::UserRejected),
            "SIP_TRUNK_FAILURE" => Some(Self::SipTrunkFailure),
            "CONNECTION_TIMEOUT" => Some(Self::ConnectionTimeout),
            "MEDIA_FAILURE" => Some(Self::MediaFailure),
            "AGENT_ERROR" => Some(Self::AgentError),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ReconnectReason {
    RrUnknown = 0,
    RrSignalDisconnected = 1,
    RrPublisherFailed = 2,
    RrSubscriberFailed = 3,
    RrSwitchCandidate = 4,
}
impl ReconnectReason {
    /// 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 {
            Self::RrUnknown => "RR_UNKNOWN",
            Self::RrSignalDisconnected => "RR_SIGNAL_DISCONNECTED",
            Self::RrPublisherFailed => "RR_PUBLISHER_FAILED",
            Self::RrSubscriberFailed => "RR_SUBSCRIBER_FAILED",
            Self::RrSwitchCandidate => "RR_SWITCH_CANDIDATE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RR_UNKNOWN" => Some(Self::RrUnknown),
            "RR_SIGNAL_DISCONNECTED" => Some(Self::RrSignalDisconnected),
            "RR_PUBLISHER_FAILED" => Some(Self::RrPublisherFailed),
            "RR_SUBSCRIBER_FAILED" => Some(Self::RrSubscriberFailed),
            "RR_SWITCH_CANDIDATE" => Some(Self::RrSwitchCandidate),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SubscriptionError {
    SeUnknown = 0,
    SeCodecUnsupported = 1,
    SeTrackNotfound = 2,
}
impl SubscriptionError {
    /// 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 {
            Self::SeUnknown => "SE_UNKNOWN",
            Self::SeCodecUnsupported => "SE_CODEC_UNSUPPORTED",
            Self::SeTrackNotfound => "SE_TRACK_NOTFOUND",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SE_UNKNOWN" => Some(Self::SeUnknown),
            "SE_CODEC_UNSUPPORTED" => Some(Self::SeCodecUnsupported),
            "SE_TRACK_NOTFOUND" => Some(Self::SeTrackNotfound),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AudioTrackFeature {
    TfStereo = 0,
    TfNoDtx = 1,
    TfAutoGainControl = 2,
    TfEchoCancellation = 3,
    TfNoiseSuppression = 4,
    TfEnhancedNoiseCancellation = 5,
    /// client will buffer audio once available and send it to the server via bytes stream once connected
    TfPreconnectBuffer = 6,
}
impl AudioTrackFeature {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::TfStereo => "TF_STEREO",
            Self::TfNoDtx => "TF_NO_DTX",
            Self::TfAutoGainControl => "TF_AUTO_GAIN_CONTROL",
            Self::TfEchoCancellation => "TF_ECHO_CANCELLATION",
            Self::TfNoiseSuppression => "TF_NOISE_SUPPRESSION",
            Self::TfEnhancedNoiseCancellation => "TF_ENHANCED_NOISE_CANCELLATION",
            Self::TfPreconnectBuffer => "TF_PRECONNECT_BUFFER",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "TF_STEREO" => Some(Self::TfStereo),
            "TF_NO_DTX" => Some(Self::TfNoDtx),
            "TF_AUTO_GAIN_CONTROL" => Some(Self::TfAutoGainControl),
            "TF_ECHO_CANCELLATION" => Some(Self::TfEchoCancellation),
            "TF_NOISE_SUPPRESSION" => Some(Self::TfNoiseSuppression),
            "TF_ENHANCED_NOISE_CANCELLATION" => Some(Self::TfEnhancedNoiseCancellation),
            "TF_PRECONNECT_BUFFER" => Some(Self::TfPreconnectBuffer),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PacketTrailerFeature {
    PtfUserTimestamp = 0,
    PtfFrameId = 1,
    PtfUserData = 2,
}
impl PacketTrailerFeature {
    /// 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 {
            Self::PtfUserTimestamp => "PTF_USER_TIMESTAMP",
            Self::PtfFrameId => "PTF_FRAME_ID",
            Self::PtfUserData => "PTF_USER_DATA",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PTF_USER_TIMESTAMP" => Some(Self::PtfUserTimestamp),
            "PTF_FRAME_ID" => Some(Self::PtfFrameId),
            "PTF_USER_DATA" => Some(Self::PtfUserData),
            _ => None,
        }
    }
}
// --- Core Request ---

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartEgressRequest {
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
    /// At least one required
    #[prost(message, repeated, tag = "7")]
    pub outputs: ::prost::alloc::vec::Vec<Output>,
    /// Request-level storage default
    #[prost(message, optional, tag = "8")]
    pub storage: ::core::option::Option<StorageConfig>,
    /// Optional additional webhook config
    #[prost(message, repeated, tag = "9")]
    pub webhooks: ::prost::alloc::vec::Vec<WebhookConfig>,
    #[prost(oneof = "start_egress_request::Source", tags = "2, 3, 4")]
    pub source: ::core::option::Option<start_egress_request::Source>,
    /// Optional — default H264_720P_30
    #[prost(oneof = "start_egress_request::Encoding", tags = "5, 6")]
    pub encoding: ::core::option::Option<start_egress_request::Encoding>,
}
/// Nested message and enum types in `StartEgressRequest`.
pub mod start_egress_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        #[prost(message, tag = "2")]
        Template(super::TemplateSource),
        #[prost(message, tag = "3")]
        Web(super::WebSource),
        #[prost(message, tag = "4")]
        Media(super::MediaSource),
    }
    /// Optional — default H264_720P_30
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Encoding {
        #[prost(enumeration = "super::EncodingOptionsPreset", tag = "5")]
        Preset(i32),
        #[prost(message, tag = "6")]
        Advanced(super::EncodingOptions),
    }
}
// --- Source Types ---

/// Room composite recording via layout template.
/// Service generates token, constructs recorder URL, awaits start signal.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TemplateSource {
    #[prost(string, tag = "1")]
    pub layout: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub audio_only: bool,
    #[prost(bool, tag = "3")]
    pub video_only: bool,
    #[prost(string, tag = "4")]
    pub custom_base_url: ::prost::alloc::string::String,
}
/// Record a custom URL via headless browser.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebSource {
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub audio_only: bool,
    #[prost(bool, tag = "3")]
    pub video_only: bool,
    #[prost(bool, tag = "4")]
    pub await_start_signal: bool,
}
/// Capture tracks directly from a room via SDK.
/// Unifies deprecated Participant, TrackComposite, and Track egress.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MediaSource {
    /// TODO: DataConfig data = 4;
    #[prost(message, optional, tag = "3")]
    pub audio: ::core::option::Option<AudioConfig>,
    #[prost(oneof = "media_source::Video", tags = "1, 2")]
    pub video: ::core::option::Option<media_source::Video>,
}
/// Nested message and enum types in `MediaSource`.
pub mod media_source {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Video {
        #[prost(string, tag = "1")]
        VideoTrackId(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        ParticipantVideo(super::ParticipantVideo),
    }
}
// --- Video Configuration ---

#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ParticipantVideo {
    #[prost(string, tag = "1")]
    pub identity: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub prefer_screen_share: bool,
}
// --- Audio Configuration ---

/// Unified audio selection and channel routing.
/// Each route specifies both which audio to capture and which channel to output to.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AudioConfig {
    /// If true, all unmatched audio is recorded to both channels
    #[prost(bool, tag = "1")]
    pub capture_all: bool,
    #[prost(message, repeated, tag = "2")]
    pub routes: ::prost::alloc::vec::Vec<AudioRoute>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AudioRoute {
    #[prost(enumeration = "AudioChannel", tag = "4")]
    pub channel: i32,
    #[prost(oneof = "audio_route::Match", tags = "1, 2, 3")]
    pub r#match: ::core::option::Option<audio_route::Match>,
}
/// Nested message and enum types in `AudioRoute`.
pub mod audio_route {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Match {
        #[prost(string, tag = "1")]
        TrackId(::prost::alloc::string::String),
        #[prost(string, tag = "2")]
        ParticipantIdentity(::prost::alloc::string::String),
        #[prost(enumeration = "super::participant_info::Kind", tag = "3")]
        ParticipantKind(i32),
    }
}
// --- Data Track Configuration ---

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataConfig {
    #[prost(bool, tag = "1")]
    pub capture_all: bool,
    #[prost(message, repeated, tag = "2")]
    pub selectors: ::prost::alloc::vec::Vec<DataSelector>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataSelector {
    #[prost(oneof = "data_selector::Match", tags = "1, 2")]
    pub r#match: ::core::option::Option<data_selector::Match>,
}
/// Nested message and enum types in `DataSelector`.
pub mod data_selector {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Match {
        #[prost(string, tag = "1")]
        TrackId(::prost::alloc::string::String),
        #[prost(string, tag = "2")]
        ParticipantIdentity(::prost::alloc::string::String),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EncodingOptions {
    /// (default 1920)
    #[prost(int32, tag = "1")]
    pub width: i32,
    /// (default 1080)
    #[prost(int32, tag = "2")]
    pub height: i32,
    /// (default 24)
    #[prost(int32, tag = "3")]
    pub depth: i32,
    /// (default 30)
    #[prost(int32, tag = "4")]
    pub framerate: i32,
    /// (default OPUS)
    #[prost(enumeration = "AudioCodec", tag = "5")]
    pub audio_codec: i32,
    /// (default 128)
    #[prost(int32, tag = "6")]
    pub audio_bitrate: i32,
    /// (default 44100)
    #[prost(int32, tag = "7")]
    pub audio_frequency: i32,
    /// (default H264_MAIN)
    #[prost(enumeration = "VideoCodec", tag = "8")]
    pub video_codec: i32,
    /// (default 4500)
    #[prost(int32, tag = "9")]
    pub video_bitrate: i32,
    /// in seconds (default 4s for streaming, segment duration for segmented output, encoder default for files)
    #[prost(double, tag = "10")]
    pub key_frame_interval: f64,
    /// --- Deprecated ---
    ///
    /// quality setting on audio encoder
    #[deprecated]
    #[prost(int32, tag = "11")]
    pub audio_quality: i32,
    /// quality setting on video encoder
    #[deprecated]
    #[prost(int32, tag = "12")]
    pub video_quality: i32,
}
// --- Output Types ---

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Output {
    /// Per-output storage override (falls back to request, then server)
    #[prost(message, optional, tag = "6")]
    pub storage: ::core::option::Option<StorageConfig>,
    #[prost(oneof = "output::Config", tags = "1, 2, 3, 4")]
    pub config: ::core::option::Option<output::Config>,
}
/// Nested message and enum types in `Output`.
pub mod output {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Config {
        #[prost(message, tag = "1")]
        File(super::FileOutput),
        #[prost(message, tag = "2")]
        Stream(super::StreamOutput),
        #[prost(message, tag = "3")]
        Segments(super::SegmentedFileOutput),
        /// TODO: DataOutput data = 5;
        #[prost(message, tag = "4")]
        Images(super::ImageOutput),
    }
}
/// Unified file output — replaces v1 EncodedFileOutput and DirectFileOutput.
/// Whether transcoded depends on encoding options on the request.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FileOutput {
    #[prost(enumeration = "EncodedFileType", tag = "1")]
    pub file_type: i32,
    #[prost(string, tag = "2")]
    pub filepath: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub disable_manifest: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StreamOutput {
    /// required
    #[prost(enumeration = "StreamProtocol", tag = "1")]
    pub protocol: i32,
    /// required
    #[prost(string, repeated, tag = "2")]
    pub urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Used to generate HLS segments or other kind of segmented output
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SegmentedFileOutput {
    /// (optional)
    #[prost(enumeration = "SegmentedFileProtocol", tag = "1")]
    pub protocol: i32,
    /// (optional)
    #[prost(string, tag = "2")]
    pub filename_prefix: ::prost::alloc::string::String,
    /// (optional)
    #[prost(string, tag = "3")]
    pub playlist_name: ::prost::alloc::string::String,
    /// (optional, disabled if not provided). Path of a live playlist
    #[prost(string, tag = "11")]
    pub live_playlist_name: ::prost::alloc::string::String,
    /// in seconds (optional)
    #[prost(uint32, tag = "4")]
    pub segment_duration: u32,
    /// (optional, default INDEX)
    #[prost(enumeration = "SegmentedFileSuffix", tag = "10")]
    pub filename_suffix: i32,
    /// disable upload of manifest file (default false)
    #[prost(bool, tag = "8")]
    pub disable_manifest: bool,
    /// TODO: deprecate
    #[prost(oneof = "segmented_file_output::Output", tags = "5, 6, 7, 9")]
    pub output: ::core::option::Option<segmented_file_output::Output>,
}
/// Nested message and enum types in `SegmentedFileOutput`.
pub mod segmented_file_output {
    /// TODO: deprecate
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Output {
        #[prost(message, tag = "5")]
        S3(super::S3Upload),
        #[prost(message, tag = "6")]
        Gcp(super::GcpUpload),
        #[prost(message, tag = "7")]
        Azure(super::AzureBlobUpload),
        #[prost(message, tag = "9")]
        AliOss(super::AliOssUpload),
    }
}
/// Capture images at a specified interval
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImageOutput {
    /// in seconds (required)
    #[prost(uint32, tag = "1")]
    pub capture_interval: u32,
    /// (optional, defaults to track width)
    #[prost(int32, tag = "2")]
    pub width: i32,
    /// (optional, defaults to track height)
    #[prost(int32, tag = "3")]
    pub height: i32,
    /// (optional)
    #[prost(string, tag = "4")]
    pub filename_prefix: ::prost::alloc::string::String,
    /// (optional, default INDEX)
    #[prost(enumeration = "ImageFileSuffix", tag = "5")]
    pub filename_suffix: i32,
    /// (optional)
    #[prost(enumeration = "ImageCodec", tag = "6")]
    pub image_codec: i32,
    /// disable upload of manifest file (default false)
    #[prost(bool, tag = "7")]
    pub disable_manifest: bool,
    /// TODO: deprecate
    #[prost(oneof = "image_output::Output", tags = "8, 9, 10, 11")]
    pub output: ::core::option::Option<image_output::Output>,
}
/// Nested message and enum types in `ImageOutput`.
pub mod image_output {
    /// TODO: deprecate
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Output {
        #[prost(message, tag = "8")]
        S3(super::S3Upload),
        #[prost(message, tag = "9")]
        Gcp(super::GcpUpload),
        #[prost(message, tag = "10")]
        Azure(super::AzureBlobUpload),
        #[prost(message, tag = "11")]
        AliOss(super::AliOssUpload),
    }
}
// --- Storage ---

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StorageConfig {
    #[prost(oneof = "storage_config::Provider", tags = "1, 2, 3, 4")]
    pub provider: ::core::option::Option<storage_config::Provider>,
}
/// Nested message and enum types in `StorageConfig`.
pub mod storage_config {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Provider {
        #[prost(message, tag = "1")]
        S3(super::S3Upload),
        #[prost(message, tag = "2")]
        Gcp(super::GcpUpload),
        #[prost(message, tag = "3")]
        Azure(super::AzureBlobUpload),
        #[prost(message, tag = "4")]
        AliOss(super::AliOssUpload),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3Upload {
    #[prost(string, tag = "1")]
    pub access_key: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub secret: ::prost::alloc::string::String,
    #[prost(string, tag = "11")]
    pub session_token: ::prost::alloc::string::String,
    /// ARN of the role to assume for file upload. Egress will make an AssumeRole API call using the provided access_key and secret to assume that role. On LiveKit cloud, this is only available on accounts that have the feature enabled
    #[prost(string, tag = "12")]
    pub assume_role_arn: ::prost::alloc::string::String,
    /// ExternalID to use when assuming role for upload
    #[prost(string, tag = "13")]
    pub assume_role_external_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub region: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub endpoint: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub bucket: ::prost::alloc::string::String,
    #[prost(bool, tag = "6")]
    pub force_path_style: bool,
    #[prost(map = "string, string", tag = "7")]
    pub metadata: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    #[prost(string, tag = "8")]
    pub tagging: ::prost::alloc::string::String,
    /// Content-Disposition header
    #[prost(string, tag = "9")]
    pub content_disposition: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "10")]
    pub proxy: ::core::option::Option<ProxyConfig>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GcpUpload {
    /// service account credentials serialized in JSON "credentials.json"
    #[prost(string, tag = "1")]
    pub credentials: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub bucket: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub proxy: ::core::option::Option<ProxyConfig>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AzureBlobUpload {
    #[prost(string, tag = "1")]
    pub account_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub account_key: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub container_name: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AliOssUpload {
    #[prost(string, tag = "1")]
    pub access_key: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub secret: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub region: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub endpoint: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub bucket: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProxyConfig {
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub username: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub password: ::prost::alloc::string::String,
}
// --- Control RPCs ---

#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListEgressRequest {
    /// (optional, filter by room name)
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
    /// (optional, filter by egress ID)
    #[prost(string, tag = "2")]
    pub egress_id: ::prost::alloc::string::String,
    /// (optional, list active egress only)
    #[prost(bool, tag = "3")]
    pub active: bool,
    /// next field id: 5
    #[prost(message, optional, tag = "4")]
    pub page_token: ::core::option::Option<TokenPagination>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEgressResponse {
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<EgressInfo>,
    /// next field id: 3
    #[prost(message, optional, tag = "2")]
    pub next_page_token: ::core::option::Option<TokenPagination>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StopEgressRequest {
    #[prost(string, tag = "1")]
    pub egress_id: ::prost::alloc::string::String,
}
// --- Egress Info ---

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EgressInfo {
    #[prost(string, tag = "1")]
    pub egress_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub room_id: ::prost::alloc::string::String,
    #[prost(string, tag = "13")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(enumeration = "EgressSourceType", tag = "26")]
    pub source_type: i32,
    #[prost(enumeration = "EgressStatus", tag = "3")]
    pub status: i32,
    #[prost(int64, tag = "10")]
    pub started_at: i64,
    #[prost(int64, tag = "11")]
    pub ended_at: i64,
    #[prost(int64, tag = "18")]
    pub updated_at: i64,
    #[prost(message, repeated, tag = "15")]
    pub stream_results: ::prost::alloc::vec::Vec<StreamInfo>,
    #[prost(message, repeated, tag = "16")]
    pub file_results: ::prost::alloc::vec::Vec<FileInfo>,
    #[prost(message, repeated, tag = "17")]
    pub segment_results: ::prost::alloc::vec::Vec<SegmentsInfo>,
    #[prost(message, repeated, tag = "20")]
    pub image_results: ::prost::alloc::vec::Vec<ImagesInfo>,
    #[prost(string, tag = "9")]
    pub error: ::prost::alloc::string::String,
    #[prost(int32, tag = "22")]
    pub error_code: i32,
    #[prost(string, tag = "21")]
    pub details: ::prost::alloc::string::String,
    #[prost(string, tag = "23")]
    pub manifest_location: ::prost::alloc::string::String,
    #[prost(bool, tag = "25")]
    pub backup_storage_used: bool,
    #[prost(int32, tag = "27")]
    pub retry_count: i32,
    #[prost(oneof = "egress_info::Request", tags = "29, 30, 4, 14, 19, 5, 6")]
    pub request: ::core::option::Option<egress_info::Request>,
    // next ID: 31

    /// --- Deprecated ---
    #[prost(oneof = "egress_info::Result", tags = "7, 8, 12")]
    pub result: ::core::option::Option<egress_info::Result>,
}
/// Nested message and enum types in `EgressInfo`.
pub mod egress_info {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Request {
        #[prost(message, tag = "29")]
        Egress(super::StartEgressRequest),
        #[prost(message, tag = "30")]
        Replay(super::ExportReplayRequest),
        /// TODO: deprecate
        #[prost(message, tag = "4")]
        RoomComposite(super::RoomCompositeEgressRequest),
        #[prost(message, tag = "14")]
        Web(super::WebEgressRequest),
        #[prost(message, tag = "19")]
        Participant(super::ParticipantEgressRequest),
        #[prost(message, tag = "5")]
        TrackComposite(super::TrackCompositeEgressRequest),
        #[prost(message, tag = "6")]
        Track(super::TrackEgressRequest),
    }
    // next ID: 31

    /// --- Deprecated ---
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        #[deprecated]
        #[prost(message, tag = "7")]
        Stream(super::StreamInfoList),
        #[deprecated]
        #[prost(message, tag = "8")]
        File(super::FileInfo),
        #[deprecated]
        #[prost(message, tag = "12")]
        Segments(super::SegmentsInfo),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StreamInfo {
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    #[prost(int64, tag = "2")]
    pub started_at: i64,
    #[prost(int64, tag = "3")]
    pub ended_at: i64,
    #[prost(int64, tag = "4")]
    pub duration: i64,
    #[prost(enumeration = "stream_info::Status", tag = "5")]
    pub status: i32,
    #[prost(string, tag = "6")]
    pub error: ::prost::alloc::string::String,
    #[prost(int64, tag = "7")]
    pub last_retry_at: i64,
    #[prost(uint32, tag = "8")]
    pub retries: u32,
}
/// Nested message and enum types in `StreamInfo`.
pub mod stream_info {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Status {
        Active = 0,
        Finished = 1,
        Failed = 2,
    }
    impl Status {
        /// 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 {
                Self::Active => "ACTIVE",
                Self::Finished => "FINISHED",
                Self::Failed => "FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ACTIVE" => Some(Self::Active),
                "FINISHED" => Some(Self::Finished),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FileInfo {
    #[prost(string, tag = "1")]
    pub filename: ::prost::alloc::string::String,
    #[prost(int64, tag = "2")]
    pub started_at: i64,
    #[prost(int64, tag = "3")]
    pub ended_at: i64,
    #[prost(int64, tag = "6")]
    pub duration: i64,
    #[prost(int64, tag = "4")]
    pub size: i64,
    #[prost(string, tag = "5")]
    pub location: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SegmentsInfo {
    #[prost(string, tag = "1")]
    pub playlist_name: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub live_playlist_name: ::prost::alloc::string::String,
    #[prost(int64, tag = "2")]
    pub duration: i64,
    #[prost(int64, tag = "3")]
    pub size: i64,
    #[prost(string, tag = "4")]
    pub playlist_location: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub live_playlist_location: ::prost::alloc::string::String,
    #[prost(int64, tag = "5")]
    pub segment_count: i64,
    #[prost(int64, tag = "6")]
    pub started_at: i64,
    #[prost(int64, tag = "7")]
    pub ended_at: i64,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImagesInfo {
    #[prost(string, tag = "4")]
    pub filename_prefix: ::prost::alloc::string::String,
    #[prost(int64, tag = "1")]
    pub image_count: i64,
    #[prost(int64, tag = "2")]
    pub started_at: i64,
    #[prost(int64, tag = "3")]
    pub ended_at: i64,
}
// --- Auto Egress ---

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoParticipantEgress {
    #[prost(message, repeated, tag = "3")]
    pub file_outputs: ::prost::alloc::vec::Vec<EncodedFileOutput>,
    #[prost(message, repeated, tag = "4")]
    pub segment_outputs: ::prost::alloc::vec::Vec<SegmentedFileOutput>,
    #[prost(oneof = "auto_participant_egress::Options", tags = "1, 2")]
    pub options: ::core::option::Option<auto_participant_egress::Options>,
}
/// Nested message and enum types in `AutoParticipantEgress`.
pub mod auto_participant_egress {
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Options {
        /// (default H264_720P_30)
        #[prost(enumeration = "super::EncodingOptionsPreset", tag = "1")]
        Preset(i32),
        /// (optional)
        #[prost(message, tag = "2")]
        Advanced(super::EncodingOptions),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoTrackEgress {
    /// see docs for templating (default {track_id}-{time})
    #[prost(string, tag = "1")]
    pub filepath: ::prost::alloc::string::String,
    /// disables upload of json manifest file (default false)
    #[prost(bool, tag = "5")]
    pub disable_manifest: bool,
    #[prost(oneof = "auto_track_egress::Output", tags = "2, 3, 4, 6")]
    pub output: ::core::option::Option<auto_track_egress::Output>,
}
/// Nested message and enum types in `AutoTrackEgress`.
pub mod auto_track_egress {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Output {
        #[prost(message, tag = "2")]
        S3(super::S3Upload),
        #[prost(message, tag = "3")]
        Gcp(super::GcpUpload),
        #[prost(message, tag = "4")]
        Azure(super::AzureBlobUpload),
        #[prost(message, tag = "6")]
        AliOss(super::AliOssUpload),
    }
}
// --- Replay Export (message only — RPC defined in cloud_replay.proto) ---

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExportReplayRequest {
    #[prost(string, tag = "1")]
    pub replay_id: ::prost::alloc::string::String,
    #[prost(int64, tag = "2")]
    pub start_offset_ms: i64,
    #[prost(int64, tag = "3")]
    pub end_offset_ms: i64,
    #[prost(message, repeated, tag = "9")]
    pub outputs: ::prost::alloc::vec::Vec<Output>,
    #[prost(message, optional, tag = "10")]
    pub storage: ::core::option::Option<StorageConfig>,
    #[prost(message, repeated, tag = "11")]
    pub webhooks: ::prost::alloc::vec::Vec<WebhookConfig>,
    #[prost(oneof = "export_replay_request::Source", tags = "4, 5, 6")]
    pub source: ::core::option::Option<export_replay_request::Source>,
    #[prost(oneof = "export_replay_request::Encoding", tags = "7, 8")]
    pub encoding: ::core::option::Option<export_replay_request::Encoding>,
}
/// Nested message and enum types in `ExportReplayRequest`.
pub mod export_replay_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        #[prost(message, tag = "4")]
        Template(super::TemplateSource),
        #[prost(message, tag = "5")]
        Web(super::WebSource),
        #[prost(message, tag = "6")]
        Media(super::MediaSource),
    }
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Encoding {
        #[prost(enumeration = "super::EncodingOptionsPreset", tag = "7")]
        Preset(i32),
        #[prost(message, tag = "8")]
        Advanced(super::EncodingOptions),
    }
}
// TODO: deprecate --- V1 ---

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoomCompositeEgressRequest {
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub layout: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub audio_only: bool,
    #[prost(enumeration = "AudioMixing", tag = "15")]
    pub audio_mixing: i32,
    #[prost(bool, tag = "4")]
    pub video_only: bool,
    #[prost(string, tag = "5")]
    pub custom_base_url: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "11")]
    pub file_outputs: ::prost::alloc::vec::Vec<EncodedFileOutput>,
    #[prost(message, repeated, tag = "12")]
    pub stream_outputs: ::prost::alloc::vec::Vec<StreamOutput>,
    #[prost(message, repeated, tag = "13")]
    pub segment_outputs: ::prost::alloc::vec::Vec<SegmentedFileOutput>,
    #[prost(message, repeated, tag = "14")]
    pub image_outputs: ::prost::alloc::vec::Vec<ImageOutput>,
    #[prost(message, repeated, tag = "16")]
    pub webhooks: ::prost::alloc::vec::Vec<WebhookConfig>,
    #[prost(oneof = "room_composite_egress_request::Output", tags = "6, 7, 10")]
    pub output: ::core::option::Option<room_composite_egress_request::Output>,
    #[prost(oneof = "room_composite_egress_request::Options", tags = "8, 9")]
    pub options: ::core::option::Option<room_composite_egress_request::Options>,
}
/// Nested message and enum types in `RoomCompositeEgressRequest`.
pub mod room_composite_egress_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Output {
        #[deprecated]
        #[prost(message, tag = "6")]
        File(super::EncodedFileOutput),
        #[deprecated]
        #[prost(message, tag = "7")]
        Stream(super::StreamOutput),
        #[deprecated]
        #[prost(message, tag = "10")]
        Segments(super::SegmentedFileOutput),
    }
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Options {
        #[prost(enumeration = "super::EncodingOptionsPreset", tag = "8")]
        Preset(i32),
        #[prost(message, tag = "9")]
        Advanced(super::EncodingOptions),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebEgressRequest {
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub audio_only: bool,
    #[prost(bool, tag = "3")]
    pub video_only: bool,
    #[prost(bool, tag = "12")]
    pub await_start_signal: bool,
    #[prost(message, repeated, tag = "9")]
    pub file_outputs: ::prost::alloc::vec::Vec<EncodedFileOutput>,
    #[prost(message, repeated, tag = "10")]
    pub stream_outputs: ::prost::alloc::vec::Vec<StreamOutput>,
    #[prost(message, repeated, tag = "11")]
    pub segment_outputs: ::prost::alloc::vec::Vec<SegmentedFileOutput>,
    #[prost(message, repeated, tag = "13")]
    pub image_outputs: ::prost::alloc::vec::Vec<ImageOutput>,
    #[prost(message, repeated, tag = "14")]
    pub webhooks: ::prost::alloc::vec::Vec<WebhookConfig>,
    #[prost(oneof = "web_egress_request::Output", tags = "4, 5, 6")]
    pub output: ::core::option::Option<web_egress_request::Output>,
    #[prost(oneof = "web_egress_request::Options", tags = "7, 8")]
    pub options: ::core::option::Option<web_egress_request::Options>,
}
/// Nested message and enum types in `WebEgressRequest`.
pub mod web_egress_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Output {
        #[deprecated]
        #[prost(message, tag = "4")]
        File(super::EncodedFileOutput),
        #[deprecated]
        #[prost(message, tag = "5")]
        Stream(super::StreamOutput),
        #[deprecated]
        #[prost(message, tag = "6")]
        Segments(super::SegmentedFileOutput),
    }
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Options {
        #[prost(enumeration = "super::EncodingOptionsPreset", tag = "7")]
        Preset(i32),
        #[prost(message, tag = "8")]
        Advanced(super::EncodingOptions),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParticipantEgressRequest {
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub identity: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub screen_share: bool,
    #[prost(message, repeated, tag = "6")]
    pub file_outputs: ::prost::alloc::vec::Vec<EncodedFileOutput>,
    #[prost(message, repeated, tag = "7")]
    pub stream_outputs: ::prost::alloc::vec::Vec<StreamOutput>,
    #[prost(message, repeated, tag = "8")]
    pub segment_outputs: ::prost::alloc::vec::Vec<SegmentedFileOutput>,
    #[prost(message, repeated, tag = "9")]
    pub image_outputs: ::prost::alloc::vec::Vec<ImageOutput>,
    #[prost(message, repeated, tag = "10")]
    pub webhooks: ::prost::alloc::vec::Vec<WebhookConfig>,
    #[prost(oneof = "participant_egress_request::Options", tags = "4, 5")]
    pub options: ::core::option::Option<participant_egress_request::Options>,
}
/// Nested message and enum types in `ParticipantEgressRequest`.
pub mod participant_egress_request {
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Options {
        #[prost(enumeration = "super::EncodingOptionsPreset", tag = "4")]
        Preset(i32),
        #[prost(message, tag = "5")]
        Advanced(super::EncodingOptions),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TrackCompositeEgressRequest {
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub audio_track_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub video_track_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "11")]
    pub file_outputs: ::prost::alloc::vec::Vec<EncodedFileOutput>,
    #[prost(message, repeated, tag = "12")]
    pub stream_outputs: ::prost::alloc::vec::Vec<StreamOutput>,
    #[prost(message, repeated, tag = "13")]
    pub segment_outputs: ::prost::alloc::vec::Vec<SegmentedFileOutput>,
    #[prost(message, repeated, tag = "14")]
    pub image_outputs: ::prost::alloc::vec::Vec<ImageOutput>,
    #[prost(message, repeated, tag = "15")]
    pub webhooks: ::prost::alloc::vec::Vec<WebhookConfig>,
    #[prost(oneof = "track_composite_egress_request::Output", tags = "4, 5, 8")]
    pub output: ::core::option::Option<track_composite_egress_request::Output>,
    #[prost(oneof = "track_composite_egress_request::Options", tags = "6, 7")]
    pub options: ::core::option::Option<track_composite_egress_request::Options>,
}
/// Nested message and enum types in `TrackCompositeEgressRequest`.
pub mod track_composite_egress_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Output {
        #[deprecated]
        #[prost(message, tag = "4")]
        File(super::EncodedFileOutput),
        #[deprecated]
        #[prost(message, tag = "5")]
        Stream(super::StreamOutput),
        #[deprecated]
        #[prost(message, tag = "8")]
        Segments(super::SegmentedFileOutput),
    }
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Options {
        #[prost(enumeration = "super::EncodingOptionsPreset", tag = "6")]
        Preset(i32),
        #[prost(message, tag = "7")]
        Advanced(super::EncodingOptions),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TrackEgressRequest {
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub track_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "5")]
    pub webhooks: ::prost::alloc::vec::Vec<WebhookConfig>,
    #[prost(oneof = "track_egress_request::Output", tags = "3, 4")]
    pub output: ::core::option::Option<track_egress_request::Output>,
}
/// Nested message and enum types in `TrackEgressRequest`.
pub mod track_egress_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Output {
        #[prost(message, tag = "3")]
        File(super::DirectFileOutput),
        #[prost(string, tag = "4")]
        WebsocketUrl(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DirectFileOutput {
    #[prost(string, tag = "1")]
    pub filepath: ::prost::alloc::string::String,
    #[prost(bool, tag = "5")]
    pub disable_manifest: bool,
    #[prost(oneof = "direct_file_output::Output", tags = "2, 3, 4, 6")]
    pub output: ::core::option::Option<direct_file_output::Output>,
}
/// Nested message and enum types in `DirectFileOutput`.
pub mod direct_file_output {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Output {
        #[prost(message, tag = "2")]
        S3(super::S3Upload),
        #[prost(message, tag = "3")]
        Gcp(super::GcpUpload),
        #[prost(message, tag = "4")]
        Azure(super::AzureBlobUpload),
        #[prost(message, tag = "6")]
        AliOss(super::AliOssUpload),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EncodedFileOutput {
    #[prost(enumeration = "EncodedFileType", tag = "1")]
    pub file_type: i32,
    #[prost(string, tag = "2")]
    pub filepath: ::prost::alloc::string::String,
    #[prost(bool, tag = "6")]
    pub disable_manifest: bool,
    #[prost(oneof = "encoded_file_output::Output", tags = "3, 4, 5, 7")]
    pub output: ::core::option::Option<encoded_file_output::Output>,
}
/// Nested message and enum types in `EncodedFileOutput`.
pub mod encoded_file_output {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Output {
        #[prost(message, tag = "3")]
        S3(super::S3Upload),
        #[prost(message, tag = "4")]
        Gcp(super::GcpUpload),
        #[prost(message, tag = "5")]
        Azure(super::AzureBlobUpload),
        #[prost(message, tag = "7")]
        AliOss(super::AliOssUpload),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateLayoutRequest {
    #[prost(string, tag = "1")]
    pub egress_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub layout: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateStreamRequest {
    #[prost(string, tag = "1")]
    pub egress_id: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "2")]
    pub add_output_urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "3")]
    pub remove_output_urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamInfoList {
    #[prost(message, repeated, tag = "1")]
    pub info: ::prost::alloc::vec::Vec<StreamInfo>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AudioChannel {
    Both = 0,
    Left = 1,
    Right = 2,
}
impl AudioChannel {
    /// 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 {
            Self::Both => "AUDIO_CHANNEL_BOTH",
            Self::Left => "AUDIO_CHANNEL_LEFT",
            Self::Right => "AUDIO_CHANNEL_RIGHT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AUDIO_CHANNEL_BOTH" => Some(Self::Both),
            "AUDIO_CHANNEL_LEFT" => Some(Self::Left),
            "AUDIO_CHANNEL_RIGHT" => Some(Self::Right),
            _ => None,
        }
    }
}
// --- Encoding ---

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EncodingOptionsPreset {
    ///   1280x720, 30fps, 3000kpbs, H.264_MAIN / OPUS
    H264720p30 = 0,
    ///   1280x720, 60fps, 4500kbps, H.264_MAIN / OPUS
    H264720p60 = 1,
    /// 1920x1080, 30fps, 4500kbps, H.264_MAIN / OPUS
    H2641080p30 = 2,
    /// 1920x1080, 60fps, 6000kbps, H.264_MAIN / OPUS
    H2641080p60 = 3,
    ///   720x1280, 30fps, 3000kpbs, H.264_MAIN / OPUS
    PortraitH264720p30 = 4,
    ///   720x1280, 60fps, 4500kbps, H.264_MAIN / OPUS
    PortraitH264720p60 = 5,
    /// 1080x1920, 30fps, 4500kbps, H.264_MAIN / OPUS
    PortraitH2641080p30 = 6,
    /// 1080x1920, 60fps, 6000kbps, H.264_MAIN / OPUS
    PortraitH2641080p60 = 7,
    /// Skip transcoding. Valid only when specifying a single track with MediaSource
    Passthrough = 8,
}
impl EncodingOptionsPreset {
    /// 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 {
            Self::H264720p30 => "H264_720P_30",
            Self::H264720p60 => "H264_720P_60",
            Self::H2641080p30 => "H264_1080P_30",
            Self::H2641080p60 => "H264_1080P_60",
            Self::PortraitH264720p30 => "PORTRAIT_H264_720P_30",
            Self::PortraitH264720p60 => "PORTRAIT_H264_720P_60",
            Self::PortraitH2641080p30 => "PORTRAIT_H264_1080P_30",
            Self::PortraitH2641080p60 => "PORTRAIT_H264_1080P_60",
            Self::Passthrough => "PASSTHROUGH",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "H264_720P_30" => Some(Self::H264720p30),
            "H264_720P_60" => Some(Self::H264720p60),
            "H264_1080P_30" => Some(Self::H2641080p30),
            "H264_1080P_60" => Some(Self::H2641080p60),
            "PORTRAIT_H264_720P_30" => Some(Self::PortraitH264720p30),
            "PORTRAIT_H264_720P_60" => Some(Self::PortraitH264720p60),
            "PORTRAIT_H264_1080P_30" => Some(Self::PortraitH2641080p30),
            "PORTRAIT_H264_1080P_60" => Some(Self::PortraitH2641080p60),
            "PASSTHROUGH" => Some(Self::Passthrough),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EncodedFileType {
    /// file type chosen based on codecs
    DefaultFiletype = 0,
    Mp4 = 1,
    Ogg = 2,
    Mp3 = 3,
}
impl EncodedFileType {
    /// 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 {
            Self::DefaultFiletype => "DEFAULT_FILETYPE",
            Self::Mp4 => "MP4",
            Self::Ogg => "OGG",
            Self::Mp3 => "MP3",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DEFAULT_FILETYPE" => Some(Self::DefaultFiletype),
            "MP4" => Some(Self::Mp4),
            "OGG" => Some(Self::Ogg),
            "MP3" => Some(Self::Mp3),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum StreamProtocol {
    /// protocol chosen based on urls
    DefaultProtocol = 0,
    Rtmp = 1,
    Srt = 2,
    Websocket = 3,
}
impl StreamProtocol {
    /// 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 {
            Self::DefaultProtocol => "DEFAULT_PROTOCOL",
            Self::Rtmp => "RTMP",
            Self::Srt => "SRT",
            Self::Websocket => "WEBSOCKET",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DEFAULT_PROTOCOL" => Some(Self::DefaultProtocol),
            "RTMP" => Some(Self::Rtmp),
            "SRT" => Some(Self::Srt),
            "WEBSOCKET" => Some(Self::Websocket),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SegmentedFileProtocol {
    DefaultSegmentedFileProtocol = 0,
    HlsProtocol = 1,
}
impl SegmentedFileProtocol {
    /// 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 {
            Self::DefaultSegmentedFileProtocol => "DEFAULT_SEGMENTED_FILE_PROTOCOL",
            Self::HlsProtocol => "HLS_PROTOCOL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DEFAULT_SEGMENTED_FILE_PROTOCOL" => Some(Self::DefaultSegmentedFileProtocol),
            "HLS_PROTOCOL" => Some(Self::HlsProtocol),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SegmentedFileSuffix {
    Index = 0,
    Timestamp = 1,
}
impl SegmentedFileSuffix {
    /// 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 {
            Self::Index => "INDEX",
            Self::Timestamp => "TIMESTAMP",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INDEX" => Some(Self::Index),
            "TIMESTAMP" => Some(Self::Timestamp),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ImageFileSuffix {
    ImageSuffixIndex = 0,
    ImageSuffixTimestamp = 1,
    /// Do not append any suffix and overwrite the existing image with the latest
    ImageSuffixNoneOverwrite = 2,
}
impl ImageFileSuffix {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// 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 {
            Self::ImageSuffixIndex => "IMAGE_SUFFIX_INDEX",
            Self::ImageSuffixTimestamp => "IMAGE_SUFFIX_TIMESTAMP",
            Self::ImageSuffixNoneOverwrite => "IMAGE_SUFFIX_NONE_OVERWRITE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "IMAGE_SUFFIX_INDEX" => Some(Self::ImageSuffixIndex),
            "IMAGE_SUFFIX_TIMESTAMP" => Some(Self::ImageSuffixTimestamp),
            "IMAGE_SUFFIX_NONE_OVERWRITE" => Some(Self::ImageSuffixNoneOverwrite),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EgressSourceType {
    Web = 0,
    Sdk = 1,
}
impl EgressSourceType {
    /// 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 {
            Self::Web => "EGRESS_SOURCE_TYPE_WEB",
            Self::Sdk => "EGRESS_SOURCE_TYPE_SDK",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EGRESS_SOURCE_TYPE_WEB" => Some(Self::Web),
            "EGRESS_SOURCE_TYPE_SDK" => Some(Self::Sdk),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EgressStatus {
    EgressStarting = 0,
    EgressActive = 1,
    EgressEnding = 2,
    EgressComplete = 3,
    EgressFailed = 4,
    EgressAborted = 5,
    EgressLimitReached = 6,
}
impl EgressStatus {
    /// 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 {
            Self::EgressStarting => "EGRESS_STARTING",
            Self::EgressActive => "EGRESS_ACTIVE",
            Self::EgressEnding => "EGRESS_ENDING",
            Self::EgressComplete => "EGRESS_COMPLETE",
            Self::EgressFailed => "EGRESS_FAILED",
            Self::EgressAborted => "EGRESS_ABORTED",
            Self::EgressLimitReached => "EGRESS_LIMIT_REACHED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EGRESS_STARTING" => Some(Self::EgressStarting),
            "EGRESS_ACTIVE" => Some(Self::EgressActive),
            "EGRESS_ENDING" => Some(Self::EgressEnding),
            "EGRESS_COMPLETE" => Some(Self::EgressComplete),
            "EGRESS_FAILED" => Some(Self::EgressFailed),
            "EGRESS_ABORTED" => Some(Self::EgressAborted),
            "EGRESS_LIMIT_REACHED" => Some(Self::EgressLimitReached),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AudioMixing {
    DefaultMixing = 0,
    DualChannelAgent = 1,
    DualChannelAlternate = 2,
}
impl AudioMixing {
    /// 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 {
            Self::DefaultMixing => "DEFAULT_MIXING",
            Self::DualChannelAgent => "DUAL_CHANNEL_AGENT",
            Self::DualChannelAlternate => "DUAL_CHANNEL_ALTERNATE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DEFAULT_MIXING" => Some(Self::DefaultMixing),
            "DUAL_CHANNEL_AGENT" => Some(Self::DualChannelAgent),
            "DUAL_CHANNEL_ALTERNATE" => Some(Self::DualChannelAlternate),
            _ => None,
        }
    }
}
#[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, 19, 20, 21, 22, 23")]
    pub message: ::core::option::Option<signal_request::Message>,
}
/// Nested message and enum types in `SignalRequest`.
pub mod signal_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        /// participant offer for publisher
        #[prost(message, tag = "1")]
        Offer(super::SessionDescription),
        /// participant answering subscriber offer
        #[prost(message, tag = "2")]
        Answer(super::SessionDescription),
        #[prost(message, tag = "3")]
        Trickle(super::TrickleRequest),
        #[prost(message, tag = "4")]
        AddTrack(super::AddTrackRequest),
        /// mute the participant's published tracks
        #[prost(message, tag = "5")]
        Mute(super::MuteTrackRequest),
        /// Subscribe or unsubscribe from tracks
        #[prost(message, tag = "6")]
        Subscription(super::UpdateSubscription),
        /// Update settings of subscribed tracks
        #[prost(message, tag = "7")]
        TrackSetting(super::UpdateTrackSettings),
        /// Immediately terminate session
        #[prost(message, tag = "8")]
        Leave(super::LeaveRequest),
        /// Update published video layers
        #[deprecated]
        #[prost(message, tag = "10")]
        UpdateLayers(super::UpdateVideoLayers),
        /// Update subscriber permissions
        #[prost(message, tag = "11")]
        SubscriptionPermission(super::SubscriptionPermission),
        /// sync client's subscribe state to server during reconnect
        #[prost(message, tag = "12")]
        SyncState(super::SyncState),
        /// Simulate conditions, for client validations
        #[prost(message, tag = "13")]
        Simulate(super::SimulateScenario),
        /// client triggered ping to server
        ///
        /// deprecated by ping_req (message Ping)
        #[prost(int64, tag = "14")]
        Ping(i64),
        /// update a participant's own metadata, name, or attributes
        /// requires canUpdateOwnParticipantMetadata permission
        #[prost(message, tag = "15")]
        UpdateMetadata(super::UpdateParticipantMetadata),
        #[prost(message, tag = "16")]
        PingReq(super::Ping),
        /// Update local audio track settings
        #[prost(message, tag = "17")]
        UpdateAudioTrack(super::UpdateLocalAudioTrack),
        /// 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),
        /// Store a data blob.
        #[prost(message, tag = "22")]
        StoreDataBlobRequest(super::StoreDataBlobRequest),
        /// Retrieve a stored data blob.
        #[prost(message, tag = "23")]
        GetDataBlobRequest(super::GetDataBlobRequest),
    }
}
#[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, 27, 28, 29, 30, 31")]
    pub message: ::core::option::Option<signal_response::Message>,
}
/// Nested message and enum types in `SignalResponse`.
pub mod signal_response {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        /// sent when join is accepted
        #[prost(message, tag = "1")]
        Join(super::JoinResponse),
        /// sent when server answers publisher
        #[prost(message, tag = "2")]
        Answer(super::SessionDescription),
        /// sent when server is sending subscriber an offer
        #[prost(message, tag = "3")]
        Offer(super::SessionDescription),
        /// sent when an ICE candidate is available
        #[prost(message, tag = "4")]
        Trickle(super::TrickleRequest),
        /// sent when participants in the room has changed
        #[prost(message, tag = "5")]
        Update(super::ParticipantUpdate),
        /// sent to the participant when their track has been published
        #[prost(message, tag = "6")]
        TrackPublished(super::TrackPublishedResponse),
        /// Immediately terminate session
        #[prost(message, tag = "8")]
        Leave(super::LeaveRequest),
        /// server initiated mute
        #[prost(message, tag = "9")]
        Mute(super::MuteTrackRequest),
        /// indicates changes to speaker status, including when they've gone to not speaking
        #[prost(message, tag = "10")]
        SpeakersChanged(super::SpeakersChanged),
        /// sent when metadata of the room has changed
        #[prost(message, tag = "11")]
        RoomUpdate(super::RoomUpdate),
        /// when connection quality changed
        #[prost(message, tag = "12")]
        ConnectionQuality(super::ConnectionQualityUpdate),
        /// when streamed tracks state changed, used to notify when any of the streams were paused due to
        /// congestion
        #[prost(message, tag = "13")]
        StreamStateUpdate(super::StreamStateUpdate),
        /// when max subscribe quality changed, used by dynamic broadcasting to disable unused layers
        #[prost(message, tag = "14")]
        SubscribedQualityUpdate(super::SubscribedQualityUpdate),
        /// when subscription permission changed
        #[prost(message, tag = "15")]
        SubscriptionPermissionUpdate(super::SubscriptionPermissionUpdate),
        /// update the token the client was using, to prevent an active client from using an expired token
        #[prost(string, tag = "16")]
        RefreshToken(::prost::alloc::string::String),
        /// server initiated track unpublish
        #[prost(message, tag = "17")]
        TrackUnpublished(super::TrackUnpublishedResponse),
        /// respond to ping
        ///
        /// deprecated by pong_resp (message Pong)
        #[prost(int64, tag = "18")]
        Pong(i64),
        /// sent when client reconnects
        #[prost(message, tag = "19")]
        Reconnect(super::ReconnectResponse),
        /// respond to Ping
        #[prost(message, tag = "20")]
        PongResp(super::Pong),
        /// Subscription response, client should not expect any media from this subscription if it fails
        #[prost(message, tag = "21")]
        SubscriptionResponse(super::SubscriptionResponse),
        /// Response relating to user inititated requests that carry a `request_id`
        #[prost(message, tag = "22")]
        RequestResponse(super::RequestResponse),
        /// notify to the publisher when a published track has been subscribed for the first time
        #[prost(message, tag = "23")]
        TrackSubscribed(super::TrackSubscribed),
        /// notify to the participant when they have been moved to a new room
        #[prost(message, tag = "24")]
        RoomMoved(super::RoomMovedResponse),
        /// notify number of required media sections to satisfy subscribed tracks
        #[prost(message, tag = "25")]
        MediaSectionsRequirement(super::MediaSectionsRequirement),
        /// 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),
        /// Sent in response to `StoreDataBlobRequest`.
        #[prost(message, tag = "30")]
        StoreDataBlobResponse(super::StoreDataBlobResponse),
        /// Sent in response to `GetDataBlobRequest`.
        #[prost(message, tag = "31")]
        GetDataBlobResponse(super::GetDataBlobResponse),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SimulcastCodec {
    #[prost(string, tag = "1")]
    pub codec: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub cid: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "4")]
    pub layers: ::prost::alloc::vec::Vec<VideoLayer>,
    #[prost(enumeration = "video_layer::Mode", tag = "5")]
    pub video_layer_mode: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddTrackRequest {
    /// client ID of track, to match it when RTC track is received
    #[prost(string, tag = "1")]
    pub cid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(enumeration = "TrackType", tag = "3")]
    pub r#type: i32,
    #[prost(uint32, tag = "4")]
    pub width: u32,
    #[prost(uint32, tag = "5")]
    pub height: u32,
    /// true to add track and initialize to muted
    #[prost(bool, tag = "6")]
    pub muted: bool,
    /// true if DTX (Discontinuous Transmission) is disabled for audio
    ///
    /// deprecated in favor of audio_features
    #[deprecated]
    #[prost(bool, tag = "7")]
    pub disable_dtx: bool,
    #[prost(enumeration = "TrackSource", tag = "8")]
    pub source: i32,
    #[prost(message, repeated, tag = "9")]
    pub layers: ::prost::alloc::vec::Vec<VideoLayer>,
    #[prost(message, repeated, tag = "10")]
    pub simulcast_codecs: ::prost::alloc::vec::Vec<SimulcastCodec>,
    /// server ID of track, publish new codec to exist track
    #[prost(string, tag = "11")]
    pub sid: ::prost::alloc::string::String,
    /// deprecated in favor of audio_features
    #[deprecated]
    #[prost(bool, tag = "12")]
    pub stereo: bool,
    /// true if RED (Redundant Encoding) is disabled for audio
    #[prost(bool, tag = "13")]
    pub disable_red: bool,
    #[prost(enumeration = "encryption::Type", tag = "14")]
    pub encryption: i32,
    /// which stream the track belongs to, used to group tracks together.
    /// if not specified, server will infer it from track source to bundle camera/microphone, screenshare/audio together
    #[prost(string, tag = "15")]
    pub stream: ::prost::alloc::string::String,
    #[prost(enumeration = "BackupCodecPolicy", tag = "16")]
    pub backup_codec_policy: i32,
    #[prost(enumeration = "AudioTrackFeature", repeated, tag = "17")]
    pub audio_features: ::prost::alloc::vec::Vec<i32>,
    #[prost(enumeration = "PacketTrailerFeature", repeated, tag = "18")]
    pub packet_trailer_features: ::prost::alloc::vec::Vec<i32>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::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,
    /// Encoding for frame payloads on this track. If unspecified, the track is untyped.
    #[prost(message, optional, tag = "4")]
    pub frame_encoding: ::core::option::Option<DataTrackFrameEncoding>,
    /// ID of the schema used by frames on this track if the track is typed.
    /// If set, the associated schema must be stored with `StoreDataBlobRequest`.
    #[prost(message, optional, tag = "5")]
    pub schema: ::core::option::Option<DataTrackSchemaId>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PublishDataTrackResponse {
    /// Information about the published track.
    #[prost(message, optional, tag = "1")]
    pub info: ::core::option::Option<DataTrackInfo>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UnpublishDataTrackRequest {
    /// Publisher handle of the track to unpublish.
    #[prost(uint32, tag = "1")]
    pub pub_handle: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UnpublishDataTrackResponse {
    /// Information about the unpublished track.
    #[prost(message, optional, tag = "1")]
    pub info: ::core::option::Option<DataTrackInfo>,
}
#[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<u32, data_track_subscriber_handles::PublishedDataTrack>,
}
/// Nested message and enum types in `DataTrackSubscriberHandles`.
pub mod data_track_subscriber_handles {
    #[derive(Clone, PartialEq, Eq, Hash, ::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,
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TrickleRequest {
    #[prost(string, tag = "1")]
    pub candidate_init: ::prost::alloc::string::String,
    #[prost(enumeration = "SignalTarget", tag = "2")]
    pub target: i32,
    #[prost(bool, tag = "3")]
    pub r#final: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MuteTrackRequest {
    #[prost(string, tag = "1")]
    pub sid: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub muted: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JoinResponse {
    #[prost(message, optional, tag = "1")]
    pub room: ::core::option::Option<Room>,
    #[prost(message, optional, tag = "2")]
    pub participant: ::core::option::Option<ParticipantInfo>,
    #[prost(message, repeated, tag = "3")]
    pub other_participants: ::prost::alloc::vec::Vec<ParticipantInfo>,
    /// deprecated. use server_info.version instead.
    #[prost(string, tag = "4")]
    pub server_version: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "5")]
    pub ice_servers: ::prost::alloc::vec::Vec<IceServer>,
    /// use subscriber as the primary PeerConnection
    #[prost(bool, tag = "6")]
    pub subscriber_primary: bool,
    /// when the current server isn't available, return alternate url to retry connection
    /// when this is set, the other fields will be largely empty
    #[prost(string, tag = "7")]
    pub alternative_url: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "8")]
    pub client_configuration: ::core::option::Option<ClientConfiguration>,
    /// deprecated. use server_info.region instead.
    #[prost(string, tag = "9")]
    pub server_region: ::prost::alloc::string::String,
    #[prost(int32, tag = "10")]
    pub ping_timeout: i32,
    #[prost(int32, tag = "11")]
    pub ping_interval: i32,
    #[prost(message, optional, tag = "12")]
    pub server_info: ::core::option::Option<ServerInfo>,
    /// Server-Injected-Frame byte trailer, used to identify unencrypted frames when e2ee is enabled
    #[prost(bytes = "vec", tag = "13")]
    pub sif_trailer: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, repeated, tag = "14")]
    pub enabled_publish_codecs: ::prost::alloc::vec::Vec<Codec>,
    /// when set, client should attempt to establish publish peer connection when joining room to speed up publishing
    #[prost(bool, tag = "15")]
    pub fast_publish: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReconnectResponse {
    #[prost(message, repeated, tag = "1")]
    pub ice_servers: ::prost::alloc::vec::Vec<IceServer>,
    #[prost(message, optional, tag = "2")]
    pub client_configuration: ::core::option::Option<ClientConfiguration>,
    #[prost(message, optional, tag = "3")]
    pub server_info: ::core::option::Option<ServerInfo>,
    /// last sequence number of reliable message received before resuming
    #[prost(uint32, tag = "4")]
    pub last_message_seq: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TrackPublishedResponse {
    #[prost(string, tag = "1")]
    pub cid: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub track: ::core::option::Option<TrackInfo>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TrackUnpublishedResponse {
    #[prost(string, tag = "1")]
    pub track_sid: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SessionDescription {
    /// "answer" | "offer" | "pranswer" | "rollback"
    #[prost(string, tag = "1")]
    pub r#type: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub sdp: ::prost::alloc::string::String,
    #[prost(uint32, tag = "3")]
    pub id: u32,
    #[prost(map = "string, string", tag = "4")]
    pub mid_to_track_id: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParticipantUpdate {
    #[prost(message, repeated, tag = "1")]
    pub participants: ::prost::alloc::vec::Vec<ParticipantInfo>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSubscription {
    #[prost(string, repeated, tag = "1")]
    pub track_sids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(bool, tag = "2")]
    pub subscribe: bool,
    #[prost(message, repeated, tag = "3")]
    pub participant_tracks: ::prost::alloc::vec::Vec<ParticipantTracks>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateDataSubscription {
    #[prost(message, repeated, tag = "1")]
    pub updates: ::prost::alloc::vec::Vec<update_data_subscription::Update>,
}
/// Nested message and enum types in `UpdateDataSubscription`.
pub mod update_data_subscription {
    #[derive(Clone, PartialEq, Eq, Hash, ::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<super::DataTrackSubscriptionOptions>,
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StoreDataBlobRequest {
    #[prost(uint32, tag = "1")]
    pub request_id: u32,
    #[prost(message, optional, tag = "2")]
    pub blob: ::core::option::Option<DataBlob>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StoreDataBlobResponse {
    #[prost(uint32, tag = "1")]
    pub request_id: u32,
    /// Unique key the data blob was stored under.
    #[prost(message, optional, tag = "2")]
    pub key: ::core::option::Option<DataBlobKey>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDataBlobRequest {
    #[prost(uint32, tag = "1")]
    pub request_id: u32,
    /// Identity of the participant who owns the blob.
    #[prost(string, tag = "2")]
    pub participant_identity: ::prost::alloc::string::String,
    /// Unique key of the data blob to retrieve.
    #[prost(message, optional, tag = "3")]
    pub key: ::core::option::Option<DataBlobKey>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDataBlobResponse {
    #[prost(uint32, tag = "1")]
    pub request_id: u32,
    #[prost(message, optional, tag = "2")]
    pub blob: ::core::option::Option<DataBlob>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateTrackSettings {
    #[prost(string, repeated, tag = "1")]
    pub track_sids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// when true, the track is placed in a paused state, with no new data returned
    #[prost(bool, tag = "3")]
    pub disabled: bool,
    /// deprecated in favor of width & height
    #[prost(enumeration = "VideoQuality", tag = "4")]
    pub quality: i32,
    /// for video, width to receive
    #[prost(uint32, tag = "5")]
    pub width: u32,
    /// for video, height to receive
    #[prost(uint32, tag = "6")]
    pub height: u32,
    #[prost(uint32, tag = "7")]
    pub fps: u32,
    /// subscription priority. 1 being the highest (0 is unset)
    /// when unset, server sill assign priority based on the order of subscription
    /// server will use priority in the following ways:
    /// 1. when subscribed tracks exceed per-participant subscription limit, server will
    ///     pause the lowest priority tracks
    /// 2. when the network is congested, server will assign available bandwidth to
    ///     higher priority tracks first. lowest priority tracks can be paused
    #[prost(uint32, tag = "8")]
    pub priority: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateLocalAudioTrack {
    #[prost(string, tag = "1")]
    pub track_sid: ::prost::alloc::string::String,
    #[prost(enumeration = "AudioTrackFeature", repeated, tag = "2")]
    pub features: ::prost::alloc::vec::Vec<i32>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateLocalVideoTrack {
    #[prost(string, tag = "1")]
    pub track_sid: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub width: u32,
    #[prost(uint32, tag = "3")]
    pub height: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LeaveRequest {
    /// sent when server initiates the disconnect due to server-restart
    /// indicates clients should attempt full-reconnect sequence
    /// NOTE: `can_reconnect` obsoleted by `action` starting in protocol version 13
    #[prost(bool, tag = "1")]
    pub can_reconnect: bool,
    #[prost(enumeration = "DisconnectReason", tag = "2")]
    pub reason: i32,
    #[prost(enumeration = "leave_request::Action", tag = "3")]
    pub action: i32,
    #[prost(message, optional, tag = "4")]
    pub regions: ::core::option::Option<RegionSettings>,
}
/// Nested message and enum types in `LeaveRequest`.
pub mod leave_request {
    /// indicates action clients should take on receiving this message
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Action {
        /// should disconnect
        Disconnect = 0,
        /// should attempt a resume with `reconnect=1` in join URL
        Resume = 1,
        /// should attempt a reconnect, i. e. no `reconnect=1`
        Reconnect = 2,
    }
    impl Action {
        /// 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 {
                Self::Disconnect => "DISCONNECT",
                Self::Resume => "RESUME",
                Self::Reconnect => "RECONNECT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DISCONNECT" => Some(Self::Disconnect),
                "RESUME" => Some(Self::Resume),
                "RECONNECT" => Some(Self::Reconnect),
                _ => None,
            }
        }
    }
}
/// message to indicate published video track dimensions are changing
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateVideoLayers {
    #[prost(string, tag = "1")]
    pub track_sid: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub layers: ::prost::alloc::vec::Vec<VideoLayer>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateParticipantMetadata {
    #[prost(string, tag = "1")]
    pub metadata: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// attributes to update. it only updates attributes that have been set
    /// to delete attributes, set the value to an empty string
    #[prost(map = "string, string", tag = "3")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    #[prost(uint32, tag = "4")]
    pub request_id: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct IceServer {
    #[prost(string, repeated, tag = "1")]
    pub urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, tag = "2")]
    pub username: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub credential: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SpeakersChanged {
    #[prost(message, repeated, tag = "1")]
    pub speakers: ::prost::alloc::vec::Vec<SpeakerInfo>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoomUpdate {
    #[prost(message, optional, tag = "1")]
    pub room: ::core::option::Option<Room>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionQualityInfo {
    #[prost(string, tag = "1")]
    pub participant_sid: ::prost::alloc::string::String,
    #[prost(enumeration = "ConnectionQuality", tag = "2")]
    pub quality: i32,
    #[prost(float, tag = "3")]
    pub score: f32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionQualityUpdate {
    #[prost(message, repeated, tag = "1")]
    pub updates: ::prost::alloc::vec::Vec<ConnectionQualityInfo>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StreamStateInfo {
    #[prost(string, tag = "1")]
    pub participant_sid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub track_sid: ::prost::alloc::string::String,
    #[prost(enumeration = "StreamState", tag = "3")]
    pub state: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamStateUpdate {
    #[prost(message, repeated, tag = "1")]
    pub stream_states: ::prost::alloc::vec::Vec<StreamStateInfo>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SubscribedQuality {
    #[prost(enumeration = "VideoQuality", tag = "1")]
    pub quality: i32,
    #[prost(bool, tag = "2")]
    pub enabled: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribedCodec {
    #[prost(string, tag = "1")]
    pub codec: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub qualities: ::prost::alloc::vec::Vec<SubscribedQuality>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribedQualityUpdate {
    #[prost(string, tag = "1")]
    pub track_sid: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(message, repeated, tag = "2")]
    pub subscribed_qualities: ::prost::alloc::vec::Vec<SubscribedQuality>,
    #[prost(message, repeated, tag = "3")]
    pub subscribed_codecs: ::prost::alloc::vec::Vec<SubscribedCodec>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscribedAudioCodecUpdate {
    #[prost(string, tag = "1")]
    pub track_sid: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub subscribed_audio_codecs: ::prost::alloc::vec::Vec<SubscribedAudioCodec>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TrackPermission {
    /// permission could be granted either by participant sid or identity
    #[prost(string, tag = "1")]
    pub participant_sid: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub all_tracks: bool,
    #[prost(string, repeated, tag = "3")]
    pub track_sids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, tag = "4")]
    pub participant_identity: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubscriptionPermission {
    #[prost(bool, tag = "1")]
    pub all_participants: bool,
    #[prost(message, repeated, tag = "2")]
    pub track_permissions: ::prost::alloc::vec::Vec<TrackPermission>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SubscriptionPermissionUpdate {
    #[prost(string, tag = "1")]
    pub participant_sid: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub track_sid: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub allowed: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoomMovedResponse {
    /// information about the new room
    #[prost(message, optional, tag = "1")]
    pub room: ::core::option::Option<Room>,
    /// new reconnect token that can be used to reconnect to the new room
    #[prost(string, tag = "2")]
    pub token: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub participant: ::core::option::Option<ParticipantInfo>,
    #[prost(message, repeated, tag = "4")]
    pub other_participants: ::prost::alloc::vec::Vec<ParticipantInfo>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SyncState {
    /// last subscribe/publish answer before reconnecting
    /// subscribe answer if using dual peer connection
    /// publish answer if using single peer connection
    #[prost(message, optional, tag = "1")]
    pub answer: ::core::option::Option<SessionDescription>,
    #[prost(message, optional, tag = "2")]
    pub subscription: ::core::option::Option<UpdateSubscription>,
    #[prost(message, repeated, tag = "3")]
    pub publish_tracks: ::prost::alloc::vec::Vec<TrackPublishedResponse>,
    #[prost(message, repeated, tag = "4")]
    pub data_channels: ::prost::alloc::vec::Vec<DataChannelInfo>,
    /// last received server side offer/sent client side offer before reconnecting
    /// received server side offer if using dual peer connection
    /// sent client side offer if using single peer connection
    #[prost(message, optional, tag = "5")]
    pub offer: ::core::option::Option<SessionDescription>,
    #[prost(string, repeated, tag = "6")]
    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<DataChannelReceiveState>,
    #[prost(message, repeated, tag = "8")]
    pub publish_data_tracks: ::prost::alloc::vec::Vec<PublishDataTrackResponse>,
    #[prost(message, optional, tag = "9")]
    pub data_subscription: ::core::option::Option<UpdateDataSubscription>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataChannelReceiveState {
    #[prost(string, tag = "1")]
    pub publisher_sid: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub last_seq: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataChannelInfo {
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub id: u32,
    #[prost(enumeration = "SignalTarget", tag = "3")]
    pub target: i32,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SimulateScenario {
    #[prost(oneof = "simulate_scenario::Scenario", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9")]
    pub scenario: ::core::option::Option<simulate_scenario::Scenario>,
}
/// Nested message and enum types in `SimulateScenario`.
pub mod simulate_scenario {
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Scenario {
        /// simulate N seconds of speaker activity
        #[prost(int32, tag = "1")]
        SpeakerUpdate(i32),
        /// simulate local node failure
        #[prost(bool, tag = "2")]
        NodeFailure(bool),
        /// simulate migration
        #[prost(bool, tag = "3")]
        Migration(bool),
        /// server to send leave
        #[prost(bool, tag = "4")]
        ServerLeave(bool),
        /// switch candidate protocol to tcp
        #[prost(enumeration = "super::CandidateProtocol", tag = "5")]
        SwitchCandidateProtocol(i32),
        /// maximum bandwidth for subscribers, in bps
        /// when zero, clears artificial bandwidth limit
        #[prost(int64, tag = "6")]
        SubscriberBandwidth(i64),
        /// disconnect signal on resume
        #[prost(bool, tag = "7")]
        DisconnectSignalOnResume(bool),
        /// disconnect signal on resume before sending any messages from server
        #[prost(bool, tag = "8")]
        DisconnectSignalOnResumeNoMessages(bool),
        /// full reconnect leave request
        #[prost(bool, tag = "9")]
        LeaveRequestFullReconnect(bool),
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Ping {
    #[prost(int64, tag = "1")]
    pub timestamp: i64,
    /// rtt in milliseconds calculated by client
    #[prost(int64, tag = "2")]
    pub rtt: i64,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Pong {
    /// timestamp field of last received ping request
    #[prost(int64, tag = "1")]
    pub last_ping_timestamp: i64,
    #[prost(int64, tag = "2")]
    pub timestamp: i64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RegionSettings {
    #[prost(message, repeated, tag = "1")]
    pub regions: ::prost::alloc::vec::Vec<RegionInfo>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegionInfo {
    #[prost(string, tag = "1")]
    pub region: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub url: ::prost::alloc::string::String,
    #[prost(int64, tag = "3")]
    pub distance: i64,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SubscriptionResponse {
    #[prost(string, tag = "1")]
    pub track_sid: ::prost::alloc::string::String,
    #[prost(enumeration = "SubscriptionError", tag = "2")]
    pub err: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestResponse {
    #[prost(uint32, tag = "1")]
    pub request_id: u32,
    #[prost(enumeration = "request_response::Reason", tag = "2")]
    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, 10, 11")]
    pub request: ::core::option::Option<request_response::Request>,
}
/// Nested message and enum types in `RequestResponse`.
pub mod request_response {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Reason {
        Ok = 0,
        NotFound = 1,
        NotAllowed = 2,
        LimitExceeded = 3,
        Queued = 4,
        UnsupportedType = 5,
        UnclassifiedError = 6,
        InvalidHandle = 7,
        InvalidName = 8,
        DuplicateHandle = 9,
        DuplicateName = 10,
        InvalidRequest = 11,
    }
    impl Reason {
        /// 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 {
                Self::Ok => "OK",
                Self::NotFound => "NOT_FOUND",
                Self::NotAllowed => "NOT_ALLOWED",
                Self::LimitExceeded => "LIMIT_EXCEEDED",
                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",
                Self::InvalidRequest => "INVALID_REQUEST",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OK" => Some(Self::Ok),
                "NOT_FOUND" => Some(Self::NotFound),
                "NOT_ALLOWED" => Some(Self::NotAllowed),
                "LIMIT_EXCEEDED" => Some(Self::LimitExceeded),
                "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),
                "INVALID_REQUEST" => Some(Self::InvalidRequest),
                _ => None,
            }
        }
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Request {
        #[prost(message, tag = "4")]
        Trickle(super::TrickleRequest),
        #[prost(message, tag = "5")]
        AddTrack(super::AddTrackRequest),
        #[prost(message, tag = "6")]
        Mute(super::MuteTrackRequest),
        #[prost(message, tag = "7")]
        UpdateMetadata(super::UpdateParticipantMetadata),
        #[prost(message, tag = "8")]
        UpdateAudioTrack(super::UpdateLocalAudioTrack),
        #[prost(message, tag = "9")]
        UpdateVideoTrack(super::UpdateLocalVideoTrack),
        #[prost(message, tag = "10")]
        PublishDataTrack(super::PublishDataTrackRequest),
        #[prost(message, tag = "11")]
        UnpublishDataTrack(super::UnpublishDataTrackRequest),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TrackSubscribed {
    #[prost(string, tag = "1")]
    pub track_sid: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ConnectionSettings {
    #[prost(bool, tag = "1")]
    pub auto_subscribe: bool,
    #[prost(bool, tag = "2")]
    pub adaptive_stream: bool,
    #[prost(bool, optional, tag = "3")]
    pub subscriber_allow_pause: ::core::option::Option<bool>,
    #[prost(bool, tag = "4")]
    pub disable_ice_lite: bool,
    #[prost(bool, optional, tag = "5")]
    pub auto_subscribe_data_track: ::core::option::Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JoinRequest {
    #[prost(message, optional, tag = "1")]
    pub client_info: ::core::option::Option<ClientInfo>,
    #[prost(message, optional, tag = "2")]
    pub connection_settings: ::core::option::Option<ConnectionSettings>,
    /// if not empty, will overwrite `metadata` in token
    #[prost(string, tag = "3")]
    pub metadata: ::prost::alloc::string::String,
    /// will set keys provided via this
    /// will overwrite if the same key is in the token
    /// will not delete keys from token if there is a key collision and this sets that key to empty value
    #[prost(map = "string, string", tag = "4")]
    pub participant_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "5")]
    pub add_track_requests: ::prost::alloc::vec::Vec<AddTrackRequest>,
    #[prost(message, optional, tag = "6")]
    pub publisher_offer: ::core::option::Option<SessionDescription>,
    #[prost(bool, tag = "7")]
    pub reconnect: bool,
    #[prost(enumeration = "ReconnectReason", tag = "8")]
    pub reconnect_reason: i32,
    #[prost(string, tag = "9")]
    pub participant_sid: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "10")]
    pub sync_state: ::core::option::Option<SyncState>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WrappedJoinRequest {
    #[prost(enumeration = "wrapped_join_request::Compression", tag = "1")]
    pub compression: i32,
    /// marshalled JoinRequest + potentially compressed
    #[prost(bytes = "vec", tag = "2")]
    pub join_request: ::prost::alloc::vec::Vec<u8>,
}
/// Nested message and enum types in `WrappedJoinRequest`.
pub mod wrapped_join_request {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Compression {
        None = 0,
        Gzip = 1,
    }
    impl Compression {
        /// 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 {
                Self::None => "NONE",
                Self::Gzip => "GZIP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "NONE" => Some(Self::None),
                "GZIP" => Some(Self::Gzip),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MediaSectionsRequirement {
    #[prost(uint32, tag = "1")]
    pub num_audios: u32,
    #[prost(uint32, tag = "2")]
    pub num_videos: u32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SignalTarget {
    Publisher = 0,
    Subscriber = 1,
}
impl SignalTarget {
    /// 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 {
            Self::Publisher => "PUBLISHER",
            Self::Subscriber => "SUBSCRIBER",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PUBLISHER" => Some(Self::Publisher),
            "SUBSCRIBER" => Some(Self::Subscriber),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum StreamState {
    Active = 0,
    Paused = 1,
}
impl StreamState {
    /// 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 {
            Self::Active => "ACTIVE",
            Self::Paused => "PAUSED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ACTIVE" => Some(Self::Active),
            "PAUSED" => Some(Self::Paused),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CandidateProtocol {
    Udp = 0,
    Tcp = 1,
    Tls = 2,
}
impl CandidateProtocol {
    /// 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 {
            Self::Udp => "UDP",
            Self::Tcp => "TCP",
            Self::Tls => "TLS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UDP" => Some(Self::Udp),
            "TCP" => Some(Self::Tcp),
            "TLS" => Some(Self::Tls),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Job {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub dispatch_id: ::prost::alloc::string::String,
    #[prost(enumeration = "JobType", tag = "2")]
    pub r#type: i32,
    #[prost(message, optional, tag = "3")]
    pub room: ::core::option::Option<Room>,
    #[prost(message, optional, tag = "4")]
    pub participant: ::core::option::Option<ParticipantInfo>,
    #[deprecated]
    #[prost(string, tag = "5")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub metadata: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "8")]
    pub state: ::core::option::Option<JobState>,
    #[prost(bool, tag = "10")]
    pub enable_recording: bool,
    #[prost(string, tag = "11")]
    pub deployment: ::prost::alloc::string::String,
    #[prost(map = "string, string", tag = "12")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    #[prost(bool, tag = "13")]
    pub enable_redaction: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct JobState {
    #[prost(enumeration = "JobStatus", tag = "1")]
    pub status: i32,
    #[prost(string, tag = "2")]
    pub error: ::prost::alloc::string::String,
    #[prost(int64, tag = "3")]
    pub started_at: i64,
    #[prost(int64, tag = "4")]
    pub ended_at: i64,
    #[prost(int64, tag = "5")]
    pub updated_at: i64,
    #[prost(string, tag = "6")]
    pub participant_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub worker_id: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub agent_id: ::prost::alloc::string::String,
}
/// from Worker to Server
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkerMessage {
    #[prost(oneof = "worker_message::Message", tags = "1, 2, 3, 4, 5, 6, 7")]
    pub message: ::core::option::Option<worker_message::Message>,
}
/// Nested message and enum types in `WorkerMessage`.
pub mod worker_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        /// agent workers need to register themselves with the server first
        #[prost(message, tag = "1")]
        Register(super::RegisterWorkerRequest),
        /// worker confirms to server that it's available for a job, or declines it
        #[prost(message, tag = "2")]
        Availability(super::AvailabilityResponse),
        /// worker can update its status to the server, including taking itself out of the pool
        #[prost(message, tag = "3")]
        UpdateWorker(super::UpdateWorkerStatus),
        /// job can send status updates to the server, useful for tracking progress
        #[prost(message, tag = "4")]
        UpdateJob(super::UpdateJobStatus),
        #[prost(message, tag = "5")]
        Ping(super::WorkerPing),
        #[prost(message, tag = "6")]
        SimulateJob(super::SimulateJobRequest),
        #[prost(message, tag = "7")]
        MigrateJob(super::MigrateJobRequest),
    }
}
/// from Server to Worker
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerMessage {
    #[prost(oneof = "server_message::Message", tags = "1, 2, 3, 5, 4")]
    pub message: ::core::option::Option<server_message::Message>,
}
/// Nested message and enum types in `ServerMessage`.
pub mod server_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        /// server confirms the registration, from this moment on, the worker is considered active
        #[prost(message, tag = "1")]
        Register(super::RegisterWorkerResponse),
        /// server asks worker to confirm availability for a job
        #[prost(message, tag = "2")]
        Availability(super::AvailabilityRequest),
        #[prost(message, tag = "3")]
        Assignment(super::JobAssignment),
        #[prost(message, tag = "5")]
        Termination(super::JobTermination),
        #[prost(message, tag = "4")]
        Pong(super::WorkerPong),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SimulateJobRequest {
    #[prost(enumeration = "JobType", tag = "1")]
    pub r#type: i32,
    #[prost(message, optional, tag = "2")]
    pub room: ::core::option::Option<Room>,
    #[prost(message, optional, tag = "3")]
    pub participant: ::core::option::Option<ParticipantInfo>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WorkerPing {
    #[prost(int64, tag = "1")]
    pub timestamp: i64,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WorkerPong {
    #[prost(int64, tag = "1")]
    pub last_timestamp: i64,
    #[prost(int64, tag = "2")]
    pub timestamp: i64,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegisterWorkerRequest {
    #[prost(enumeration = "JobType", tag = "1")]
    pub r#type: i32,
    #[prost(string, tag = "8")]
    pub agent_name: ::prost::alloc::string::String,
    /// string worker_id = 2;
    #[prost(string, tag = "3")]
    pub version: ::prost::alloc::string::String,
    /// string name = 4 \[deprecated = true\];
    #[prost(uint32, tag = "5")]
    pub ping_interval: u32,
    #[prost(string, optional, tag = "6")]
    pub namespace: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "7")]
    pub allowed_permissions: ::core::option::Option<ParticipantPermission>,
    #[prost(string, tag = "9")]
    pub deployment: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegisterWorkerResponse {
    #[prost(string, tag = "1")]
    pub worker_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub server_info: ::core::option::Option<ServerInfo>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MigrateJobRequest {
    /// string job_id = 1 \[deprecated = true\];
    #[prost(string, repeated, tag = "2")]
    pub job_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AvailabilityRequest {
    #[prost(message, optional, tag = "1")]
    pub job: ::core::option::Option<Job>,
    /// True when the job was previously assigned to another worker but has been
    /// migrated due to different reasons (e.g. worker failure, job migration)
    #[prost(bool, tag = "2")]
    pub resuming: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AvailabilityResponse {
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub available: bool,
    #[prost(bool, tag = "3")]
    pub supports_resume: bool,
    #[prost(bool, tag = "8")]
    pub terminate: bool,
    #[prost(string, tag = "4")]
    pub participant_name: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub participant_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub participant_metadata: ::prost::alloc::string::String,
    /// NEXT_ID: 9
    #[prost(map = "string, string", tag = "7")]
    pub participant_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateJobStatus {
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    /// The worker can indicate the job end by either specifying SUCCESS or FAILED
    #[prost(enumeration = "JobStatus", tag = "2")]
    pub status: i32,
    /// metadata shown on the dashboard, useful for debugging
    #[prost(string, tag = "3")]
    pub error: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct UpdateWorkerStatus {
    #[prost(enumeration = "WorkerStatus", optional, tag = "1")]
    pub status: ::core::option::Option<i32>,
    /// optional string metadata = 2 \[deprecated=true\];
    #[prost(float, tag = "3")]
    pub load: f32,
    #[prost(uint32, tag = "4")]
    pub job_count: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobAssignment {
    #[prost(message, optional, tag = "1")]
    pub job: ::core::option::Option<Job>,
    #[prost(string, optional, tag = "2")]
    pub url: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, tag = "3")]
    pub token: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct JobTermination {
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobType {
    JtRoom = 0,
    JtPublisher = 1,
    JtParticipant = 2,
}
impl JobType {
    /// 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 {
            Self::JtRoom => "JT_ROOM",
            Self::JtPublisher => "JT_PUBLISHER",
            Self::JtParticipant => "JT_PARTICIPANT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "JT_ROOM" => Some(Self::JtRoom),
            "JT_PUBLISHER" => Some(Self::JtPublisher),
            "JT_PARTICIPANT" => Some(Self::JtParticipant),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum WorkerStatus {
    WsAvailable = 0,
    WsFull = 1,
}
impl WorkerStatus {
    /// 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 {
            Self::WsAvailable => "WS_AVAILABLE",
            Self::WsFull => "WS_FULL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "WS_AVAILABLE" => Some(Self::WsAvailable),
            "WS_FULL" => Some(Self::WsFull),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobStatus {
    JsPending = 0,
    JsRunning = 1,
    JsSuccess = 2,
    JsFailed = 3,
}
impl JobStatus {
    /// 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 {
            Self::JsPending => "JS_PENDING",
            Self::JsRunning => "JS_RUNNING",
            Self::JsSuccess => "JS_SUCCESS",
            Self::JsFailed => "JS_FAILED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "JS_PENDING" => Some(Self::JsPending),
            "JS_RUNNING" => Some(Self::JsRunning),
            "JS_SUCCESS" => Some(Self::JsSuccess),
            "JS_FAILED" => Some(Self::JsFailed),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAgentDispatchRequest {
    #[prost(string, tag = "1")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub room: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub metadata: ::prost::alloc::string::String,
    /// cloud only
    #[prost(enumeration = "JobRestartPolicy", tag = "4")]
    pub restart_policy: i32,
    #[prost(string, tag = "5")]
    pub deployment: ::prost::alloc::string::String,
    #[prost(map = "string, string", tag = "6")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoomAgentDispatch {
    #[prost(string, tag = "1")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub metadata: ::prost::alloc::string::String,
    /// cloud only
    #[prost(enumeration = "JobRestartPolicy", tag = "3")]
    pub restart_policy: i32,
    #[prost(string, tag = "4")]
    pub deployment: ::prost::alloc::string::String,
    #[prost(map = "string, string", tag = "5")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteAgentDispatchRequest {
    #[prost(string, tag = "1")]
    pub dispatch_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub room: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListAgentDispatchRequest {
    /// if set, only the dispatch whose id is given will be returned
    #[prost(string, tag = "1")]
    pub dispatch_id: ::prost::alloc::string::String,
    /// name of the room to list agents for. Must be set.
    #[prost(string, tag = "2")]
    pub room: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAgentDispatchResponse {
    #[prost(message, repeated, tag = "1")]
    pub agent_dispatches: ::prost::alloc::vec::Vec<AgentDispatch>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AgentDispatch {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub room: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub metadata: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub state: ::core::option::Option<AgentDispatchState>,
    /// cloud only
    #[prost(enumeration = "JobRestartPolicy", tag = "6")]
    pub restart_policy: i32,
    #[prost(string, tag = "7")]
    pub deployment: ::prost::alloc::string::String,
    #[prost(map = "string, string", tag = "8")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AgentDispatchState {
    /// 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<Job>,
    #[prost(int64, tag = "2")]
    pub created_at: i64,
    #[prost(int64, tag = "3")]
    pub deleted_at: i64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobRestartPolicy {
    /// restart when the job fails (default)
    JrpOnFailure = 0,
    /// never restart
    JrpNever = 1,
}
impl JobRestartPolicy {
    /// 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 {
            Self::JrpOnFailure => "JRP_ON_FAILURE",
            Self::JrpNever => "JRP_NEVER",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "JRP_ON_FAILURE" => Some(Self::JrpOnFailure),
            "JRP_NEVER" => Some(Self::JrpNever),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateRoomRequest {
    /// name of the room
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// configuration to use for this room parameters. Setting parameters below override the config defaults.
    #[prost(string, tag = "12")]
    pub room_preset: ::prost::alloc::string::String,
    /// number of seconds to keep the room open if no one joins
    #[prost(uint32, tag = "2")]
    pub empty_timeout: u32,
    /// number of seconds to keep the room open after everyone leaves
    #[prost(uint32, tag = "10")]
    pub departure_timeout: u32,
    /// limit number of participants that can be in a room
    #[prost(uint32, tag = "3")]
    pub max_participants: u32,
    /// override the node room is allocated to, for debugging
    #[prost(string, tag = "4")]
    pub node_id: ::prost::alloc::string::String,
    /// metadata of room
    #[prost(string, tag = "5")]
    pub metadata: ::prost::alloc::string::String,
    /// search tags
    #[prost(map = "string, string", tag = "15")]
    pub tags: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// auto-egress configurations
    #[prost(message, optional, tag = "6")]
    pub egress: ::core::option::Option<RoomEgress>,
    /// playout delay of subscriber
    #[prost(uint32, tag = "7")]
    pub min_playout_delay: u32,
    #[prost(uint32, tag = "8")]
    pub max_playout_delay: u32,
    /// improves A/V sync when playout_delay set to a value larger than 200ms. It will disables transceiver re-use
    /// so not recommended for rooms with frequent subscription changes
    #[prost(bool, tag = "9")]
    pub sync_streams: bool,
    /// replay
    #[prost(bool, tag = "13")]
    pub replay_enabled: bool,
    /// Define agents that should be dispatched to this room
    #[prost(message, repeated, tag = "14")]
    pub agents: ::prost::alloc::vec::Vec<RoomAgentDispatch>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoomEgress {
    #[prost(message, optional, tag = "1")]
    pub room: ::core::option::Option<RoomCompositeEgressRequest>,
    #[prost(message, optional, tag = "3")]
    pub participant: ::core::option::Option<AutoParticipantEgress>,
    #[prost(message, optional, tag = "2")]
    pub tracks: ::core::option::Option<AutoTrackEgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoomAgent {
    #[prost(message, repeated, tag = "1")]
    pub dispatches: ::prost::alloc::vec::Vec<RoomAgentDispatch>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListRoomsRequest {
    /// when set, will only return rooms with name match
    #[prost(string, repeated, tag = "1")]
    pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRoomsResponse {
    #[prost(message, repeated, tag = "1")]
    pub rooms: ::prost::alloc::vec::Vec<Room>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteRoomRequest {
    /// name of the room
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteRoomResponse {
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListParticipantsRequest {
    /// name of the room
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListParticipantsResponse {
    #[prost(message, repeated, tag = "1")]
    pub participants: ::prost::alloc::vec::Vec<ParticipantInfo>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RoomParticipantIdentity {
    /// name of the room
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
    /// identity of the participant
    #[prost(string, tag = "2")]
    pub identity: ::prost::alloc::string::String,
    /// Unix timestamp used to invalidate token whose nbf is before this value.
    /// Used only by RemoveParticipant; defaults to now(server)+leeway(1min) if left empty.
    #[prost(int64, tag = "3")]
    pub revoke_token_ts: i64,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RemoveParticipantResponse {
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MuteRoomTrackRequest {
    /// name of the room
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub identity: ::prost::alloc::string::String,
    /// sid of the track to mute
    #[prost(string, tag = "3")]
    pub track_sid: ::prost::alloc::string::String,
    /// set to true to mute, false to unmute
    #[prost(bool, tag = "4")]
    pub muted: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MuteRoomTrackResponse {
    #[prost(message, optional, tag = "1")]
    pub track: ::core::option::Option<TrackInfo>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateParticipantRequest {
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub identity: ::prost::alloc::string::String,
    /// metadata to update. skipping updates if left empty
    #[prost(string, tag = "3")]
    pub metadata: ::prost::alloc::string::String,
    /// set to update the participant's permissions
    #[prost(message, optional, tag = "4")]
    pub permission: ::core::option::Option<ParticipantPermission>,
    /// display name to update
    #[prost(string, tag = "5")]
    pub name: ::prost::alloc::string::String,
    /// attributes to update. it only updates attributes that have been set
    /// to delete attributes, set the value to an empty string
    #[prost(map = "string, string", tag = "6")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSubscriptionsRequest {
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub identity: ::prost::alloc::string::String,
    /// list of sids of tracks
    #[prost(string, repeated, tag = "3")]
    pub track_sids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// set to true to subscribe, false to unsubscribe from tracks
    #[prost(bool, tag = "4")]
    pub subscribe: bool,
    /// list of participants and their tracks
    #[prost(message, repeated, tag = "5")]
    pub participant_tracks: ::prost::alloc::vec::Vec<ParticipantTracks>,
}
/// empty for now
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateSubscriptionsResponse {
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SendDataRequest {
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
    #[prost(bytes = "vec", tag = "2")]
    pub data: ::prost::alloc::vec::Vec<u8>,
    #[prost(enumeration = "data_packet::Kind", tag = "3")]
    pub kind: i32,
    /// mark deprecated
    #[deprecated]
    #[prost(string, repeated, tag = "4")]
    pub destination_sids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// when set, only forward to these identities
    #[prost(string, repeated, tag = "6")]
    pub destination_identities: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "5")]
    pub topic: ::core::option::Option<::prost::alloc::string::String>,
    /// added by SDK to enable de-duping of messages, for INTERNAL USE ONLY
    #[prost(bytes = "vec", tag = "7")]
    pub nonce: ::prost::alloc::vec::Vec<u8>,
}
///
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SendDataResponse {
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateRoomMetadataRequest {
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
    /// metadata to update. skipping updates if left empty
    #[prost(string, tag = "2")]
    pub metadata: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoomConfiguration {
    /// Used as ID, must be unique
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// number of seconds to keep the room open if no one joins
    #[prost(uint32, tag = "2")]
    pub empty_timeout: u32,
    /// number of seconds to keep the room open after everyone leaves
    #[prost(uint32, tag = "3")]
    pub departure_timeout: u32,
    /// limit number of participants that can be in a room, excluding Egress and Agent participants
    #[prost(uint32, tag = "4")]
    pub max_participants: u32,
    /// metadata of room
    #[prost(string, tag = "11")]
    pub metadata: ::prost::alloc::string::String,
    /// egress
    #[prost(message, optional, tag = "5")]
    pub egress: ::core::option::Option<RoomEgress>,
    /// playout delay of subscriber
    #[prost(uint32, tag = "7")]
    pub min_playout_delay: u32,
    #[prost(uint32, tag = "8")]
    pub max_playout_delay: u32,
    /// improves A/V sync when playout_delay set to a value larger than 200ms. It will disables transceiver re-use
    /// so not recommended for rooms with frequent subscription changes
    #[prost(bool, tag = "9")]
    pub sync_streams: bool,
    /// Define agents that should be dispatched to this room
    #[prost(message, repeated, tag = "10")]
    pub agents: ::prost::alloc::vec::Vec<RoomAgentDispatch>,
    /// Tags to attach to the room
    #[prost(map = "string, string", tag = "12")]
    pub tags: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ForwardParticipantRequest {
    /// room to forward participant from
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
    /// identity of the participant to forward
    #[prost(string, tag = "2")]
    pub identity: ::prost::alloc::string::String,
    /// room to forward participant to
    #[prost(string, tag = "3")]
    pub destination_room: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ForwardParticipantResponse {
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MoveParticipantRequest {
    /// room to move participant from
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
    /// identity of the participant to move to
    #[prost(string, tag = "2")]
    pub identity: ::prost::alloc::string::String,
    /// room to move participant to
    #[prost(string, tag = "3")]
    pub destination_room: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MoveParticipantResponse {
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PerformRpcRequest {
    #[prost(string, tag = "1")]
    pub room: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub destination_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub method: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub payload: ::prost::alloc::string::String,
    #[prost(uint32, tag = "5")]
    pub response_timeout_ms: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PerformRpcResponse {
    #[prost(string, tag = "1")]
    pub payload: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateIngressRequest {
    #[prost(enumeration = "IngressInput", tag = "1")]
    pub input_type: i32,
    /// Where to pull media from, only for URL input type
    #[prost(string, tag = "9")]
    pub url: ::prost::alloc::string::String,
    /// User provided identifier for the ingress
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// room to publish to
    #[prost(string, tag = "3")]
    pub room_name: ::prost::alloc::string::String,
    /// publish as participant
    #[prost(string, tag = "4")]
    pub participant_identity: ::prost::alloc::string::String,
    /// name of publishing participant (used for display only)
    #[prost(string, tag = "5")]
    pub participant_name: ::prost::alloc::string::String,
    /// metadata associated with the publishing participant
    #[prost(string, tag = "10")]
    pub participant_metadata: ::prost::alloc::string::String,
    /// \[depreacted \] whether to pass through the incoming media without transcoding, only compatible with some input types. Use `enable_transcoding` instead.
    #[deprecated]
    #[prost(bool, tag = "8")]
    pub bypass_transcoding: bool,
    /// Whether to transcode the ingested media. Only WHIP supports disabling transcoding currently. WHIP will default to transcoding disabled. Replaces `bypass_transcoding. 
    #[prost(bool, optional, tag = "11")]
    pub enable_transcoding: ::core::option::Option<bool>,
    #[prost(message, optional, tag = "6")]
    pub audio: ::core::option::Option<IngressAudioOptions>,
    #[prost(message, optional, tag = "7")]
    pub video: ::core::option::Option<IngressVideoOptions>,
    /// The default value is true and when set to false, the new connection attempts will be rejected
    #[prost(bool, optional, tag = "12")]
    pub enabled: ::core::option::Option<bool>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct IngressAudioOptions {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(enumeration = "TrackSource", tag = "2")]
    pub source: i32,
    #[prost(oneof = "ingress_audio_options::EncodingOptions", tags = "3, 4")]
    pub encoding_options: ::core::option::Option<ingress_audio_options::EncodingOptions>,
}
/// Nested message and enum types in `IngressAudioOptions`.
pub mod ingress_audio_options {
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum EncodingOptions {
        #[prost(enumeration = "super::IngressAudioEncodingPreset", tag = "3")]
        Preset(i32),
        #[prost(message, tag = "4")]
        Options(super::IngressAudioEncodingOptions),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IngressVideoOptions {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(enumeration = "TrackSource", tag = "2")]
    pub source: i32,
    #[prost(oneof = "ingress_video_options::EncodingOptions", tags = "3, 4")]
    pub encoding_options: ::core::option::Option<ingress_video_options::EncodingOptions>,
}
/// Nested message and enum types in `IngressVideoOptions`.
pub mod ingress_video_options {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum EncodingOptions {
        #[prost(enumeration = "super::IngressVideoEncodingPreset", tag = "3")]
        Preset(i32),
        #[prost(message, tag = "4")]
        Options(super::IngressVideoEncodingOptions),
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct IngressAudioEncodingOptions {
    /// desired audio codec to publish to room
    #[prost(enumeration = "AudioCodec", tag = "1")]
    pub audio_codec: i32,
    #[prost(uint32, tag = "2")]
    pub bitrate: u32,
    #[prost(bool, tag = "3")]
    pub disable_dtx: bool,
    #[prost(uint32, tag = "4")]
    pub channels: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IngressVideoEncodingOptions {
    /// desired codec to publish to room
    #[prost(enumeration = "VideoCodec", tag = "1")]
    pub video_codec: i32,
    #[prost(double, tag = "2")]
    pub frame_rate: f64,
    /// simulcast layers to publish, when empty, should usually be set to layers at 1/2 and 1/4 of the dimensions
    #[prost(message, repeated, tag = "3")]
    pub layers: ::prost::alloc::vec::Vec<VideoLayer>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IngressInfo {
    #[prost(string, tag = "1")]
    pub ingress_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub stream_key: ::prost::alloc::string::String,
    /// URL to point the encoder to for push (RTMP, WHIP), or location to pull media from for pull (URL)
    #[prost(string, tag = "4")]
    pub url: ::prost::alloc::string::String,
    /// for RTMP input, it'll be a rtmp:// URL
    /// for FILE input, it'll be a http:// URL
    /// for SRT input, it'll be a srt:// URL
    #[prost(enumeration = "IngressInput", tag = "5")]
    pub input_type: i32,
    #[deprecated]
    #[prost(bool, tag = "13")]
    pub bypass_transcoding: bool,
    #[prost(bool, optional, tag = "15")]
    pub enable_transcoding: ::core::option::Option<bool>,
    #[prost(message, optional, tag = "6")]
    pub audio: ::core::option::Option<IngressAudioOptions>,
    #[prost(message, optional, tag = "7")]
    pub video: ::core::option::Option<IngressVideoOptions>,
    #[prost(string, tag = "8")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub participant_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "10")]
    pub participant_name: ::prost::alloc::string::String,
    #[prost(string, tag = "14")]
    pub participant_metadata: ::prost::alloc::string::String,
    #[prost(bool, tag = "11")]
    pub reusable: bool,
    /// Description of error/stream non compliance and debug info for publisher otherwise (received bitrate, resolution, bandwidth)
    #[prost(message, optional, tag = "12")]
    pub state: ::core::option::Option<IngressState>,
    /// The default value is true and when set to false, the new connection attempts will be rejected
    #[prost(bool, optional, tag = "16")]
    pub enabled: ::core::option::Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IngressState {
    #[prost(enumeration = "ingress_state::Status", tag = "1")]
    pub status: i32,
    /// Error/non compliance description if any
    #[prost(string, tag = "2")]
    pub error: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub video: ::core::option::Option<InputVideoState>,
    #[prost(message, optional, tag = "4")]
    pub audio: ::core::option::Option<InputAudioState>,
    /// ID of the current/previous room published to
    #[prost(string, tag = "5")]
    pub room_id: ::prost::alloc::string::String,
    #[prost(int64, tag = "7")]
    pub started_at: i64,
    #[prost(int64, tag = "8")]
    pub ended_at: i64,
    #[prost(int64, tag = "10")]
    pub updated_at: i64,
    #[prost(string, tag = "9")]
    pub resource_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "6")]
    pub tracks: ::prost::alloc::vec::Vec<TrackInfo>,
}
/// Nested message and enum types in `IngressState`.
pub mod ingress_state {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Status {
        EndpointInactive = 0,
        EndpointBuffering = 1,
        EndpointPublishing = 2,
        EndpointError = 3,
        EndpointComplete = 4,
    }
    impl Status {
        /// 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 {
                Self::EndpointInactive => "ENDPOINT_INACTIVE",
                Self::EndpointBuffering => "ENDPOINT_BUFFERING",
                Self::EndpointPublishing => "ENDPOINT_PUBLISHING",
                Self::EndpointError => "ENDPOINT_ERROR",
                Self::EndpointComplete => "ENDPOINT_COMPLETE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ENDPOINT_INACTIVE" => Some(Self::EndpointInactive),
                "ENDPOINT_BUFFERING" => Some(Self::EndpointBuffering),
                "ENDPOINT_PUBLISHING" => Some(Self::EndpointPublishing),
                "ENDPOINT_ERROR" => Some(Self::EndpointError),
                "ENDPOINT_COMPLETE" => Some(Self::EndpointComplete),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InputVideoState {
    #[prost(string, tag = "1")]
    pub mime_type: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub average_bitrate: u32,
    #[prost(uint32, tag = "3")]
    pub width: u32,
    #[prost(uint32, tag = "4")]
    pub height: u32,
    #[prost(double, tag = "5")]
    pub framerate: f64,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InputAudioState {
    #[prost(string, tag = "1")]
    pub mime_type: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub average_bitrate: u32,
    #[prost(uint32, tag = "3")]
    pub channels: u32,
    #[prost(uint32, tag = "4")]
    pub sample_rate: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateIngressRequest {
    #[prost(string, tag = "1")]
    pub ingress_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub participant_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub participant_name: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub participant_metadata: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(bool, optional, tag = "8")]
    pub bypass_transcoding: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "10")]
    pub enable_transcoding: ::core::option::Option<bool>,
    #[prost(message, optional, tag = "6")]
    pub audio: ::core::option::Option<IngressAudioOptions>,
    #[prost(message, optional, tag = "7")]
    pub video: ::core::option::Option<IngressVideoOptions>,
    /// The default value is true and when set to false, the new connection attempts will be rejected
    #[prost(bool, optional, tag = "11")]
    pub enabled: ::core::option::Option<bool>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListIngressRequest {
    #[prost(message, optional, tag = "3")]
    pub page_token: ::core::option::Option<TokenPagination>,
    /// when blank, lists all ingress endpoints
    ///
    /// (optional, filter by room name)
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
    /// (optional, filter by ingress ID)
    #[prost(string, tag = "2")]
    pub ingress_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListIngressResponse {
    #[prost(message, optional, tag = "2")]
    pub next_page_token: ::core::option::Option<TokenPagination>,
    /// next field id: 3
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<IngressInfo>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteIngressRequest {
    #[prost(string, tag = "1")]
    pub ingress_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IngressInput {
    RtmpInput = 0,
    WhipInput = 1,
    /// Pull from the provided URL. Only HTTP url are supported, serving either a single media file or a HLS stream
    UrlInput = 2,
}
impl IngressInput {
    /// 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 {
            Self::RtmpInput => "RTMP_INPUT",
            Self::WhipInput => "WHIP_INPUT",
            Self::UrlInput => "URL_INPUT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RTMP_INPUT" => Some(Self::RtmpInput),
            "WHIP_INPUT" => Some(Self::WhipInput),
            "URL_INPUT" => Some(Self::UrlInput),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IngressAudioEncodingPreset {
    /// OPUS, 2 channels, 96kbps
    OpusStereo96kbps = 0,
    /// OPUS, 1 channel, 64kbps
    OpusMono64kbs = 1,
}
impl IngressAudioEncodingPreset {
    /// 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 {
            Self::OpusStereo96kbps => "OPUS_STEREO_96KBPS",
            Self::OpusMono64kbs => "OPUS_MONO_64KBS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "OPUS_STEREO_96KBPS" => Some(Self::OpusStereo96kbps),
            "OPUS_MONO_64KBS" => Some(Self::OpusMono64kbs),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IngressVideoEncodingPreset {
    /// 1280x720,  30fps, 1900kbps main layer, 3 layers total
    H264720p30fps3Layers = 0,
    /// 1980x1080, 30fps, 3500kbps main layer, 3 layers total
    H2641080p30fps3Layers = 1,
    ///   960x540,  25fps, 1000kbps  main layer, 2 layers total
    H264540p25fps2Layers = 2,
    /// 1280x720,  30fps, 1900kbps, no simulcast
    H264720p30fps1Layer = 3,
    /// 1980x1080, 30fps, 3500kbps, no simulcast
    H2641080p30fps1Layer = 4,
    /// 1280x720,  30fps, 2500kbps main layer, 3 layers total, higher bitrate for high motion, harder to encode content
    H264720p30fps3LayersHighMotion = 5,
    /// 1980x1080, 30fps, 4500kbps main layer, 3 layers total, higher bitrate for high motion, harder to encode content
    H2641080p30fps3LayersHighMotion = 6,
    ///   960x540,  25fps, 1300kbps  main layer, 2 layers total, higher bitrate for high motion, harder to encode content
    H264540p25fps2LayersHighMotion = 7,
    /// 1280x720,  30fps, 2500kbps, no simulcast, higher bitrate for high motion, harder to encode content
    H264720p30fps1LayerHighMotion = 8,
    /// 1980x1080, 30fps, 4500kbps, no simulcast, higher bitrate for high motion, harder to encode content
    H2641080p30fps1LayerHighMotion = 9,
}
impl IngressVideoEncodingPreset {
    /// 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 {
            Self::H264720p30fps3Layers => "H264_720P_30FPS_3_LAYERS",
            Self::H2641080p30fps3Layers => "H264_1080P_30FPS_3_LAYERS",
            Self::H264540p25fps2Layers => "H264_540P_25FPS_2_LAYERS",
            Self::H264720p30fps1Layer => "H264_720P_30FPS_1_LAYER",
            Self::H2641080p30fps1Layer => "H264_1080P_30FPS_1_LAYER",
            Self::H264720p30fps3LayersHighMotion => "H264_720P_30FPS_3_LAYERS_HIGH_MOTION",
            Self::H2641080p30fps3LayersHighMotion => "H264_1080P_30FPS_3_LAYERS_HIGH_MOTION",
            Self::H264540p25fps2LayersHighMotion => "H264_540P_25FPS_2_LAYERS_HIGH_MOTION",
            Self::H264720p30fps1LayerHighMotion => "H264_720P_30FPS_1_LAYER_HIGH_MOTION",
            Self::H2641080p30fps1LayerHighMotion => "H264_1080P_30FPS_1_LAYER_HIGH_MOTION",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "H264_720P_30FPS_3_LAYERS" => Some(Self::H264720p30fps3Layers),
            "H264_1080P_30FPS_3_LAYERS" => Some(Self::H2641080p30fps3Layers),
            "H264_540P_25FPS_2_LAYERS" => Some(Self::H264540p25fps2Layers),
            "H264_720P_30FPS_1_LAYER" => Some(Self::H264720p30fps1Layer),
            "H264_1080P_30FPS_1_LAYER" => Some(Self::H2641080p30fps1Layer),
            "H264_720P_30FPS_3_LAYERS_HIGH_MOTION" => Some(Self::H264720p30fps3LayersHighMotion),
            "H264_1080P_30FPS_3_LAYERS_HIGH_MOTION" => Some(Self::H2641080p30fps3LayersHighMotion),
            "H264_540P_25FPS_2_LAYERS_HIGH_MOTION" => Some(Self::H264540p25fps2LayersHighMotion),
            "H264_720P_30FPS_1_LAYER_HIGH_MOTION" => Some(Self::H264720p30fps1LayerHighMotion),
            "H264_1080P_30FPS_1_LAYER_HIGH_MOTION" => Some(Self::H2641080p30fps1LayerHighMotion),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebhookEvent {
    /// one of room_started, room_finished, participant_joined, participant_left, participant_connection_aborted,
    /// track_published, track_unpublished, egress_started, egress_updated, egress_ended,
    /// ingress_started, ingress_ended, agent_job_started, agent_job_ended
    #[prost(string, tag = "1")]
    pub event: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub room: ::core::option::Option<Room>,
    /// set when event is participant_* or track_*
    #[prost(message, optional, tag = "3")]
    pub participant: ::core::option::Option<ParticipantInfo>,
    /// set when event is egress_*
    #[prost(message, optional, tag = "9")]
    pub egress_info: ::core::option::Option<EgressInfo>,
    /// set when event is ingress_*
    #[prost(message, optional, tag = "10")]
    pub ingress_info: ::core::option::Option<IngressInfo>,
    /// set when event is track_*
    #[prost(message, optional, tag = "8")]
    pub track: ::core::option::Option<TrackInfo>,
    /// set when event is agent_job_*
    #[prost(message, optional, tag = "12")]
    pub job: ::core::option::Option<Job>,
    /// unique event uuid
    #[prost(string, tag = "6")]
    pub id: ::prost::alloc::string::String,
    /// timestamp in seconds
    #[prost(int64, tag = "7")]
    pub created_at: i64,
    #[deprecated]
    #[prost(int32, tag = "11")]
    pub num_dropped: i32,
}
/// SIPStatus is returned as an error detail in CreateSIPParticipant.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipStatus {
    #[prost(enumeration = "SipStatusCode", tag = "1")]
    pub code: i32,
    #[prost(string, tag = "2")]
    pub status: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateSipTrunkRequest {
    /// CIDR or IPs that traffic is accepted from
    /// An empty list means all inbound traffic is accepted.
    #[prost(string, repeated, tag = "1")]
    pub inbound_addresses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// IP that SIP INVITE is sent too
    #[prost(string, tag = "2")]
    pub outbound_address: ::prost::alloc::string::String,
    /// Number used to make outbound calls
    #[prost(string, tag = "3")]
    pub outbound_number: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(string, repeated, tag = "4")]
    pub inbound_numbers_regex: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Accepted `To` values. This Trunk will only accept a call made to
    /// these numbers. This allows you to have distinct Trunks for different phone
    /// numbers at the same provider.
    #[prost(string, repeated, tag = "9")]
    pub inbound_numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Username and password used to authenticate inbound and outbound SIP invites
    /// May be empty to have no Authentication
    #[prost(string, tag = "5")]
    pub inbound_username: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub inbound_password: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub outbound_username: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub outbound_password: ::prost::alloc::string::String,
    /// Optional human-readable name for the Trunk.
    #[prost(string, tag = "10")]
    pub name: ::prost::alloc::string::String,
    /// Optional user-defined metadata for the Trunk.
    #[prost(string, tag = "11")]
    pub metadata: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipCodec {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub rate: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SipMediaConfig {
    /// if set, ignore the default codecs and use the list below.
    #[prost(bool, tag = "1")]
    pub only_listed_codecs: bool,
    /// List of allowed codecs. If only_listed_codecs is not set, this list is added to default codecs.
    #[prost(message, repeated, tag = "2")]
    pub codecs: ::prost::alloc::vec::Vec<SipCodec>,
    #[prost(enumeration = "SipMediaEncryption", optional, tag = "3")]
    pub encryption: ::core::option::Option<i32>,
    /// Use specific media timeout. If zero or not specified, will use default timeout.
    #[prost(message, optional, tag = "4")]
    pub media_timeout: ::core::option::Option<::pbjson_types::Duration>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProviderInfo {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(enumeration = "ProviderType", tag = "3")]
    pub r#type: i32,
    #[prost(bool, tag = "4")]
    pub prevent_transfer: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipTrunkInfo {
    #[prost(string, tag = "1")]
    pub sip_trunk_id: ::prost::alloc::string::String,
    #[prost(enumeration = "sip_trunk_info::TrunkKind", tag = "14")]
    pub kind: i32,
    /// CIDR or IPs that traffic is accepted from
    /// An empty list means all inbound traffic is accepted.
    #[prost(string, repeated, tag = "2")]
    pub inbound_addresses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// IP that SIP INVITE is sent too
    #[prost(string, tag = "3")]
    pub outbound_address: ::prost::alloc::string::String,
    /// Number used to make outbound calls
    #[prost(string, tag = "4")]
    pub outbound_number: ::prost::alloc::string::String,
    /// Transport used for inbound and outbound calls.
    #[prost(enumeration = "SipTransport", tag = "13")]
    pub transport: i32,
    #[deprecated]
    #[prost(string, repeated, tag = "5")]
    pub inbound_numbers_regex: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Accepted `To` values. This Trunk will only accept a call made to
    /// these numbers. This allows you to have distinct Trunks for different phone
    /// numbers at the same provider.
    #[prost(string, repeated, tag = "10")]
    pub inbound_numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Username and password used to authenticate inbound and outbound SIP invites
    /// May be empty to have no Authentication
    #[prost(string, tag = "6")]
    pub inbound_username: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub inbound_password: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub outbound_username: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub outbound_password: ::prost::alloc::string::String,
    /// Human-readable name for the Trunk.
    #[prost(string, tag = "11")]
    pub name: ::prost::alloc::string::String,
    /// User-defined metadata for the Trunk.
    #[prost(string, tag = "12")]
    pub metadata: ::prost::alloc::string::String,
}
/// Nested message and enum types in `SIPTrunkInfo`.
pub mod sip_trunk_info {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum TrunkKind {
        TrunkLegacy = 0,
        TrunkInbound = 1,
        TrunkOutbound = 2,
    }
    impl TrunkKind {
        /// 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 {
                Self::TrunkLegacy => "TRUNK_LEGACY",
                Self::TrunkInbound => "TRUNK_INBOUND",
                Self::TrunkOutbound => "TRUNK_OUTBOUND",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TRUNK_LEGACY" => Some(Self::TrunkLegacy),
                "TRUNK_INBOUND" => Some(Self::TrunkInbound),
                "TRUNK_OUTBOUND" => Some(Self::TrunkOutbound),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSipInboundTrunkRequest {
    /// Trunk ID is ignored
    #[prost(message, optional, tag = "1")]
    pub trunk: ::core::option::Option<SipInboundTrunkInfo>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSipInboundTrunkRequest {
    #[prost(string, tag = "1")]
    pub sip_trunk_id: ::prost::alloc::string::String,
    #[prost(oneof = "update_sip_inbound_trunk_request::Action", tags = "2, 3")]
    pub action: ::core::option::Option<update_sip_inbound_trunk_request::Action>,
}
/// Nested message and enum types in `UpdateSIPInboundTrunkRequest`.
pub mod update_sip_inbound_trunk_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        #[prost(message, tag = "2")]
        Replace(super::SipInboundTrunkInfo),
        #[prost(message, tag = "3")]
        Update(super::SipInboundTrunkUpdate),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SipInboundTrunkInfo {
    #[prost(string, tag = "1")]
    pub sip_trunk_id: ::prost::alloc::string::String,
    /// Human-readable name for the Trunk.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// User-defined metadata for the Trunk.
    #[prost(string, tag = "3")]
    pub metadata: ::prost::alloc::string::String,
    /// Numbers associated with LiveKit SIP. The Trunk will only accept calls made to these numbers.
    /// Creating multiple Trunks with different phone numbers allows having different rules for a single provider.
    #[prost(string, repeated, tag = "4")]
    pub numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// CIDR or IPs that traffic is accepted from.
    /// An empty list means all inbound traffic is accepted.
    #[prost(string, repeated, tag = "5")]
    pub allowed_addresses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Numbers that are allowed to make calls to this Trunk.
    /// An empty list means calls from any phone number is accepted.
    #[prost(string, repeated, tag = "6")]
    pub allowed_numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Username and password used to authenticate inbound SIP invites.
    /// May be empty to have no authentication.
    #[prost(string, tag = "7")]
    pub auth_username: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub auth_password: ::prost::alloc::string::String,
    #[prost(string, tag = "19")]
    pub auth_realm: ::prost::alloc::string::String,
    /// Include these SIP X-* headers in 200 OK responses.
    #[prost(map = "string, string", tag = "9")]
    pub headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Map SIP X-* headers from INVITE to SIP participant attributes.
    #[prost(map = "string, string", tag = "10")]
    pub headers_to_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Map LiveKit attributes to SIP X-* headers when sending BYE or REFER requests.
    /// Keys are the names of attributes and values are the names of X-* headers they will be mapped to.
    #[prost(map = "string, string", tag = "14")]
    pub attributes_to_headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Map SIP headers from INVITE to sip.h.* participant attributes automatically.
    ///
    /// When the names of required headers is known, using headers_to_attributes is strongly recommended.
    ///
    /// When mapping INVITE headers to response headers with attributes_to_headers map,
    /// lowercase header names should be used, for example: sip.h.x-custom-header.
    #[prost(enumeration = "SipHeaderOptions", tag = "15")]
    pub include_headers: i32,
    /// Max time for the caller to wait for track subscription.
    #[prost(message, optional, tag = "11")]
    pub ringing_timeout: ::core::option::Option<::pbjson_types::Duration>,
    /// Max call duration.
    #[prost(message, optional, tag = "12")]
    pub max_call_duration: ::core::option::Option<::pbjson_types::Duration>,
    #[prost(bool, tag = "13")]
    pub krisp_enabled: bool,
    #[deprecated]
    #[prost(enumeration = "SipMediaEncryption", tag = "16")]
    pub media_encryption: i32,
    #[prost(message, optional, tag = "20")]
    pub media: ::core::option::Option<SipMediaConfig>,
    #[prost(message, optional, tag = "17")]
    pub created_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "18")]
    pub updated_at: ::core::option::Option<::pbjson_types::Timestamp>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SipInboundTrunkUpdate {
    #[prost(message, optional, tag = "1")]
    pub numbers: ::core::option::Option<ListUpdate>,
    #[prost(message, optional, tag = "2")]
    pub allowed_addresses: ::core::option::Option<ListUpdate>,
    #[prost(message, optional, tag = "3")]
    pub allowed_numbers: ::core::option::Option<ListUpdate>,
    #[prost(string, optional, tag = "4")]
    pub auth_username: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "5")]
    pub auth_password: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "9")]
    pub auth_realm: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "6")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "7")]
    pub metadata: ::core::option::Option<::prost::alloc::string::String>,
    #[deprecated]
    #[prost(enumeration = "SipMediaEncryption", optional, tag = "8")]
    pub media_encryption: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "10")]
    pub media: ::core::option::Option<SipMediaConfig>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSipOutboundTrunkRequest {
    /// Trunk ID is ignored
    #[prost(message, optional, tag = "1")]
    pub trunk: ::core::option::Option<SipOutboundTrunkInfo>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSipOutboundTrunkRequest {
    #[prost(string, tag = "1")]
    pub sip_trunk_id: ::prost::alloc::string::String,
    #[prost(oneof = "update_sip_outbound_trunk_request::Action", tags = "2, 3")]
    pub action: ::core::option::Option<update_sip_outbound_trunk_request::Action>,
}
/// Nested message and enum types in `UpdateSIPOutboundTrunkRequest`.
pub mod update_sip_outbound_trunk_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        #[prost(message, tag = "2")]
        Replace(super::SipOutboundTrunkInfo),
        #[prost(message, tag = "3")]
        Update(super::SipOutboundTrunkUpdate),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SipOutboundTrunkInfo {
    #[prost(string, tag = "1")]
    pub sip_trunk_id: ::prost::alloc::string::String,
    /// Human-readable name for the Trunk.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// User-defined metadata for the Trunk.
    #[prost(string, tag = "3")]
    pub metadata: ::prost::alloc::string::String,
    /// Hostname or IP that SIP INVITE is sent too.
    /// Note that this is not a SIP URI and should not contain the 'sip:' protocol prefix.
    #[prost(string, tag = "4")]
    pub address: ::prost::alloc::string::String,
    /// country where the call terminates as ISO 3166-1 alpha-2 (<https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2>). This will be used by the livekit infrastructure to route calls.
    #[prost(string, tag = "14")]
    pub destination_country: ::prost::alloc::string::String,
    /// SIP Transport used for outbound call.
    #[prost(enumeration = "SipTransport", tag = "5")]
    pub transport: i32,
    /// Numbers used to make the calls. Random one from this list will be selected.
    #[prost(string, repeated, tag = "6")]
    pub numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Username and password used to authenticate with SIP server.
    /// May be empty to have no authentication.
    #[prost(string, tag = "7")]
    pub auth_username: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub auth_password: ::prost::alloc::string::String,
    /// Include these SIP X-* headers in INVITE request.
    /// These headers are sent as-is and may help identify this call as coming from LiveKit for the other SIP endpoint.
    #[prost(map = "string, string", tag = "9")]
    pub headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Map SIP X-* headers from 200 OK to SIP participant attributes.
    /// Keys are the names of X-* headers and values are the names of attributes they will be mapped to.
    #[prost(map = "string, string", tag = "10")]
    pub headers_to_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Map LiveKit attributes to SIP X-* headers when sending BYE or REFER requests.
    /// Keys are the names of attributes and values are the names of X-* headers they will be mapped to.
    #[prost(map = "string, string", tag = "11")]
    pub attributes_to_headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Map SIP headers from 200 OK to sip.h.* participant attributes automatically.
    ///
    /// When the names of required headers is known, using headers_to_attributes is strongly recommended.
    ///
    /// When mapping 200 OK headers to follow-up request headers with attributes_to_headers map,
    /// lowercase header names should be used, for example: sip.h.x-custom-header.
    #[prost(enumeration = "SipHeaderOptions", tag = "12")]
    pub include_headers: i32,
    #[deprecated]
    #[prost(enumeration = "SipMediaEncryption", tag = "13")]
    pub media_encryption: i32,
    #[prost(message, optional, tag = "18")]
    pub media: ::core::option::Option<SipMediaConfig>,
    /// Optional custom hostname for the 'From' SIP header in outbound INVITEs.
    /// When set, outbound calls from this trunk will use this host instead of the default project SIP domain.
    /// Enables originating calls from custom domains.
    #[prost(string, tag = "15")]
    pub from_host: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "16")]
    pub created_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "17")]
    pub updated_at: ::core::option::Option<::pbjson_types::Timestamp>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SipOutboundTrunkUpdate {
    #[prost(string, optional, tag = "1")]
    pub address: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(enumeration = "SipTransport", optional, tag = "2")]
    pub transport: ::core::option::Option<i32>,
    #[prost(string, optional, tag = "9")]
    pub destination_country: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub numbers: ::core::option::Option<ListUpdate>,
    #[prost(string, optional, tag = "4")]
    pub auth_username: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "5")]
    pub auth_password: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "6")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "7")]
    pub metadata: ::core::option::Option<::prost::alloc::string::String>,
    #[deprecated]
    #[prost(enumeration = "SipMediaEncryption", optional, tag = "8")]
    pub media_encryption: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "11")]
    pub media: ::core::option::Option<SipMediaConfig>,
    #[prost(string, optional, tag = "10")]
    pub from_host: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSipInboundTrunkRequest {
    #[prost(string, tag = "1")]
    pub sip_trunk_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSipInboundTrunkResponse {
    #[prost(message, optional, tag = "1")]
    pub trunk: ::core::option::Option<SipInboundTrunkInfo>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSipOutboundTrunkRequest {
    #[prost(string, tag = "1")]
    pub sip_trunk_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSipOutboundTrunkResponse {
    #[prost(message, optional, tag = "1")]
    pub trunk: ::core::option::Option<SipOutboundTrunkInfo>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListSipTrunkRequest {
    #[prost(message, optional, tag = "1")]
    pub page: ::core::option::Option<Pagination>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSipTrunkResponse {
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<SipTrunkInfo>,
}
/// ListSIPInboundTrunkRequest lists inbound trunks for given filters. If no filters are set, all trunks are listed.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListSipInboundTrunkRequest {
    #[prost(message, optional, tag = "3")]
    pub page: ::core::option::Option<Pagination>,
    /// Trunk IDs to list. If this option is set, the response will contains trunks in the same order.
    /// If any of the trunks is missing, a nil item in that position will be sent in the response.
    #[prost(string, repeated, tag = "1")]
    pub trunk_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Only list trunks that contain one of the numbers, including wildcard trunks.
    #[prost(string, repeated, tag = "2")]
    pub numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSipInboundTrunkResponse {
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<SipInboundTrunkInfo>,
}
/// ListSIPOutboundTrunkRequest lists outbound trunks for given filters. If no filters are set, all trunks are listed.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListSipOutboundTrunkRequest {
    #[prost(message, optional, tag = "3")]
    pub page: ::core::option::Option<Pagination>,
    /// Trunk IDs to list. If this option is set, the response will contains trunks in the same order.
    /// If any of the trunks is missing, a nil item in that position will be sent in the response.
    #[prost(string, repeated, tag = "1")]
    pub trunk_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Only list trunks that contain one of the numbers, including wildcard trunks.
    #[prost(string, repeated, tag = "2")]
    pub numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSipOutboundTrunkResponse {
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<SipOutboundTrunkInfo>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteSipTrunkRequest {
    #[prost(string, tag = "1")]
    pub sip_trunk_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipDispatchRuleDirect {
    /// What room should call be directed into
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
    /// Optional pin required to enter room
    #[prost(string, tag = "2")]
    pub pin: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipDispatchRuleIndividual {
    /// Prefix used on new room name
    #[prost(string, tag = "1")]
    pub room_prefix: ::prost::alloc::string::String,
    /// Optional pin required to enter room
    #[prost(string, tag = "2")]
    pub pin: ::prost::alloc::string::String,
    /// Optionally append random suffix
    #[prost(bool, tag = "3")]
    pub no_randomness: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipDispatchRuleCallee {
    /// Prefix used on new room name
    #[prost(string, tag = "1")]
    pub room_prefix: ::prost::alloc::string::String,
    /// Optional pin required to enter room
    #[prost(string, tag = "2")]
    pub pin: ::prost::alloc::string::String,
    /// Optionally append random suffix
    #[prost(bool, tag = "3")]
    pub randomize: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipDispatchRule {
    #[prost(oneof = "sip_dispatch_rule::Rule", tags = "1, 2, 3")]
    pub rule: ::core::option::Option<sip_dispatch_rule::Rule>,
}
/// Nested message and enum types in `SIPDispatchRule`.
pub mod sip_dispatch_rule {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Rule {
        /// SIPDispatchRuleDirect is a `SIP Dispatch Rule` that puts a user directly into a room
        /// This places users into an existing room. Optionally you can require a pin before a user can
        /// enter the room
        #[prost(message, tag = "1")]
        DispatchRuleDirect(super::SipDispatchRuleDirect),
        /// SIPDispatchRuleIndividual is a `SIP Dispatch Rule` that creates a new room for each caller.
        #[prost(message, tag = "2")]
        DispatchRuleIndividual(super::SipDispatchRuleIndividual),
        /// SIPDispatchRuleCallee is a `SIP Dispatch Rule` that creates a new room for each callee.
        #[prost(message, tag = "3")]
        DispatchRuleCallee(super::SipDispatchRuleCallee),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSipDispatchRuleRequest {
    /// Rule ID is ignored
    #[prost(message, optional, tag = "10")]
    pub dispatch_rule: ::core::option::Option<SipDispatchRuleInfo>,
    #[deprecated]
    #[prost(message, optional, tag = "1")]
    pub rule: ::core::option::Option<SipDispatchRule>,
    /// What trunks are accepted for this dispatch rule
    /// If empty all trunks will match this dispatch rule
    #[deprecated]
    #[prost(string, repeated, tag = "2")]
    pub trunk_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// By default the From value (Phone number) is used for participant name/identity and added to attributes.
    /// If true, a random value for identity will be used and numbers will be omitted from attributes.
    #[deprecated]
    #[prost(bool, tag = "3")]
    pub hide_phone_number: bool,
    /// Dispatch Rule will only accept a call made to these numbers (if set).
    #[deprecated]
    #[prost(string, repeated, tag = "6")]
    pub inbound_numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional human-readable name for the Dispatch Rule.
    #[deprecated]
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// User-defined metadata for the Dispatch Rule.
    /// Participants created by this rule will inherit this metadata.
    #[deprecated]
    #[prost(string, tag = "5")]
    pub metadata: ::prost::alloc::string::String,
    /// User-defined attributes for the Dispatch Rule.
    /// Participants created by this rule will inherit these attributes.
    #[prost(map = "string, string", tag = "7")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Cloud-only, config preset to use
    #[deprecated]
    #[prost(string, tag = "8")]
    pub room_preset: ::prost::alloc::string::String,
    /// RoomConfiguration to use if the participant initiates the room
    #[deprecated]
    #[prost(message, optional, tag = "9")]
    pub room_config: ::core::option::Option<RoomConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSipDispatchRuleRequest {
    #[prost(string, tag = "1")]
    pub sip_dispatch_rule_id: ::prost::alloc::string::String,
    #[prost(oneof = "update_sip_dispatch_rule_request::Action", tags = "2, 3")]
    pub action: ::core::option::Option<update_sip_dispatch_rule_request::Action>,
}
/// Nested message and enum types in `UpdateSIPDispatchRuleRequest`.
pub mod update_sip_dispatch_rule_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        #[prost(message, tag = "2")]
        Replace(super::SipDispatchRuleInfo),
        #[prost(message, tag = "3")]
        Update(super::SipDispatchRuleUpdate),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SipDispatchRuleInfo {
    #[prost(string, tag = "1")]
    pub sip_dispatch_rule_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub rule: ::core::option::Option<SipDispatchRule>,
    #[prost(string, repeated, tag = "3")]
    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 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,
    /// User-defined metadata for the Dispatch Rule.
    /// Participants created by this rule will inherit this metadata.
    #[prost(string, tag = "6")]
    pub metadata: ::prost::alloc::string::String,
    /// User-defined attributes for the Dispatch Rule.
    /// Participants created by this rule will inherit these attributes.
    #[prost(map = "string, string", tag = "8")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Cloud-only, config preset to use
    #[prost(string, tag = "9")]
    pub room_preset: ::prost::alloc::string::String,
    /// RoomConfiguration to use if the participant initiates the room
    #[prost(message, optional, tag = "10")]
    pub room_config: ::core::option::Option<RoomConfiguration>,
    #[prost(message, optional, tag = "16")]
    pub media: ::core::option::Option<SipMediaConfig>,
    #[prost(bool, tag = "11")]
    pub krisp_enabled: bool,
    #[deprecated]
    #[prost(enumeration = "SipMediaEncryption", tag = "12")]
    pub media_encryption: i32,
    #[prost(message, optional, tag = "14")]
    pub created_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "15")]
    pub updated_at: ::core::option::Option<::pbjson_types::Timestamp>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SipDispatchRuleUpdate {
    #[prost(message, optional, tag = "1")]
    pub trunk_ids: ::core::option::Option<ListUpdate>,
    #[prost(message, optional, tag = "2")]
    pub rule: ::core::option::Option<SipDispatchRule>,
    #[prost(string, optional, tag = "3")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "4")]
    pub metadata: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(map = "string, string", tag = "5")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    #[deprecated]
    #[prost(enumeration = "SipMediaEncryption", optional, tag = "6")]
    pub media_encryption: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "7")]
    pub media: ::core::option::Option<SipMediaConfig>,
}
/// ListSIPDispatchRuleRequest lists dispatch rules for given filters. If no filters are set, all rules are listed.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListSipDispatchRuleRequest {
    #[prost(message, optional, tag = "3")]
    pub page: ::core::option::Option<Pagination>,
    /// Rule IDs to list. If this option is set, the response will contains rules in the same order.
    /// If any of the rules is missing, a nil item in that position will be sent in the response.
    #[prost(string, repeated, tag = "1")]
    pub dispatch_rule_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Only list rules that contain one of the Trunk IDs, including wildcard rules.
    #[prost(string, repeated, tag = "2")]
    pub trunk_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSipDispatchRuleResponse {
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<SipDispatchRuleInfo>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteSipDispatchRuleRequest {
    #[prost(string, tag = "1")]
    pub sip_dispatch_rule_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SipOutboundConfig {
    /// SIP server address
    #[prost(string, tag = "1")]
    pub hostname: ::prost::alloc::string::String,
    /// country where the call terminates as ISO 3166-1 alpha-2 (<https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2>). This will be used by the livekit infrastructure to route calls.
    #[prost(string, tag = "7")]
    pub destination_country: ::prost::alloc::string::String,
    /// SIP Transport used for outbound call.
    #[prost(enumeration = "SipTransport", tag = "2")]
    pub transport: i32,
    /// Username and password used to authenticate with SIP server.
    /// May be empty to have no authentication.
    #[prost(string, tag = "3")]
    pub auth_username: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub auth_password: ::prost::alloc::string::String,
    /// Map SIP X-* headers from 200 OK to SIP participant attributes.
    /// Keys are the names of X-* headers and values are the names of attributes they will be mapped to.
    #[prost(map = "string, string", tag = "5")]
    pub headers_to_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Map LiveKit attributes to SIP X-* headers when sending BYE or REFER requests.
    /// Keys are the names of attributes and values are the names of X-* headers they will be mapped to.
    #[prost(map = "string, string", tag = "6")]
    pub attributes_to_headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Optional custom hostname for the 'From' SIP header. When set, outbound calls use this host instead of the default project SIP domain.
    #[prost(string, tag = "8")]
    pub from_host: ::prost::alloc::string::String,
}
/// A SIP Participant is a singular SIP session connected to a LiveKit room via
/// a SIP Trunk into a SIP DispatchRule
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSipParticipantRequest {
    /// What SIP Trunk should be used to dial the user
    #[prost(string, tag = "1")]
    pub sip_trunk_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "20")]
    pub trunk: ::core::option::Option<SipOutboundConfig>,
    /// INVITE <uri>
    #[prost(message, optional, tag = "24")]
    pub sip_request_uri: ::core::option::Option<SipRequestDest>,
    /// To:   "Name" <uri>
    #[prost(message, optional, tag = "25")]
    pub sip_to_header: ::core::option::Option<SipNamedDest>,
    /// From: "Name" <uri>
    #[prost(message, optional, tag = "26")]
    pub sip_from_header: ::core::option::Option<SipNamedDest>,
    /// What number should be dialed via SIP
    #[prost(string, tag = "2")]
    pub sip_call_to: ::prost::alloc::string::String,
    /// Optional SIP From number to use. If empty, trunk number is used.
    #[prost(string, tag = "15")]
    pub sip_number: ::prost::alloc::string::String,
    /// What LiveKit room should this participant be connected too
    #[prost(string, tag = "3")]
    pub room_name: ::prost::alloc::string::String,
    /// Optional identity of the participant in LiveKit room
    #[prost(string, tag = "4")]
    pub participant_identity: ::prost::alloc::string::String,
    /// Optional name of the participant in LiveKit room
    #[prost(string, tag = "7")]
    pub participant_name: ::prost::alloc::string::String,
    /// Optional user-defined metadata. Will be attached to a created Participant in the room.
    #[prost(string, tag = "8")]
    pub participant_metadata: ::prost::alloc::string::String,
    /// Optional user-defined attributes. Will be attached to a created Participant in the room.
    #[prost(map = "string, string", tag = "9")]
    pub participant_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Optionally send following DTMF digits (extension codes) when making a call.
    /// Character 'w' can be used to add a 0.5 sec delay.
    #[prost(string, tag = "5")]
    pub dtmf: ::prost::alloc::string::String,
    /// Optionally play dialtone in the room as an audible indicator for existing participants. The `play_ringtone` option is deprectated but has the same effect.
    #[deprecated]
    #[prost(bool, tag = "6")]
    pub play_ringtone: bool,
    #[prost(bool, tag = "13")]
    pub play_dialtone: bool,
    /// By default the From value (Phone number) is used for participant name/identity (if not set) and added to attributes.
    /// If true, a random value for identity will be used and numbers will be omitted from attributes.
    #[prost(bool, tag = "10")]
    pub hide_phone_number: bool,
    /// These headers are sent as-is and may help identify this call as coming from LiveKit for the other SIP endpoint.
    #[prost(map = "string, string", tag = "16")]
    pub headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Map SIP headers from 200 OK to sip.h.* participant attributes automatically.
    ///
    /// When the names of required headers is known, using headers_to_attributes is strongly recommended.
    ///
    /// When mapping 200 OK headers to follow-up request headers with attributes_to_headers map,
    /// lowercase header names should be used, for example: sip.h.x-custom-header.
    #[prost(enumeration = "SipHeaderOptions", tag = "17")]
    pub include_headers: i32,
    /// Max time for the callee to answer the call.
    #[prost(message, optional, tag = "11")]
    pub ringing_timeout: ::core::option::Option<::pbjson_types::Duration>,
    /// Max call duration.
    #[prost(message, optional, tag = "12")]
    pub max_call_duration: ::core::option::Option<::pbjson_types::Duration>,
    /// Enable voice isolation for the callee.
    #[prost(bool, tag = "14")]
    pub krisp_enabled: bool,
    #[deprecated]
    #[prost(enumeration = "SipMediaEncryption", tag = "18")]
    pub media_encryption: i32,
    #[prost(message, optional, tag = "23")]
    pub media: ::core::option::Option<SipMediaConfig>,
    /// Wait for the answer for the call before returning.
    #[prost(bool, tag = "19")]
    pub wait_until_answered: bool,
    /// Optional display name for the 'From' SIP header.
    ///
    /// Cases:
    /// 1) Unspecified: Use legacy behavior - display name will be set to be the caller's number.
    /// 2) Empty string: Do not send a display name, which will result in a CNAM lookup downstream.
    /// 3) Non-empty: Use the specified value as the display name.
    #[prost(string, optional, tag = "21")]
    pub display_name: ::core::option::Option<::prost::alloc::string::String>,
    /// NEXT ID: 27
    #[prost(message, optional, tag = "22")]
    pub destination: ::core::option::Option<Destination>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipParticipantInfo {
    #[prost(string, tag = "1")]
    pub participant_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub participant_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub sip_call_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransferSipParticipantRequest {
    #[prost(string, tag = "1")]
    pub participant_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub transfer_to: ::prost::alloc::string::String,
    /// Optionally play dialtone to the SIP participant as an audible indicator of being transferred
    #[prost(bool, tag = "4")]
    pub play_dialtone: bool,
    /// Add the following headers to the REFER SIP request.
    #[prost(map = "string, string", tag = "5")]
    pub headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Max time for the transfer destination to answer the call.
    #[prost(message, optional, tag = "6")]
    pub ringing_timeout: ::core::option::Option<::pbjson_types::Duration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SipCallInfo {
    #[prost(string, tag = "1")]
    pub call_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub trunk_id: ::prost::alloc::string::String,
    #[prost(string, tag = "16")]
    pub dispatch_rule_id: ::prost::alloc::string::String,
    #[prost(string, tag = "17")]
    pub region: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub room_name: ::prost::alloc::string::String,
    /// ID of the current/previous room published to
    #[prost(string, tag = "4")]
    pub room_id: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub participant_identity: ::prost::alloc::string::String,
    #[prost(map = "string, string", tag = "18")]
    pub participant_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    #[prost(message, optional, tag = "6")]
    pub from_uri: ::core::option::Option<SipUri>,
    #[prost(message, optional, tag = "7")]
    pub to_uri: ::core::option::Option<SipUri>,
    #[deprecated]
    #[prost(int64, tag = "9")]
    pub created_at: i64,
    #[deprecated]
    #[prost(int64, tag = "10")]
    pub started_at: i64,
    #[deprecated]
    #[prost(int64, tag = "11")]
    pub ended_at: i64,
    #[prost(enumeration = "SipFeature", repeated, tag = "14")]
    pub enabled_features: ::prost::alloc::vec::Vec<i32>,
    #[prost(enumeration = "SipCallDirection", tag = "15")]
    pub call_direction: i32,
    #[prost(enumeration = "SipCallStatus", tag = "8")]
    pub call_status: i32,
    #[prost(int64, tag = "22")]
    pub created_at_ns: i64,
    #[prost(int64, tag = "23")]
    pub started_at_ns: i64,
    #[prost(int64, tag = "24")]
    pub ended_at_ns: i64,
    #[prost(enumeration = "DisconnectReason", tag = "12")]
    pub disconnect_reason: i32,
    #[prost(string, tag = "13")]
    pub error: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "19")]
    pub call_status_code: ::core::option::Option<SipStatus>,
    #[prost(string, tag = "20")]
    pub audio_codec: ::prost::alloc::string::String,
    #[prost(string, tag = "21")]
    pub media_encryption: ::prost::alloc::string::String,
    #[prost(string, tag = "25")]
    pub pcap_file_link: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "26")]
    pub call_context: ::prost::alloc::vec::Vec<::pbjson_types::Any>,
    #[prost(message, optional, tag = "27")]
    pub provider_info: ::core::option::Option<ProviderInfo>,
    #[prost(string, tag = "28")]
    pub sip_call_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipTransferInfo {
    #[prost(string, tag = "1")]
    pub transfer_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub call_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub transfer_to: ::prost::alloc::string::String,
    #[prost(int64, tag = "4")]
    pub transfer_initiated_at_ns: i64,
    #[prost(int64, tag = "5")]
    pub transfer_completed_at_ns: i64,
    #[prost(enumeration = "SipTransferStatus", tag = "6")]
    pub transfer_status: i32,
    #[prost(string, tag = "7")]
    pub error: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "8")]
    pub transfer_status_code: ::core::option::Option<SipStatus>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipUri {
    #[prost(string, tag = "1")]
    pub user: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub host: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub ip: ::prost::alloc::string::String,
    #[prost(uint32, tag = "4")]
    pub port: u32,
    #[prost(enumeration = "SipTransport", tag = "5")]
    pub transport: i32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipRequestDest {
    #[prost(oneof = "sip_request_dest::Uri", tags = "1, 2")]
    pub uri: ::core::option::Option<sip_request_dest::Uri>,
}
/// Nested message and enum types in `SIPRequestDest`.
pub mod sip_request_dest {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Uri {
        /// <sip:user@sip.example.com:5060;transport=tcp>
        #[prost(string, tag = "1")]
        Raw(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        Values(super::SipUri),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipNamedDest {
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
    #[prost(oneof = "sip_named_dest::Uri", tags = "1, 2")]
    pub uri: ::core::option::Option<sip_named_dest::Uri>,
}
/// Nested message and enum types in `SIPNamedDest`.
pub mod sip_named_dest {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Uri {
        /// <sip:user@sip.example.com:5060;transport=tcp>
        #[prost(string, tag = "1")]
        Raw(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        Values(super::SipUri),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Destination {
    #[prost(string, tag = "1")]
    pub city: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub country: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub region: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SipStatusCode {
    SipStatusUnknown = 0,
    SipStatusTrying = 100,
    SipStatusRinging = 180,
    SipStatusCallIsForwarded = 181,
    SipStatusQueued = 182,
    SipStatusSessionProgress = 183,
    SipStatusEarlyDialogTerminated = 199,
    SipStatusOk = 200,
    SipStatusAccepted = 202,
    SipStatusNoNotification = 204,
    SipStatusMultipleChoices = 300,
    SipStatusMovedPermanently = 301,
    SipStatusMovedTemporarily = 302,
    SipStatusUseProxy = 305,
    SipStatusAlternativeService = 380,
    SipStatusBadRequest = 400,
    SipStatusUnauthorized = 401,
    SipStatusPaymentRequired = 402,
    SipStatusForbidden = 403,
    SipStatusNotfound = 404,
    SipStatusMethodNotAllowed = 405,
    SipStatusNotAcceptable = 406,
    SipStatusProxyAuthRequired = 407,
    SipStatusRequestTimeout = 408,
    SipStatusConflict = 409,
    SipStatusGone = 410,
    SipStatusLengthRequired = 411,
    SipStatusConditionalRequestFailed = 412,
    SipStatusRequestEntityTooLarge = 413,
    SipStatusRequestUriTooLong = 414,
    SipStatusUnsupportedMediaType = 415,
    SipStatusRequestedRangeNotSatisfiable = 416,
    SipStatusUnknownResourcePriority = 417,
    SipStatusBadExtension = 420,
    SipStatusExtensionRequired = 421,
    SipStatusSessionIntervalTooSmall = 422,
    SipStatusIntervalTooBrief = 423,
    SipStatusBadLocationInformation = 424,
    SipStatusBadAlertMessage = 425,
    SipStatusUseIdentityHeader = 428,
    SipStatusProvideReferrerIdentity = 429,
    SipStatusFlowFailed = 430,
    SipStatusAnonymityDisallowed = 433,
    SipStatusBadIdentityInfo = 436,
    SipStatusUnsupportedCertificate = 437,
    SipStatusInvalidIdentityHeader = 438,
    SipStatusFirstHopLacksOutboundSupport = 439,
    SipStatusMaxBreadthExceeded = 440,
    SipStatusBadInfoPackage = 469,
    SipStatusConsentNeeded = 470,
    SipStatusTemporarilyUnavailable = 480,
    SipStatusCallTransactionDoesNotExists = 481,
    SipStatusLoopDetected = 482,
    SipStatusTooManyHops = 483,
    SipStatusAddressIncomplete = 484,
    SipStatusAmbiguous = 485,
    SipStatusBusyHere = 486,
    SipStatusRequestTerminated = 487,
    SipStatusNotAcceptableHere = 488,
    SipStatusBadEvent = 489,
    SipStatusRequestPending = 491,
    SipStatusUndecipherable = 493,
    SipStatusSecurityAgreementRequired = 494,
    SipStatusInternalServerError = 500,
    SipStatusNotImplemented = 501,
    SipStatusBadGateway = 502,
    SipStatusServiceUnavailable = 503,
    SipStatusGatewayTimeout = 504,
    SipStatusVersionNotSupported = 505,
    SipStatusMessageTooLarge = 513,
    SipStatusGlobalBusyEverywhere = 600,
    SipStatusGlobalDecline = 603,
    SipStatusGlobalDoesNotExistAnywhere = 604,
    SipStatusGlobalNotAcceptable = 606,
    SipStatusGlobalUnwanted = 607,
    SipStatusGlobalRejected = 608,
}
impl SipStatusCode {
    /// 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 {
            Self::SipStatusUnknown => "SIP_STATUS_UNKNOWN",
            Self::SipStatusTrying => "SIP_STATUS_TRYING",
            Self::SipStatusRinging => "SIP_STATUS_RINGING",
            Self::SipStatusCallIsForwarded => "SIP_STATUS_CALL_IS_FORWARDED",
            Self::SipStatusQueued => "SIP_STATUS_QUEUED",
            Self::SipStatusSessionProgress => "SIP_STATUS_SESSION_PROGRESS",
            Self::SipStatusEarlyDialogTerminated => "SIP_STATUS_EARLY_DIALOG_TERMINATED",
            Self::SipStatusOk => "SIP_STATUS_OK",
            Self::SipStatusAccepted => "SIP_STATUS_ACCEPTED",
            Self::SipStatusNoNotification => "SIP_STATUS_NO_NOTIFICATION",
            Self::SipStatusMultipleChoices => "SIP_STATUS_MULTIPLE_CHOICES",
            Self::SipStatusMovedPermanently => "SIP_STATUS_MOVED_PERMANENTLY",
            Self::SipStatusMovedTemporarily => "SIP_STATUS_MOVED_TEMPORARILY",
            Self::SipStatusUseProxy => "SIP_STATUS_USE_PROXY",
            Self::SipStatusAlternativeService => "SIP_STATUS_ALTERNATIVE_SERVICE",
            Self::SipStatusBadRequest => "SIP_STATUS_BAD_REQUEST",
            Self::SipStatusUnauthorized => "SIP_STATUS_UNAUTHORIZED",
            Self::SipStatusPaymentRequired => "SIP_STATUS_PAYMENT_REQUIRED",
            Self::SipStatusForbidden => "SIP_STATUS_FORBIDDEN",
            Self::SipStatusNotfound => "SIP_STATUS_NOTFOUND",
            Self::SipStatusMethodNotAllowed => "SIP_STATUS_METHOD_NOT_ALLOWED",
            Self::SipStatusNotAcceptable => "SIP_STATUS_NOT_ACCEPTABLE",
            Self::SipStatusProxyAuthRequired => "SIP_STATUS_PROXY_AUTH_REQUIRED",
            Self::SipStatusRequestTimeout => "SIP_STATUS_REQUEST_TIMEOUT",
            Self::SipStatusConflict => "SIP_STATUS_CONFLICT",
            Self::SipStatusGone => "SIP_STATUS_GONE",
            Self::SipStatusLengthRequired => "SIP_STATUS_LENGTH_REQUIRED",
            Self::SipStatusConditionalRequestFailed => "SIP_STATUS_CONDITIONAL_REQUEST_FAILED",
            Self::SipStatusRequestEntityTooLarge => "SIP_STATUS_REQUEST_ENTITY_TOO_LARGE",
            Self::SipStatusRequestUriTooLong => "SIP_STATUS_REQUEST_URI_TOO_LONG",
            Self::SipStatusUnsupportedMediaType => "SIP_STATUS_UNSUPPORTED_MEDIA_TYPE",
            Self::SipStatusRequestedRangeNotSatisfiable => "SIP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE",
            Self::SipStatusUnknownResourcePriority => "SIP_STATUS_UNKNOWN_RESOURCE_PRIORITY",
            Self::SipStatusBadExtension => "SIP_STATUS_BAD_EXTENSION",
            Self::SipStatusExtensionRequired => "SIP_STATUS_EXTENSION_REQUIRED",
            Self::SipStatusSessionIntervalTooSmall => "SIP_STATUS_SESSION_INTERVAL_TOO_SMALL",
            Self::SipStatusIntervalTooBrief => "SIP_STATUS_INTERVAL_TOO_BRIEF",
            Self::SipStatusBadLocationInformation => "SIP_STATUS_BAD_LOCATION_INFORMATION",
            Self::SipStatusBadAlertMessage => "SIP_STATUS_BAD_ALERT_MESSAGE",
            Self::SipStatusUseIdentityHeader => "SIP_STATUS_USE_IDENTITY_HEADER",
            Self::SipStatusProvideReferrerIdentity => "SIP_STATUS_PROVIDE_REFERRER_IDENTITY",
            Self::SipStatusFlowFailed => "SIP_STATUS_FLOW_FAILED",
            Self::SipStatusAnonymityDisallowed => "SIP_STATUS_ANONYMITY_DISALLOWED",
            Self::SipStatusBadIdentityInfo => "SIP_STATUS_BAD_IDENTITY_INFO",
            Self::SipStatusUnsupportedCertificate => "SIP_STATUS_UNSUPPORTED_CERTIFICATE",
            Self::SipStatusInvalidIdentityHeader => "SIP_STATUS_INVALID_IDENTITY_HEADER",
            Self::SipStatusFirstHopLacksOutboundSupport => "SIP_STATUS_FIRST_HOP_LACKS_OUTBOUND_SUPPORT",
            Self::SipStatusMaxBreadthExceeded => "SIP_STATUS_MAX_BREADTH_EXCEEDED",
            Self::SipStatusBadInfoPackage => "SIP_STATUS_BAD_INFO_PACKAGE",
            Self::SipStatusConsentNeeded => "SIP_STATUS_CONSENT_NEEDED",
            Self::SipStatusTemporarilyUnavailable => "SIP_STATUS_TEMPORARILY_UNAVAILABLE",
            Self::SipStatusCallTransactionDoesNotExists => "SIP_STATUS_CALL_TRANSACTION_DOES_NOT_EXISTS",
            Self::SipStatusLoopDetected => "SIP_STATUS_LOOP_DETECTED",
            Self::SipStatusTooManyHops => "SIP_STATUS_TOO_MANY_HOPS",
            Self::SipStatusAddressIncomplete => "SIP_STATUS_ADDRESS_INCOMPLETE",
            Self::SipStatusAmbiguous => "SIP_STATUS_AMBIGUOUS",
            Self::SipStatusBusyHere => "SIP_STATUS_BUSY_HERE",
            Self::SipStatusRequestTerminated => "SIP_STATUS_REQUEST_TERMINATED",
            Self::SipStatusNotAcceptableHere => "SIP_STATUS_NOT_ACCEPTABLE_HERE",
            Self::SipStatusBadEvent => "SIP_STATUS_BAD_EVENT",
            Self::SipStatusRequestPending => "SIP_STATUS_REQUEST_PENDING",
            Self::SipStatusUndecipherable => "SIP_STATUS_UNDECIPHERABLE",
            Self::SipStatusSecurityAgreementRequired => "SIP_STATUS_SECURITY_AGREEMENT_REQUIRED",
            Self::SipStatusInternalServerError => "SIP_STATUS_INTERNAL_SERVER_ERROR",
            Self::SipStatusNotImplemented => "SIP_STATUS_NOT_IMPLEMENTED",
            Self::SipStatusBadGateway => "SIP_STATUS_BAD_GATEWAY",
            Self::SipStatusServiceUnavailable => "SIP_STATUS_SERVICE_UNAVAILABLE",
            Self::SipStatusGatewayTimeout => "SIP_STATUS_GATEWAY_TIMEOUT",
            Self::SipStatusVersionNotSupported => "SIP_STATUS_VERSION_NOT_SUPPORTED",
            Self::SipStatusMessageTooLarge => "SIP_STATUS_MESSAGE_TOO_LARGE",
            Self::SipStatusGlobalBusyEverywhere => "SIP_STATUS_GLOBAL_BUSY_EVERYWHERE",
            Self::SipStatusGlobalDecline => "SIP_STATUS_GLOBAL_DECLINE",
            Self::SipStatusGlobalDoesNotExistAnywhere => "SIP_STATUS_GLOBAL_DOES_NOT_EXIST_ANYWHERE",
            Self::SipStatusGlobalNotAcceptable => "SIP_STATUS_GLOBAL_NOT_ACCEPTABLE",
            Self::SipStatusGlobalUnwanted => "SIP_STATUS_GLOBAL_UNWANTED",
            Self::SipStatusGlobalRejected => "SIP_STATUS_GLOBAL_REJECTED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SIP_STATUS_UNKNOWN" => Some(Self::SipStatusUnknown),
            "SIP_STATUS_TRYING" => Some(Self::SipStatusTrying),
            "SIP_STATUS_RINGING" => Some(Self::SipStatusRinging),
            "SIP_STATUS_CALL_IS_FORWARDED" => Some(Self::SipStatusCallIsForwarded),
            "SIP_STATUS_QUEUED" => Some(Self::SipStatusQueued),
            "SIP_STATUS_SESSION_PROGRESS" => Some(Self::SipStatusSessionProgress),
            "SIP_STATUS_EARLY_DIALOG_TERMINATED" => Some(Self::SipStatusEarlyDialogTerminated),
            "SIP_STATUS_OK" => Some(Self::SipStatusOk),
            "SIP_STATUS_ACCEPTED" => Some(Self::SipStatusAccepted),
            "SIP_STATUS_NO_NOTIFICATION" => Some(Self::SipStatusNoNotification),
            "SIP_STATUS_MULTIPLE_CHOICES" => Some(Self::SipStatusMultipleChoices),
            "SIP_STATUS_MOVED_PERMANENTLY" => Some(Self::SipStatusMovedPermanently),
            "SIP_STATUS_MOVED_TEMPORARILY" => Some(Self::SipStatusMovedTemporarily),
            "SIP_STATUS_USE_PROXY" => Some(Self::SipStatusUseProxy),
            "SIP_STATUS_ALTERNATIVE_SERVICE" => Some(Self::SipStatusAlternativeService),
            "SIP_STATUS_BAD_REQUEST" => Some(Self::SipStatusBadRequest),
            "SIP_STATUS_UNAUTHORIZED" => Some(Self::SipStatusUnauthorized),
            "SIP_STATUS_PAYMENT_REQUIRED" => Some(Self::SipStatusPaymentRequired),
            "SIP_STATUS_FORBIDDEN" => Some(Self::SipStatusForbidden),
            "SIP_STATUS_NOTFOUND" => Some(Self::SipStatusNotfound),
            "SIP_STATUS_METHOD_NOT_ALLOWED" => Some(Self::SipStatusMethodNotAllowed),
            "SIP_STATUS_NOT_ACCEPTABLE" => Some(Self::SipStatusNotAcceptable),
            "SIP_STATUS_PROXY_AUTH_REQUIRED" => Some(Self::SipStatusProxyAuthRequired),
            "SIP_STATUS_REQUEST_TIMEOUT" => Some(Self::SipStatusRequestTimeout),
            "SIP_STATUS_CONFLICT" => Some(Self::SipStatusConflict),
            "SIP_STATUS_GONE" => Some(Self::SipStatusGone),
            "SIP_STATUS_LENGTH_REQUIRED" => Some(Self::SipStatusLengthRequired),
            "SIP_STATUS_CONDITIONAL_REQUEST_FAILED" => Some(Self::SipStatusConditionalRequestFailed),
            "SIP_STATUS_REQUEST_ENTITY_TOO_LARGE" => Some(Self::SipStatusRequestEntityTooLarge),
            "SIP_STATUS_REQUEST_URI_TOO_LONG" => Some(Self::SipStatusRequestUriTooLong),
            "SIP_STATUS_UNSUPPORTED_MEDIA_TYPE" => Some(Self::SipStatusUnsupportedMediaType),
            "SIP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE" => Some(Self::SipStatusRequestedRangeNotSatisfiable),
            "SIP_STATUS_UNKNOWN_RESOURCE_PRIORITY" => Some(Self::SipStatusUnknownResourcePriority),
            "SIP_STATUS_BAD_EXTENSION" => Some(Self::SipStatusBadExtension),
            "SIP_STATUS_EXTENSION_REQUIRED" => Some(Self::SipStatusExtensionRequired),
            "SIP_STATUS_SESSION_INTERVAL_TOO_SMALL" => Some(Self::SipStatusSessionIntervalTooSmall),
            "SIP_STATUS_INTERVAL_TOO_BRIEF" => Some(Self::SipStatusIntervalTooBrief),
            "SIP_STATUS_BAD_LOCATION_INFORMATION" => Some(Self::SipStatusBadLocationInformation),
            "SIP_STATUS_BAD_ALERT_MESSAGE" => Some(Self::SipStatusBadAlertMessage),
            "SIP_STATUS_USE_IDENTITY_HEADER" => Some(Self::SipStatusUseIdentityHeader),
            "SIP_STATUS_PROVIDE_REFERRER_IDENTITY" => Some(Self::SipStatusProvideReferrerIdentity),
            "SIP_STATUS_FLOW_FAILED" => Some(Self::SipStatusFlowFailed),
            "SIP_STATUS_ANONYMITY_DISALLOWED" => Some(Self::SipStatusAnonymityDisallowed),
            "SIP_STATUS_BAD_IDENTITY_INFO" => Some(Self::SipStatusBadIdentityInfo),
            "SIP_STATUS_UNSUPPORTED_CERTIFICATE" => Some(Self::SipStatusUnsupportedCertificate),
            "SIP_STATUS_INVALID_IDENTITY_HEADER" => Some(Self::SipStatusInvalidIdentityHeader),
            "SIP_STATUS_FIRST_HOP_LACKS_OUTBOUND_SUPPORT" => Some(Self::SipStatusFirstHopLacksOutboundSupport),
            "SIP_STATUS_MAX_BREADTH_EXCEEDED" => Some(Self::SipStatusMaxBreadthExceeded),
            "SIP_STATUS_BAD_INFO_PACKAGE" => Some(Self::SipStatusBadInfoPackage),
            "SIP_STATUS_CONSENT_NEEDED" => Some(Self::SipStatusConsentNeeded),
            "SIP_STATUS_TEMPORARILY_UNAVAILABLE" => Some(Self::SipStatusTemporarilyUnavailable),
            "SIP_STATUS_CALL_TRANSACTION_DOES_NOT_EXISTS" => Some(Self::SipStatusCallTransactionDoesNotExists),
            "SIP_STATUS_LOOP_DETECTED" => Some(Self::SipStatusLoopDetected),
            "SIP_STATUS_TOO_MANY_HOPS" => Some(Self::SipStatusTooManyHops),
            "SIP_STATUS_ADDRESS_INCOMPLETE" => Some(Self::SipStatusAddressIncomplete),
            "SIP_STATUS_AMBIGUOUS" => Some(Self::SipStatusAmbiguous),
            "SIP_STATUS_BUSY_HERE" => Some(Self::SipStatusBusyHere),
            "SIP_STATUS_REQUEST_TERMINATED" => Some(Self::SipStatusRequestTerminated),
            "SIP_STATUS_NOT_ACCEPTABLE_HERE" => Some(Self::SipStatusNotAcceptableHere),
            "SIP_STATUS_BAD_EVENT" => Some(Self::SipStatusBadEvent),
            "SIP_STATUS_REQUEST_PENDING" => Some(Self::SipStatusRequestPending),
            "SIP_STATUS_UNDECIPHERABLE" => Some(Self::SipStatusUndecipherable),
            "SIP_STATUS_SECURITY_AGREEMENT_REQUIRED" => Some(Self::SipStatusSecurityAgreementRequired),
            "SIP_STATUS_INTERNAL_SERVER_ERROR" => Some(Self::SipStatusInternalServerError),
            "SIP_STATUS_NOT_IMPLEMENTED" => Some(Self::SipStatusNotImplemented),
            "SIP_STATUS_BAD_GATEWAY" => Some(Self::SipStatusBadGateway),
            "SIP_STATUS_SERVICE_UNAVAILABLE" => Some(Self::SipStatusServiceUnavailable),
            "SIP_STATUS_GATEWAY_TIMEOUT" => Some(Self::SipStatusGatewayTimeout),
            "SIP_STATUS_VERSION_NOT_SUPPORTED" => Some(Self::SipStatusVersionNotSupported),
            "SIP_STATUS_MESSAGE_TOO_LARGE" => Some(Self::SipStatusMessageTooLarge),
            "SIP_STATUS_GLOBAL_BUSY_EVERYWHERE" => Some(Self::SipStatusGlobalBusyEverywhere),
            "SIP_STATUS_GLOBAL_DECLINE" => Some(Self::SipStatusGlobalDecline),
            "SIP_STATUS_GLOBAL_DOES_NOT_EXIST_ANYWHERE" => Some(Self::SipStatusGlobalDoesNotExistAnywhere),
            "SIP_STATUS_GLOBAL_NOT_ACCEPTABLE" => Some(Self::SipStatusGlobalNotAcceptable),
            "SIP_STATUS_GLOBAL_UNWANTED" => Some(Self::SipStatusGlobalUnwanted),
            "SIP_STATUS_GLOBAL_REJECTED" => Some(Self::SipStatusGlobalRejected),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SipTransport {
    Auto = 0,
    Udp = 1,
    Tcp = 2,
    Tls = 3,
}
impl SipTransport {
    /// 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 {
            Self::Auto => "SIP_TRANSPORT_AUTO",
            Self::Udp => "SIP_TRANSPORT_UDP",
            Self::Tcp => "SIP_TRANSPORT_TCP",
            Self::Tls => "SIP_TRANSPORT_TLS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SIP_TRANSPORT_AUTO" => Some(Self::Auto),
            "SIP_TRANSPORT_UDP" => Some(Self::Udp),
            "SIP_TRANSPORT_TCP" => Some(Self::Tcp),
            "SIP_TRANSPORT_TLS" => Some(Self::Tls),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SipHeaderOptions {
    /// do not map any headers, except ones mapped explicitly
    SipNoHeaders = 0,
    /// map all X-* headers to sip.h.x-* attributes
    SipXHeaders = 1,
    /// map all headers to sip.h.* attributes
    SipAllHeaders = 2,
}
impl SipHeaderOptions {
    /// 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 {
            Self::SipNoHeaders => "SIP_NO_HEADERS",
            Self::SipXHeaders => "SIP_X_HEADERS",
            Self::SipAllHeaders => "SIP_ALL_HEADERS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SIP_NO_HEADERS" => Some(Self::SipNoHeaders),
            "SIP_X_HEADERS" => Some(Self::SipXHeaders),
            "SIP_ALL_HEADERS" => Some(Self::SipAllHeaders),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SipMediaEncryption {
    /// do not enable encryption
    SipMediaEncryptDisable = 0,
    /// use encryption if available
    SipMediaEncryptAllow = 1,
    /// require encryption
    SipMediaEncryptRequire = 2,
}
impl SipMediaEncryption {
    /// 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 {
            Self::SipMediaEncryptDisable => "SIP_MEDIA_ENCRYPT_DISABLE",
            Self::SipMediaEncryptAllow => "SIP_MEDIA_ENCRYPT_ALLOW",
            Self::SipMediaEncryptRequire => "SIP_MEDIA_ENCRYPT_REQUIRE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SIP_MEDIA_ENCRYPT_DISABLE" => Some(Self::SipMediaEncryptDisable),
            "SIP_MEDIA_ENCRYPT_ALLOW" => Some(Self::SipMediaEncryptAllow),
            "SIP_MEDIA_ENCRYPT_REQUIRE" => Some(Self::SipMediaEncryptRequire),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ProviderType {
    Unknown = 0,
    /// Internally implemented
    Internal = 1,
    /// Vendor provided
    External = 2,
}
impl ProviderType {
    /// 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 {
            Self::Unknown => "PROVIDER_TYPE_UNKNOWN",
            Self::Internal => "PROVIDER_TYPE_INTERNAL",
            Self::External => "PROVIDER_TYPE_EXTERNAL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PROVIDER_TYPE_UNKNOWN" => Some(Self::Unknown),
            "PROVIDER_TYPE_INTERNAL" => Some(Self::Internal),
            "PROVIDER_TYPE_EXTERNAL" => Some(Self::External),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SipCallStatus {
    /// Incoming call is being handled by the SIP service. The SIP participant hasn't joined a LiveKit room yet
    ScsCallIncoming = 0,
    /// SIP participant for outgoing call has been created. The SIP outgoing call is being established
    ScsParticipantJoined = 1,
    /// Call is ongoing. SIP participant is active in the LiveKit room
    ScsActive = 2,
    /// Call has ended
    ScsDisconnected = 3,
    /// Call has ended or never succeeded because of an error
    ScsError = 4,
}
impl SipCallStatus {
    /// 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 {
            Self::ScsCallIncoming => "SCS_CALL_INCOMING",
            Self::ScsParticipantJoined => "SCS_PARTICIPANT_JOINED",
            Self::ScsActive => "SCS_ACTIVE",
            Self::ScsDisconnected => "SCS_DISCONNECTED",
            Self::ScsError => "SCS_ERROR",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SCS_CALL_INCOMING" => Some(Self::ScsCallIncoming),
            "SCS_PARTICIPANT_JOINED" => Some(Self::ScsParticipantJoined),
            "SCS_ACTIVE" => Some(Self::ScsActive),
            "SCS_DISCONNECTED" => Some(Self::ScsDisconnected),
            "SCS_ERROR" => Some(Self::ScsError),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SipTransferStatus {
    StsTransferOngoing = 0,
    StsTransferFailed = 1,
    StsTransferSuccessful = 2,
}
impl SipTransferStatus {
    /// 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 {
            Self::StsTransferOngoing => "STS_TRANSFER_ONGOING",
            Self::StsTransferFailed => "STS_TRANSFER_FAILED",
            Self::StsTransferSuccessful => "STS_TRANSFER_SUCCESSFUL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "STS_TRANSFER_ONGOING" => Some(Self::StsTransferOngoing),
            "STS_TRANSFER_FAILED" => Some(Self::StsTransferFailed),
            "STS_TRANSFER_SUCCESSFUL" => Some(Self::StsTransferSuccessful),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SipFeature {
    None = 0,
    KrispEnabled = 1,
}
impl SipFeature {
    /// 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 {
            Self::None => "NONE",
            Self::KrispEnabled => "KRISP_ENABLED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NONE" => Some(Self::None),
            "KRISP_ENABLED" => Some(Self::KrispEnabled),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SipCallDirection {
    ScdUnknown = 0,
    ScdInbound = 1,
    ScdOutbound = 2,
}
impl SipCallDirection {
    /// 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 {
            Self::ScdUnknown => "SCD_UNKNOWN",
            Self::ScdInbound => "SCD_INBOUND",
            Self::ScdOutbound => "SCD_OUTBOUND",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SCD_UNKNOWN" => Some(Self::ScdUnknown),
            "SCD_INBOUND" => Some(Self::ScdInbound),
            "SCD_OUTBOUND" => Some(Self::ScdOutbound),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DialWhatsAppCallRequest {
    /// 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
    #[prost(string, tag = "2")]
    pub whatsapp_to_phone_number: ::prost::alloc::string::String,
    /// Required - The API key of the business that is initiating the call
    #[prost(string, tag = "3")]
    pub whatsapp_api_key: ::prost::alloc::string::String,
    /// Required - WhatsApp Cloud API version, eg: 23.0, 24.0, etc.
    #[prost(string, tag = "12")]
    pub whatsapp_cloud_api_version: ::prost::alloc::string::String,
    /// Optional - An arbitrary string you can pass in that is useful for tracking and logging purposes.
    #[prost(string, tag = "4")]
    pub whatsapp_biz_opaque_callback_data: ::prost::alloc::string::String,
    /// Optional - What LiveKit room should this participant be connected too
    #[prost(string, tag = "5")]
    pub room_name: ::prost::alloc::string::String,
    /// Optional - Agents to dispatch the call to
    #[prost(message, repeated, tag = "6")]
    pub agents: ::prost::alloc::vec::Vec<RoomAgentDispatch>,
    /// 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
    #[prost(string, tag = "8")]
    pub participant_name: ::prost::alloc::string::String,
    /// Optional - User-defined metadata. Will be attached to a created Participant in the room.
    #[prost(string, tag = "9")]
    pub participant_metadata: ::prost::alloc::string::String,
    /// Optional - User-defined attributes. Will be attached to a created Participant in the room.
    #[prost(map = "string, string", tag = "10")]
    pub participant_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Optional - Country where the call terminates as ISO 3166-1 alpha-2 (<https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2>). This will be used by the livekit infrastructure to route calls.
    #[prost(string, tag = "11")]
    pub destination_country: ::prost::alloc::string::String,
    /// Max time for the callee to answer the call.
    #[prost(message, optional, tag = "13")]
    pub ringing_timeout: ::core::option::Option<::pbjson_types::Duration>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DialWhatsAppCallResponse {
    /// Call ID sent by Meta
    #[prost(string, tag = "1")]
    pub whatsapp_call_id: ::prost::alloc::string::String,
    /// The name of the LiveKit room that the call is connected to
    #[prost(string, tag = "2")]
    pub room_name: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DisconnectWhatsAppCallRequest {
    /// Required - Call ID sent by Meta
    #[prost(string, tag = "1")]
    pub whatsapp_call_id: ::prost::alloc::string::String,
    /// 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
        /// <https://developers.facebook.com/documentation/business-messaging/whatsapp/calling/user-initiated-calls#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 {
                Self::BusinessInitiated => "BUSINESS_INITIATED",
                Self::UserInitiated => "USER_INITIATED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "BUSINESS_INITIATED" => Some(Self::BusinessInitiated),
                "USER_INITIATED" => Some(Self::UserInitiated),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DisconnectWhatsAppCallResponse {
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectWhatsAppCallRequest {
    /// Required - Call ID sent by Meta
    #[prost(string, tag = "1")]
    pub whatsapp_call_id: ::prost::alloc::string::String,
    /// Required - The call connect webhook comes with SDP from Meta
    /// It is the answer SDP for a business initiated call
    #[prost(message, optional, tag = "2")]
    pub sdp: ::core::option::Option<SessionDescription>,
    /// Wait for the answer for the call before returning.
    #[prost(bool, tag = "3")]
    pub wait_until_answered: bool,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ConnectWhatsAppCallResponse {
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AcceptWhatsAppCallRequest {
    /// 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
    #[prost(string, tag = "2")]
    pub whatsapp_api_key: ::prost::alloc::string::String,
    /// Required - WhatsApp Cloud API version, eg: 23.0, 24.0, etc.
    #[prost(string, tag = "13")]
    pub whatsapp_cloud_api_version: ::prost::alloc::string::String,
    /// Required - Call ID sent by Meta
    #[prost(string, tag = "3")]
    pub whatsapp_call_id: ::prost::alloc::string::String,
    /// Optional - An arbitrary string you can pass in that is useful for tracking and logging purposes.
    #[prost(string, tag = "4")]
    pub whatsapp_biz_opaque_callback_data: ::prost::alloc::string::String,
    /// Required - The call accept webhook comes with SDP from Meta
    /// It is the for a user initiated call
    #[prost(message, optional, tag = "5")]
    pub sdp: ::core::option::Option<SessionDescription>,
    /// Optional - What LiveKit room should this participant be connected too
    #[prost(string, tag = "6")]
    pub room_name: ::prost::alloc::string::String,
    /// Optional - Agents to dispatch the call to
    #[prost(message, repeated, tag = "7")]
    pub agents: ::prost::alloc::vec::Vec<RoomAgentDispatch>,
    /// 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
    #[prost(string, tag = "9")]
    pub participant_name: ::prost::alloc::string::String,
    /// Optional - User-defined metadata. Will be attached to a created Participant in the room.
    #[prost(string, tag = "10")]
    pub participant_metadata: ::prost::alloc::string::String,
    /// Optional - User-defined attributes. Will be attached to a created Participant in the room.
    #[prost(map = "string, string", tag = "11")]
    pub participant_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Optional - Country where the call terminates as ISO 3166-1 alpha-2 (<https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2>). This will be used by the livekit infrastructure to route calls.
    #[prost(string, tag = "12")]
    pub destination_country: ::prost::alloc::string::String,
    /// Max time for the callee to answer the call.
    #[prost(message, optional, tag = "14")]
    pub ringing_timeout: ::core::option::Option<::pbjson_types::Duration>,
    /// Wait for the answer for the call before returning.
    #[prost(bool, tag = "15")]
    pub wait_until_answered: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AcceptWhatsAppCallResponse {
    /// The name of the LiveKit room that the call is connected to
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WhatsAppCall {
    /// list of call ids that are currently active
    #[prost(string, tag = "1")]
    pub whatsapp_call_id: ::prost::alloc::string::String,
    /// Direction of the call
    #[prost(enumeration = "WhatsAppCallDirection", tag = "2")]
    pub direction: i32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum WhatsAppCallDirection {
    WhatsappCallDirectionInbound = 0,
    WhatsappCallDirectionOutbound = 2,
}
impl WhatsAppCallDirection {
    /// 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 {
            Self::WhatsappCallDirectionInbound => "WHATSAPP_CALL_DIRECTION_INBOUND",
            Self::WhatsappCallDirectionOutbound => "WHATSAPP_CALL_DIRECTION_OUTBOUND",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "WHATSAPP_CALL_DIRECTION_INBOUND" => Some(Self::WhatsappCallDirectionInbound),
            "WHATSAPP_CALL_DIRECTION_OUTBOUND" => Some(Self::WhatsappCallDirectionOutbound),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectTwilioCallRequest {
    /// The Direction of the call
    #[prost(enumeration = "connect_twilio_call_request::TwilioCallDirection", tag = "1")]
    pub twilio_call_direction: i32,
    /// What LiveKit room should this call be connected to
    #[prost(string, tag = "2")]
    pub room_name: ::prost::alloc::string::String,
    /// Optional agents to dispatch the call to
    #[prost(message, repeated, tag = "3")]
    pub agents: ::prost::alloc::vec::Vec<RoomAgentDispatch>,
    /// 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
    #[prost(string, tag = "5")]
    pub participant_name: ::prost::alloc::string::String,
    /// Optional user-defined metadata. Will be attached to a created Participant in the room.
    #[prost(string, tag = "6")]
    pub participant_metadata: ::prost::alloc::string::String,
    /// Optional user-defined attributes. Will be attached to a created Participant in the room.
    #[prost(map = "string, string", tag = "7")]
    pub participant_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Country where the call terminates as ISO 3166-1 alpha-2 (<https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2>). This will be used by the livekit infrastructure to route calls.
    #[prost(string, tag = "8")]
    pub destination_country: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ConnectTwilioCallRequest`.
pub mod connect_twilio_call_request {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum TwilioCallDirection {
        /// Call is inbound to LiveKit from Twilio
        Inbound = 0,
        /// Call is outbound from LiveKit to Twilio
        Outbound = 1,
    }
    impl TwilioCallDirection {
        /// 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 {
                Self::Inbound => "TWILIO_CALL_DIRECTION_INBOUND",
                Self::Outbound => "TWILIO_CALL_DIRECTION_OUTBOUND",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TWILIO_CALL_DIRECTION_INBOUND" => Some(Self::Inbound),
                "TWILIO_CALL_DIRECTION_OUTBOUND" => Some(Self::Outbound),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ConnectTwilioCallResponse {
    /// The websocket URL which twilio media stream will connect to
    #[prost(string, tag = "1")]
    pub connect_url: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ConnectorType {
    Unspecified = 0,
    WhatsApp = 1,
    Twilio = 2,
}
impl ConnectorType {
    /// 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 {
            Self::Unspecified => "Unspecified",
            Self::WhatsApp => "WhatsApp",
            Self::Twilio => "Twilio",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "Unspecified" => Some(Self::Unspecified),
            "WhatsApp" => Some(Self::WhatsApp),
            "Twilio" => Some(Self::Twilio),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AnalyticsVideoLayer {
    #[prost(int32, tag = "1")]
    pub layer: i32,
    #[prost(uint32, tag = "2")]
    pub packets: u32,
    #[prost(uint64, tag = "3")]
    pub bytes: u64,
    #[prost(uint32, tag = "4")]
    pub frames: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnalyticsStream {
    #[prost(uint32, tag = "1")]
    pub ssrc: u32,
    #[prost(uint32, tag = "2")]
    pub primary_packets: u32,
    #[prost(uint64, tag = "3")]
    pub primary_bytes: u64,
    #[prost(uint32, tag = "4")]
    pub retransmit_packets: u32,
    #[prost(uint64, tag = "5")]
    pub retransmit_bytes: u64,
    #[prost(uint32, tag = "6")]
    pub padding_packets: u32,
    #[prost(uint64, tag = "7")]
    pub padding_bytes: u64,
    #[prost(uint32, tag = "8")]
    pub packets_lost: u32,
    #[prost(uint32, tag = "9")]
    pub frames: u32,
    #[prost(uint32, tag = "10")]
    pub rtt: u32,
    #[prost(uint32, tag = "11")]
    pub jitter: u32,
    #[prost(uint32, tag = "12")]
    pub nacks: u32,
    #[prost(uint32, tag = "13")]
    pub plis: u32,
    #[prost(uint32, tag = "14")]
    pub firs: u32,
    #[prost(message, repeated, tag = "15")]
    pub video_layers: ::prost::alloc::vec::Vec<AnalyticsVideoLayer>,
    #[prost(message, optional, tag = "17")]
    pub start_time: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "18")]
    pub end_time: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(uint32, tag = "19")]
    pub packets_out_of_order: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnalyticsStat {
    /// unique id for this stat
    #[prost(string, tag = "14")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "1")]
    pub analytics_key: ::prost::alloc::string::String,
    #[prost(enumeration = "StreamType", tag = "2")]
    pub kind: i32,
    #[prost(message, optional, tag = "3")]
    pub time_stamp: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(string, tag = "4")]
    pub node: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub room_id: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub participant_id: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub track_id: ::prost::alloc::string::String,
    /// average score
    #[prost(float, tag = "9")]
    pub score: f32,
    #[prost(message, repeated, tag = "10")]
    pub streams: ::prost::alloc::vec::Vec<AnalyticsStream>,
    #[prost(string, tag = "11")]
    pub mime: ::prost::alloc::string::String,
    #[prost(float, tag = "12")]
    pub min_score: f32,
    #[prost(float, tag = "13")]
    pub median_score: f32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnalyticsStats {
    #[prost(message, repeated, tag = "1")]
    pub stats: ::prost::alloc::vec::Vec<AnalyticsStat>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AnalyticsClientMeta {
    #[prost(string, tag = "1")]
    pub region: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub node: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub client_addr: ::prost::alloc::string::String,
    #[prost(uint32, tag = "4")]
    pub client_connect_time: u32,
    /// udp, tcp, turn
    #[prost(string, tag = "5")]
    pub connection_type: ::prost::alloc::string::String,
    #[prost(enumeration = "ReconnectReason", tag = "6")]
    pub reconnect_reason: i32,
    #[prost(string, optional, tag = "7")]
    pub geo_hash: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "8")]
    pub country: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(uint32, optional, tag = "9")]
    pub isp_asn: ::core::option::Option<u32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnalyticsEvent {
    /// unique id for this event
    #[prost(string, tag = "25")]
    pub id: ::prost::alloc::string::String,
    #[prost(enumeration = "AnalyticsEventType", tag = "1")]
    pub r#type: i32,
    #[prost(message, optional, tag = "2")]
    pub timestamp: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(string, tag = "3")]
    pub room_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub room: ::core::option::Option<Room>,
    #[prost(string, tag = "5")]
    pub participant_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "6")]
    pub participant: ::core::option::Option<ParticipantInfo>,
    #[prost(string, tag = "7")]
    pub track_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "8")]
    pub track: ::core::option::Option<TrackInfo>,
    #[prost(string, tag = "10")]
    pub analytics_key: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "11")]
    pub client_info: ::core::option::Option<ClientInfo>,
    #[prost(message, optional, tag = "12")]
    pub client_meta: ::core::option::Option<AnalyticsClientMeta>,
    #[prost(string, tag = "13")]
    pub egress_id: ::prost::alloc::string::String,
    #[prost(string, tag = "19")]
    pub ingress_id: ::prost::alloc::string::String,
    #[prost(enumeration = "VideoQuality", tag = "14")]
    pub max_subscribed_video_quality: i32,
    #[prost(message, optional, tag = "15")]
    pub publisher: ::core::option::Option<ParticipantInfo>,
    #[prost(string, tag = "16")]
    pub mime: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "17")]
    pub egress: ::core::option::Option<EgressInfo>,
    #[prost(message, optional, tag = "18")]
    pub ingress: ::core::option::Option<IngressInfo>,
    #[prost(string, tag = "20")]
    pub error: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "21")]
    pub rtp_stats: ::core::option::Option<RtpStats>,
    #[prost(int32, tag = "22")]
    pub video_layer: i32,
    #[prost(string, tag = "24")]
    pub node_id: ::prost::alloc::string::String,
    #[prost(string, tag = "26")]
    pub sip_call_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "27")]
    pub sip_call: ::core::option::Option<SipCallInfo>,
    #[prost(string, tag = "28")]
    pub sip_trunk_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "29")]
    pub sip_inbound_trunk: ::core::option::Option<SipInboundTrunkInfo>,
    #[prost(message, optional, tag = "30")]
    pub sip_outbound_trunk: ::core::option::Option<SipOutboundTrunkInfo>,
    #[prost(string, tag = "31")]
    pub sip_dispatch_rule_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "32")]
    pub sip_dispatch_rule: ::core::option::Option<SipDispatchRuleInfo>,
    #[prost(message, optional, tag = "36")]
    pub sip_transfer: ::core::option::Option<SipTransferInfo>,
    #[prost(message, optional, tag = "33")]
    pub report: ::core::option::Option<ReportInfo>,
    #[prost(message, optional, tag = "34")]
    pub api_call: ::core::option::Option<ApiCallInfo>,
    #[prost(message, optional, tag = "35")]
    pub webhook: ::core::option::Option<WebhookInfo>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnalyticsEvents {
    #[prost(message, repeated, tag = "1")]
    pub events: ::prost::alloc::vec::Vec<AnalyticsEvent>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AnalyticsRoomParticipant {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    #[prost(enumeration = "participant_info::State", tag = "4")]
    pub state: i32,
    #[prost(message, optional, tag = "5")]
    pub joined_at: ::core::option::Option<::pbjson_types::Timestamp>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnalyticsRoom {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub project_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, repeated, tag = "4")]
    pub participants: ::prost::alloc::vec::Vec<AnalyticsRoomParticipant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnalyticsNodeRooms {
    #[prost(string, tag = "1")]
    pub node_id: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    pub sequence_number: u64,
    #[prost(message, optional, tag = "3")]
    pub timestamp: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, repeated, tag = "4")]
    pub rooms: ::prost::alloc::vec::Vec<AnalyticsRoom>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReportInfo {
    #[prost(oneof = "report_info::Message", tags = "1")]
    pub message: ::core::option::Option<report_info::Message>,
}
/// Nested message and enum types in `ReportInfo`.
pub mod report_info {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        #[prost(message, tag = "1")]
        FeatureUsage(super::FeatureUsageInfo),
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TimeRange {
    #[prost(message, optional, tag = "1")]
    pub started_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "2")]
    pub ended_at: ::core::option::Option<::pbjson_types::Timestamp>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FeatureUsageInfo {
    #[prost(enumeration = "feature_usage_info::Feature", tag = "1")]
    pub feature: i32,
    #[prost(string, tag = "2")]
    pub project_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub room_id: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub participant_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub participant_id: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub track_id: ::prost::alloc::string::String,
    /// time ranges during which the feature was enabled.
    /// for e. g., noise cancellation may not be applied when a media track is paused/muted,
    /// this allows reporting only periods during which a feature is active.
    #[prost(message, repeated, tag = "8")]
    pub time_ranges: ::prost::alloc::vec::Vec<TimeRange>,
    /// Feature specific metadata included in the report
    #[prost(map = "string, string", tag = "9")]
    pub feature_info: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
/// Nested message and enum types in `FeatureUsageInfo`.
pub mod feature_usage_info {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Feature {
        KrispNoiseCancellation = 0,
        KrispBackgroundVoiceCancellation = 1,
        AicAudioEnhancement = 2,
        KrispViva = 3,
    }
    impl Feature {
        /// 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 {
                Self::KrispNoiseCancellation => "KRISP_NOISE_CANCELLATION",
                Self::KrispBackgroundVoiceCancellation => "KRISP_BACKGROUND_VOICE_CANCELLATION",
                Self::AicAudioEnhancement => "AIC_AUDIO_ENHANCEMENT",
                Self::KrispViva => "KRISP_VIVA",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "KRISP_NOISE_CANCELLATION" => Some(Self::KrispNoiseCancellation),
                "KRISP_BACKGROUND_VOICE_CANCELLATION" => Some(Self::KrispBackgroundVoiceCancellation),
                "AIC_AUDIO_ENHANCEMENT" => Some(Self::AicAudioEnhancement),
                "KRISP_VIVA" => Some(Self::KrispViva),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApiCallRequest {
    #[prost(oneof = "api_call_request::Message", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
    pub message: ::core::option::Option<api_call_request::Message>,
}
/// Nested message and enum types in `APICallRequest`.
pub mod api_call_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        #[prost(message, tag = "1")]
        CreateRoomRequest(super::CreateRoomRequest),
        #[prost(message, tag = "2")]
        ListRoomsRequest(super::ListRoomsRequest),
        #[prost(message, tag = "3")]
        DeleteRoomRequest(super::DeleteRoomRequest),
        #[prost(message, tag = "4")]
        ListParticipantsRequest(super::ListParticipantsRequest),
        #[prost(message, tag = "5")]
        RoomParticipantIdentity(super::RoomParticipantIdentity),
        #[prost(message, tag = "6")]
        MuteRoomTrackRequest(super::MuteRoomTrackRequest),
        #[prost(message, tag = "7")]
        UpdateParticipantRequest(super::UpdateParticipantRequest),
        #[prost(message, tag = "8")]
        UpdateSubscriptionsRequest(super::UpdateSubscriptionsRequest),
        #[prost(message, tag = "9")]
        SendDataRequest(super::SendDataRequest),
        #[prost(message, tag = "10")]
        UpdateRoomMetadataRequest(super::UpdateRoomMetadataRequest),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApiCallInfo {
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub request: ::core::option::Option<ApiCallRequest>,
    #[prost(string, tag = "3")]
    pub service: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub method: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub node_id: ::prost::alloc::string::String,
    #[prost(int32, tag = "6")]
    pub status: i32,
    #[prost(string, tag = "7")]
    pub twirp_error_code: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub twirp_error_message: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "10")]
    pub room_id: ::prost::alloc::string::String,
    #[prost(string, tag = "11")]
    pub participant_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "12")]
    pub participant_id: ::prost::alloc::string::String,
    #[prost(string, tag = "13")]
    pub track_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "14")]
    pub started_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(int64, tag = "15")]
    pub duration_ns: i64,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebhookInfo {
    #[prost(string, tag = "1")]
    pub event_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub event: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub project_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub room_id: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub participant_identity: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub participant_id: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub track_id: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub egress_id: ::prost::alloc::string::String,
    #[prost(string, tag = "10")]
    pub ingress_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "11")]
    pub created_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "12")]
    pub queued_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(int64, tag = "13")]
    pub queue_duration_ns: i64,
    #[prost(message, optional, tag = "14")]
    pub sent_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(int64, tag = "15")]
    pub send_duration_ns: i64,
    #[prost(string, tag = "16")]
    pub url: ::prost::alloc::string::String,
    #[prost(int32, tag = "17")]
    pub num_dropped: i32,
    #[prost(bool, tag = "18")]
    pub is_dropped: bool,
    #[prost(string, tag = "19")]
    pub service_status: ::prost::alloc::string::String,
    #[prost(int32, tag = "20")]
    pub service_error_code: i32,
    #[prost(string, tag = "21")]
    pub service_error: ::prost::alloc::string::String,
    #[prost(string, tag = "22")]
    pub send_error: ::prost::alloc::string::String,
    /// HTTP response status code for the delivery attempt (0 if no response).
    #[prost(int32, tag = "23")]
    pub http_status_code: i32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum StreamType {
    Upstream = 0,
    Downstream = 1,
}
impl StreamType {
    /// 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 {
            Self::Upstream => "UPSTREAM",
            Self::Downstream => "DOWNSTREAM",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UPSTREAM" => Some(Self::Upstream),
            "DOWNSTREAM" => Some(Self::Downstream),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AnalyticsEventType {
    RoomCreated = 0,
    RoomEnded = 1,
    ParticipantJoined = 2,
    ParticipantLeft = 3,
    ParticipantConnectionAborted = 45,
    TrackPublished = 4,
    TrackPublishRequested = 20,
    TrackUnpublished = 5,
    TrackSubscribed = 6,
    TrackSubscribeRequested = 21,
    TrackSubscribeFailed = 25,
    TrackUnsubscribed = 7,
    TrackPublishedUpdate = 10,
    TrackMuted = 23,
    TrackUnmuted = 24,
    TrackPublishStats = 26,
    TrackSubscribeStats = 27,
    ParticipantActive = 11,
    ParticipantResumed = 22,
    EgressStarted = 12,
    EgressEnded = 13,
    EgressUpdated = 28,
    TrackMaxSubscribedVideoQuality = 14,
    Reconnected = 15,
    IngressCreated = 18,
    IngressDeleted = 19,
    IngressStarted = 16,
    IngressEnded = 17,
    IngressUpdated = 29,
    SipInboundTrunkCreated = 30,
    SipInboundTrunkDeleted = 31,
    SipOutboundTrunkCreated = 32,
    SipOutboundTrunkDeleted = 33,
    SipDispatchRuleCreated = 34,
    SipDispatchRuleDeleted = 35,
    SipParticipantCreated = 36,
    SipCallIncoming = 37,
    SipCallStarted = 38,
    SipCallEnded = 39,
    SipTransferRequested = 43,
    SipTransferComplete = 44,
    SipCallUpdate = 46,
    Report = 40,
    ApiCall = 41,
    Webhook = 42,
}
impl AnalyticsEventType {
    /// 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 {
            Self::RoomCreated => "ROOM_CREATED",
            Self::RoomEnded => "ROOM_ENDED",
            Self::ParticipantJoined => "PARTICIPANT_JOINED",
            Self::ParticipantLeft => "PARTICIPANT_LEFT",
            Self::ParticipantConnectionAborted => "PARTICIPANT_CONNECTION_ABORTED",
            Self::TrackPublished => "TRACK_PUBLISHED",
            Self::TrackPublishRequested => "TRACK_PUBLISH_REQUESTED",
            Self::TrackUnpublished => "TRACK_UNPUBLISHED",
            Self::TrackSubscribed => "TRACK_SUBSCRIBED",
            Self::TrackSubscribeRequested => "TRACK_SUBSCRIBE_REQUESTED",
            Self::TrackSubscribeFailed => "TRACK_SUBSCRIBE_FAILED",
            Self::TrackUnsubscribed => "TRACK_UNSUBSCRIBED",
            Self::TrackPublishedUpdate => "TRACK_PUBLISHED_UPDATE",
            Self::TrackMuted => "TRACK_MUTED",
            Self::TrackUnmuted => "TRACK_UNMUTED",
            Self::TrackPublishStats => "TRACK_PUBLISH_STATS",
            Self::TrackSubscribeStats => "TRACK_SUBSCRIBE_STATS",
            Self::ParticipantActive => "PARTICIPANT_ACTIVE",
            Self::ParticipantResumed => "PARTICIPANT_RESUMED",
            Self::EgressStarted => "EGRESS_STARTED",
            Self::EgressEnded => "EGRESS_ENDED",
            Self::EgressUpdated => "EGRESS_UPDATED",
            Self::TrackMaxSubscribedVideoQuality => "TRACK_MAX_SUBSCRIBED_VIDEO_QUALITY",
            Self::Reconnected => "RECONNECTED",
            Self::IngressCreated => "INGRESS_CREATED",
            Self::IngressDeleted => "INGRESS_DELETED",
            Self::IngressStarted => "INGRESS_STARTED",
            Self::IngressEnded => "INGRESS_ENDED",
            Self::IngressUpdated => "INGRESS_UPDATED",
            Self::SipInboundTrunkCreated => "SIP_INBOUND_TRUNK_CREATED",
            Self::SipInboundTrunkDeleted => "SIP_INBOUND_TRUNK_DELETED",
            Self::SipOutboundTrunkCreated => "SIP_OUTBOUND_TRUNK_CREATED",
            Self::SipOutboundTrunkDeleted => "SIP_OUTBOUND_TRUNK_DELETED",
            Self::SipDispatchRuleCreated => "SIP_DISPATCH_RULE_CREATED",
            Self::SipDispatchRuleDeleted => "SIP_DISPATCH_RULE_DELETED",
            Self::SipParticipantCreated => "SIP_PARTICIPANT_CREATED",
            Self::SipCallIncoming => "SIP_CALL_INCOMING",
            Self::SipCallStarted => "SIP_CALL_STARTED",
            Self::SipCallEnded => "SIP_CALL_ENDED",
            Self::SipTransferRequested => "SIP_TRANSFER_REQUESTED",
            Self::SipTransferComplete => "SIP_TRANSFER_COMPLETE",
            Self::SipCallUpdate => "SIP_CALL_UPDATE",
            Self::Report => "REPORT",
            Self::ApiCall => "API_CALL",
            Self::Webhook => "WEBHOOK",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ROOM_CREATED" => Some(Self::RoomCreated),
            "ROOM_ENDED" => Some(Self::RoomEnded),
            "PARTICIPANT_JOINED" => Some(Self::ParticipantJoined),
            "PARTICIPANT_LEFT" => Some(Self::ParticipantLeft),
            "PARTICIPANT_CONNECTION_ABORTED" => Some(Self::ParticipantConnectionAborted),
            "TRACK_PUBLISHED" => Some(Self::TrackPublished),
            "TRACK_PUBLISH_REQUESTED" => Some(Self::TrackPublishRequested),
            "TRACK_UNPUBLISHED" => Some(Self::TrackUnpublished),
            "TRACK_SUBSCRIBED" => Some(Self::TrackSubscribed),
            "TRACK_SUBSCRIBE_REQUESTED" => Some(Self::TrackSubscribeRequested),
            "TRACK_SUBSCRIBE_FAILED" => Some(Self::TrackSubscribeFailed),
            "TRACK_UNSUBSCRIBED" => Some(Self::TrackUnsubscribed),
            "TRACK_PUBLISHED_UPDATE" => Some(Self::TrackPublishedUpdate),
            "TRACK_MUTED" => Some(Self::TrackMuted),
            "TRACK_UNMUTED" => Some(Self::TrackUnmuted),
            "TRACK_PUBLISH_STATS" => Some(Self::TrackPublishStats),
            "TRACK_SUBSCRIBE_STATS" => Some(Self::TrackSubscribeStats),
            "PARTICIPANT_ACTIVE" => Some(Self::ParticipantActive),
            "PARTICIPANT_RESUMED" => Some(Self::ParticipantResumed),
            "EGRESS_STARTED" => Some(Self::EgressStarted),
            "EGRESS_ENDED" => Some(Self::EgressEnded),
            "EGRESS_UPDATED" => Some(Self::EgressUpdated),
            "TRACK_MAX_SUBSCRIBED_VIDEO_QUALITY" => Some(Self::TrackMaxSubscribedVideoQuality),
            "RECONNECTED" => Some(Self::Reconnected),
            "INGRESS_CREATED" => Some(Self::IngressCreated),
            "INGRESS_DELETED" => Some(Self::IngressDeleted),
            "INGRESS_STARTED" => Some(Self::IngressStarted),
            "INGRESS_ENDED" => Some(Self::IngressEnded),
            "INGRESS_UPDATED" => Some(Self::IngressUpdated),
            "SIP_INBOUND_TRUNK_CREATED" => Some(Self::SipInboundTrunkCreated),
            "SIP_INBOUND_TRUNK_DELETED" => Some(Self::SipInboundTrunkDeleted),
            "SIP_OUTBOUND_TRUNK_CREATED" => Some(Self::SipOutboundTrunkCreated),
            "SIP_OUTBOUND_TRUNK_DELETED" => Some(Self::SipOutboundTrunkDeleted),
            "SIP_DISPATCH_RULE_CREATED" => Some(Self::SipDispatchRuleCreated),
            "SIP_DISPATCH_RULE_DELETED" => Some(Self::SipDispatchRuleDeleted),
            "SIP_PARTICIPANT_CREATED" => Some(Self::SipParticipantCreated),
            "SIP_CALL_INCOMING" => Some(Self::SipCallIncoming),
            "SIP_CALL_STARTED" => Some(Self::SipCallStarted),
            "SIP_CALL_ENDED" => Some(Self::SipCallEnded),
            "SIP_TRANSFER_REQUESTED" => Some(Self::SipTransferRequested),
            "SIP_TRANSFER_COMPLETE" => Some(Self::SipTransferComplete),
            "SIP_CALL_UPDATE" => Some(Self::SipCallUpdate),
            "REPORT" => Some(Self::Report),
            "API_CALL" => Some(Self::ApiCall),
            "WEBHOOK" => Some(Self::Webhook),
            _ => None,
        }
    }
}
include!("livekit.serde.rs");
// @@protoc_insertion_point(module)