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,
    /// JSON object of session facts for agent evals, at most 16 KiB. Its schema is
    /// evalschema/session-summary.schema.json in livekit/cloud-protocol. The collector
    /// stores it without reading individual keys.
    #[prost(string, tag = "11")]
    pub session_summary: ::prost::alloc::string::String,
}
//
// 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,
        Dotnet = 15,
    }
    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",
                Self::Dotnet => "DOTNET",
            }
        }
        /// 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),
                "DOTNET" => Some(Self::Dotnet),
                _ => 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>,
    #[prost(message, optional, tag = "47")]
    pub received_report_drift: ::core::option::Option<RtpDrift>,
    #[prost(uint32, tag = "48")]
    pub fec_packets: u32,
    #[prost(uint64, tag = "49")]
    pub fec_bytes: u64,
    #[prost(uint32, tag = "50")]
    pub fec_packets_discarded: u32,
    /// NEXT_ID: 52
    #[prost(uint32, tag = "51")]
    pub fec_packets_recovered: u32,
}
#[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(message, optional, tag = "9")]
    pub dependency_descriptor_forwarder: ::core::option::Option<DependencyDescriptorForwarderState>,
    #[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),
    }
}
/// State of a forwarder that writes the dependency descriptor for the subscriber, so
/// its frame numbers continue on a migrated subscriber.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DependencyDescriptorForwarderState {
    /// highest extended frame number sent to the subscriber
    #[prost(uint64, tag = "1")]
    pub ext_last_frame_number: u64,
}
#[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,
    DteiE2ee = 1,
    DteiUserTimestamp = 2,
    DteiParticipantSid = 255,
}
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::DteiE2ee => "DTEI_E2EE",
            Self::DteiUserTimestamp => "DTEI_USER_TIMESTAMP",
            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_E2EE" => Some(Self::DteiE2ee),
            "DTEI_USER_TIMESTAMP" => Some(Self::DteiUserTimestamp),
            "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,
        }
    }
}
/// why a room ended, reported on room-ended telemetry
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RoomEndReason {
    RoomEndUnknown = 0,
    /// RoomService.DeleteRoom was called
    RoomEndApiDelete = 1,
    /// the room sat empty past its empty or departure timeout
    RoomEndIdleTimeout = 2,
    /// the server instance is shutting down
    RoomEndServerShutdown = 3,
    /// the room was restarted or replaced elsewhere
    RoomEndSuperseded = 4,
    /// the room failed to finish opening
    RoomEndOpenFailed = 5,
}
impl RoomEndReason {
    /// 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::RoomEndUnknown => "ROOM_END_UNKNOWN",
            Self::RoomEndApiDelete => "ROOM_END_API_DELETE",
            Self::RoomEndIdleTimeout => "ROOM_END_IDLE_TIMEOUT",
            Self::RoomEndServerShutdown => "ROOM_END_SERVER_SHUTDOWN",
            Self::RoomEndSuperseded => "ROOM_END_SUPERSEDED",
            Self::RoomEndOpenFailed => "ROOM_END_OPEN_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 {
            "ROOM_END_UNKNOWN" => Some(Self::RoomEndUnknown),
            "ROOM_END_API_DELETE" => Some(Self::RoomEndApiDelete),
            "ROOM_END_IDLE_TIMEOUT" => Some(Self::RoomEndIdleTimeout),
            "ROOM_END_SERVER_SHUTDOWN" => Some(Self::RoomEndServerShutdown),
            "ROOM_END_SUPERSEDED" => Some(Self::RoomEndSuperseded),
            "ROOM_END_OPEN_FAILED" => Some(Self::RoomEndOpenFailed),
            _ => 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 {
    #[prost(message, optional, tag = "3")]
    pub audio: ::core::option::Option<AudioConfig>,
    #[prost(message, optional, tag = "4")]
    pub data: ::core::option::Option<DataConfig>,
    #[prost(oneof = "media_source::Video", tags = "1, 2, 5")]
    pub video: ::core::option::Option<media_source::Video>,
}
/// Nested message and enum types in `MediaSource`.
pub mod media_source {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Video {
        #[prost(string, tag = "1")]
        VideoTrackId(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        ParticipantVideo(super::ParticipantVideo),
        /// Multiple independent video tracks; requires an MCAP file output
        #[prost(message, tag = "5")]
        Videos(super::VideoConfig),
    }
}
// --- 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,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoConfig {
    #[prost(bool, tag = "1")]
    pub capture_all: bool,
    #[prost(message, repeated, tag = "2")]
    pub selectors: ::prost::alloc::vec::Vec<VideoSelector>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VideoSelector {
    /// Narrows the match to tracks with this name; alone, matches it from any participant
    #[prost(string, tag = "3")]
    pub track_name: ::prost::alloc::string::String,
    /// Drop matching tracks, overriding capture_all and other matches
    #[prost(bool, tag = "4")]
    pub exclude: bool,
    #[prost(oneof = "video_selector::Match", tags = "1, 2")]
    pub r#match: ::core::option::Option<video_selector::Match>,
}
/// Nested message and enum types in `VideoSelector`.
pub mod video_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),
    }
}
// --- 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 {
    /// Narrows the match to tracks with this name; alone, matches it from any participant
    #[prost(string, tag = "5")]
    pub track_name: ::prost::alloc::string::String,
    /// Drop matching tracks, overriding capture_all and other routes
    #[prost(bool, tag = "6")]
    pub exclude: bool,
    #[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 {
    /// Narrows the match to tracks with this name; alone, matches it from any participant
    #[prost(string, tag = "3")]
    pub track_name: ::prost::alloc::string::String,
    /// Drop matching tracks, overriding capture_all and other matches
    #[prost(bool, tag = "4")]
    pub exclude: bool,
    #[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, ::prost::Message)]
pub struct StreamOutput {
    /// required
    #[prost(enumeration = "StreamProtocol", tag = "1")]
    pub protocol: i32,
    /// urls or destinations required
    #[prost(string, repeated, tag = "2")]
    pub urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// urls or destinations required
    #[prost(message, repeated, tag = "3")]
    pub destinations: ::prost::alloc::vec::Vec<StreamDestination>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StreamDestination {
    /// required
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// required
    #[prost(string, tag = "2")]
    pub url: ::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,
    /// StreamDestination.id this stream was started from; empty for plain urls
    #[prost(string, tag = "9")]
    pub id: ::prost::alloc::string::String,
}
/// 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, ::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>,
    #[prost(message, repeated, tag = "4")]
    pub add_destinations: ::prost::alloc::vec::Vec<StreamDestination>,
}
#[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,
    /// One channel per captured track
    Mcap = 4,
}
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",
            Self::Mcap => "MCAP",
        }
    }
    /// 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),
            "MCAP" => Some(Self::Mcap),
            _ => 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,
    /// MPEG-TS segments
    HlsProtocol = 1,
    /// fragmented MP4 segments
    HlsFmp4Protocol = 2,
}
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",
            Self::HlsFmp4Protocol => "HLS_FMP4_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),
            "HLS_FMP4_PROTOCOL" => Some(Self::HlsFmp4Protocol),
            _ => 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 NegotiatedDataChannelId {
    NdciInvalid = 0,
    NdciReliable = 100,
    NdciLossy = 101,
    NdciDataTrack = 102,
}
impl NegotiatedDataChannelId {
    /// 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::NdciInvalid => "NDCI_INVALID",
            Self::NdciReliable => "NDCI_RELIABLE",
            Self::NdciLossy => "NDCI_LOSSY",
            Self::NdciDataTrack => "NDCI_DATA_TRACK",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NDCI_INVALID" => Some(Self::NdciInvalid),
            "NDCI_RELIABLE" => Some(Self::NdciReliable),
            "NDCI_LOSSY" => Some(Self::NdciLossy),
            "NDCI_DATA_TRACK" => Some(Self::NdciDataTrack),
            _ => 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,
    /// when the server created the job, in Unix nanoseconds
    #[prost(int64, tag = "14")]
    pub created_at: i64,
    /// The agent thread (an AT_ id, see agent/livekit_agent_thread.proto) the dispatched job's
    /// call reads and writes. Empty means the call keeps no durable thread.
    #[prost(string, tag = "15")]
    pub thread_id: ::prost::alloc::string::String,
}
#[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,
    /// why the job has no agent, for JS_PENDING and JS_CANCELLED jobs
    #[prost(enumeration = "JobStateReason", tag = "9")]
    pub reason: i32,
    /// when the server received the worker's accept for this attempt, in Unix nanoseconds
    #[prost(int64, tag = "10")]
    pub accepted_at: i64,
    /// when the server sent the assignment for this attempt, in Unix nanoseconds
    #[prost(int64, tag = "11")]
    pub assigned_at: i64,
    /// attempts assigned to a worker so far, the current one included
    #[prost(uint32, tag = "12")]
    pub attempts: u32,
    /// started_at of the first attempt assigned to a worker, in Unix nanoseconds
    #[prost(int64, tag = "13")]
    pub first_started_at: i64,
    /// time spent in attempts the agent's own code failed before the agent
    /// joined, as an entrypoint that fails before it connects: from each such
    /// attempt's start to the next attempt's start, in nanoseconds
    #[prost(int64, tag = "14")]
    pub agent_failed_attempts_ns: i64,
    /// workers asked to take this attempt, the one that took it included
    #[prost(uint32, tag = "15")]
    pub workers_asked: u32,
}
/// 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, 8")]
    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),
        /// a running job asks the server to sign an access token for it
        #[prost(message, tag = "8")]
        CreateJobToken(super::CreateJobTokenRequest),
    }
}
/// from Server to Worker
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerMessage {
    #[prost(oneof = "server_message::Message", tags = "1, 2, 3, 5, 4, 6, 7")]
    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),
        /// the server is draining this control connection: re-register elsewhere,
        /// in-flight agent HTTP streams run to completion
        #[prost(message, tag = "6")]
        GoAway(super::agent_http::GoAway),
        #[prost(message, tag = "7")]
        CreateJobToken(super::CreateJobTokenResponse),
    }
}
#[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, ::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,
    #[prost(string, tag = "3")]
    pub version: ::prost::alloc::string::String,
    #[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,
    /// HTTP endpoints this worker serves through the data plane, in route order.
    /// Empty means the worker exposes no endpoints and needs no data connections.
    #[prost(message, repeated, tag = "10")]
    pub endpoints: ::prost::alloc::vec::Vec<agent_http::AgentEndpoint>,
    /// random per process; a re-registration with a new instance_id supersedes the
    /// previous epoch and closes its remaining connections
    #[prost(string, tag = "11")]
    pub instance_id: ::prost::alloc::string::String,
    /// highest data-plane protocol version the worker supports; 0 = unsupported
    #[prost(uint32, tag = "12")]
    pub endpoint_protocol: u32,
}
#[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>,
    /// present iff the registration carried endpoints and the server supports the data plane
    #[prost(message, optional, tag = "4")]
    pub endpoint_settings: ::core::option::Option<agent_http::AgentEndpointSettings>,
}
#[derive(Clone, PartialEq, ::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>,
    /// the jobs in job_ids as they were assigned, with state.participant_identity
    /// set to the identity the worker accepted them with
    #[prost(message, repeated, tag = "3")]
    pub jobs: ::prost::alloc::vec::Vec<Job>,
}
#[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,
    /// set once the agent has connected to the room
    #[prost(message, optional, tag = "4")]
    pub join_timing: ::core::option::Option<JobJoinTiming>,
}
/// Instants of one agent join on the worker host's monotonic clock, in microseconds. The
/// clock origin is arbitrary, so only differences between these values carry meaning on
/// their own. The worker and its job processes share this clock.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct JobJoinTiming {
    /// availability request received
    #[prost(int64, tag = "1")]
    pub offer_received_us: i64,
    /// request handler accepted the job
    #[prost(int64, tag = "2")]
    pub accepted_us: i64,
    /// job assignment received
    #[prost(int64, tag = "3")]
    pub assignment_received_us: i64,
    /// a job process was handed the job
    #[prost(int64, tag = "4")]
    pub launched_us: i64,
    /// an idle process took the job; false means one was spawned
    #[prost(bool, tag = "5")]
    pub launch_warm: bool,
    /// the agent's entrypoint started
    #[prost(int64, tag = "6")]
    pub entrypoint_started_us: i64,
    /// the agent called room connect
    #[prost(int64, tag = "7")]
    pub connect_called_us: i64,
    /// the agent's primary transport connected
    #[prost(int64, tag = "8")]
    pub connected_us: i64,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct UpdateWorkerStatus {
    #[prost(enumeration = "WorkerStatus", optional, tag = "1")]
    pub status: ::core::option::Option<i32>,
    #[prost(float, tag = "3")]
    pub load: f32,
    #[prost(uint32, tag = "4")]
    pub job_count: u32,
    /// worker wants no new streams; existing streams run to completion
    #[prost(bool, tag = "5")]
    pub draining: bool,
    /// monotonic per registration; status updates may interleave across connections
    /// and a stale report must not regress newer state
    #[prost(uint64, tag = "6")]
    pub seq: u64,
}
#[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, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateJobTokenRequest {
    /// echoed in the response
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub job_id: ::prost::alloc::string::String,
    /// The claims of the token the job wants, as JSON, in the same shape as an
    /// access token's payload: identity, name, attributes, video, sip, and so on.
    #[prost(string, tag = "3")]
    pub claims: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateJobTokenResponse {
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub token: ::prost::alloc::string::String,
    /// Unix seconds
    #[prost(int64, tag = "3")]
    pub expires_at: i64,
    /// empty on success; otherwise why the token was refused, naming any refused claim
    #[prost(string, tag = "4")]
    pub error: ::prost::alloc::string::String,
}
/// ----- agent HTTP endpoints data plane -----
///
/// AgentHttp namespaces the data plane: workers expose HTTP endpoints served at
/// /agents/{agent_name}/{deployment}/{path} without binding any local listener.
/// The worker opens ONE WebTransport (QUIC) session to /agent that carries both
/// its control stream (the same WorkerMessage/ServerMessage exchange as the
/// WebSocket control connection, length-delimited) and every HTTP exchange: the
/// node opens one bidirectional QUIC stream per request. QUIC provides the
/// multiplexing and per-stream flow control, so there is no credit accounting
/// and no attach handshake.
///
/// Each exchange stream is:
///
///    [len:u32be][StreamPreamble]   the only LiveKit framing
///    \[ ... opaque bytes ... \]      one HTTP/1.1 exchange, to FIN or RESET_STREAM
///
/// After the preamble the stream is byte-transparent: the node writes a
/// canonical HTTP/1.1 request and the worker replies with an HTTP/1.1 response,
/// each parsed by whatever HTTP implementation the side already has. A WebSocket
/// upgrade is therefore an ordinary request whose response is a 101, after which
/// the stream is a byte pipe. The protocol evolves by version negotiation at
/// registration, so the preamble carries no version of its own.
///
/// Bodies use ordinary HTTP/1.1 framing, Content-Length or chunked, and are
/// unbounded: a body may be many gigabytes and must be streamed. Request and
/// response size limits are policy for the layer above.
///
/// How one direction ends:
///
///    success             end of message per the body's own framing, then FIN.
///    failed mid-body     chunked trailer fields x-lk-completion and x-lk-error,
///                        in band, so the outcome cannot race the bytes it
///                        describes.
///    failed before any   RESET_STREAM carrying an HttpStreamResetCode, sound
///    bytes               only here, where nothing is in flight.
///
/// FIN before the body's own framing says it is complete is truncation, and a
/// receiver must surface it as such.
///
/// The x-lk- header prefix is reserved for this signalling in both directions.
/// A node strips it from client-supplied request headers, so a client cannot
/// forge one, and strips it from responses, so it never reaches the end client.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AgentHttp {
}
/// Nested message and enum types in `AgentHttp`.
pub mod agent_http {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AgentEndpoint {
        /// starlette-style path template rooted at '/': {name} (one segment, default),
        /// {name:int}, {name:float}, {name:uuid} (constrained single segments),
        /// {name:path} (multi-segment). Custom converters are rejected.
        #[prost(string, tag = "1")]
        pub path: ::prost::alloc::string::String,
        /// uppercase, exactly as the application routes them (FastAPI does not imply
        /// HEAD from GET)
        #[prost(string, repeated, tag = "2")]
        pub methods: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        #[prost(enumeration = "AgentEndpointKind", tag = "3")]
        pub kind: i32,
        /// reachable without a project token
        #[prost(bool, tag = "4")]
        pub public: bool,
    }
    /// registration-level settings negotiated on the control connection, returned
    /// in RegisterWorkerResponse when the worker declares endpoints and the server
    /// supports the data plane.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AgentEndpointSettings {
        /// the negotiated data-plane protocol version; the worker speaks exactly this
        /// or closes the session
        #[prost(uint32, tag = "1")]
        pub protocol: u32,
    }
    /// the first thing on every exchange stream, node -> worker. It carries only
    /// what the worker cannot derive from the HTTP bytes that follow and what it
    /// must not infer from client-supplied headers - identity above all.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct StreamPreamble {
        /// what the bytes after this preamble are. A field rather than a framing
        /// tag, so a new stream semantic costs no new mechanism.
        #[prost(enumeration = "AgentEndpointKind", tag = "1")]
        pub kind: i32,
        #[prost(string, tag = "2")]
        pub request_id: ::prost::alloc::string::String,
        /// the caller holds agent-endpoint call permission for this agent and
        /// deployment. Always true on a non-public route.
        #[prost(bool, tag = "3")]
        pub authorized: bool,
        /// the manifest template that matched, e.g. "/items/{id}"
        #[prost(string, tag = "4")]
        pub route: ::prost::alloc::string::String,
        /// relative, because node and worker clocks are not synchronized. 0 imposes
        /// no deadline.
        #[prost(uint32, tag = "5")]
        pub timeout_ms: u32,
        /// end client address, host only
        #[prost(string, tag = "6")]
        pub client_addr: ::prost::alloc::string::String,
        /// "http" or "https" as the end client saw it; not derivable worker-side
        ///
        /// NEXT_ID: 8
        #[prost(string, tag = "7")]
        pub scheme: ::prost::alloc::string::String,
    }
    /// the server is draining: the worker should re-register elsewhere; in-flight
    /// HTTP exchanges run to completion
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GoAway {
        #[prost(string, tag = "1")]
        pub reason: ::prost::alloc::string::String,
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum AgentEndpointKind {
        AekHttp = 0,
        /// reserved for future text-mode endpoints
        AekText = 1,
    }
    impl AgentEndpointKind {
        /// 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::AekHttp => "AEK_HTTP",
                Self::AekText => "AEK_TEXT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "AEK_HTTP" => Some(Self::AekHttp),
                "AEK_TEXT" => Some(Self::AekText),
                _ => None,
            }
        }
    }
    /// why a stream was reset before any HTTP bytes flowed. This travels as the
    /// QUIC RESET_STREAM / STOP_SENDING error code, so it is a number with no room
    /// for detail: the reason string is logged by the side that reset and joined
    /// to this by request_id. An outcome after bytes have flowed travels in
    /// trailers instead, where it cannot race them.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum HttpStreamResetCode {
        /// no information. The ordinary cancel code, sent whenever a stream is torn
        /// down without a specific outcome, so it must stay the zero value and must
        /// not imply that anything was or was not applied.
        HsrAbort = 0,
        /// the worker aborted before any application code observed the request, so
        /// nothing was applied and the exchange is safe to retry. Requires that the
        /// application was never entered; a 404 it returned is an ordinary response.
        HsrRefused = 1,
        /// the application was entered and then failed before producing a response
        /// head; side effects may already have happened, so this is not safe to
        /// retry.
        HsrInternal = 2,
        /// the deadline elapsed before a response head was produced
        HsrTimeout = 3,
        /// the peer's bytes were not valid HTTP/1.1
        HsrProtocol = 4,
    }
    impl HttpStreamResetCode {
        /// 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::HsrAbort => "HSR_ABORT",
                Self::HsrRefused => "HSR_REFUSED",
                Self::HsrInternal => "HSR_INTERNAL",
                Self::HsrTimeout => "HSR_TIMEOUT",
                Self::HsrProtocol => "HSR_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 {
                "HSR_ABORT" => Some(Self::HsrAbort),
                "HSR_REFUSED" => Some(Self::HsrRefused),
                "HSR_INTERNAL" => Some(Self::HsrInternal),
                "HSR_TIMEOUT" => Some(Self::HsrTimeout),
                "HSR_PROTOCOL" => Some(Self::HsrProtocol),
                _ => None,
            }
        }
    }
}
#[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,
    /// the job ended before it was assigned to an agent
    JsCancelled = 4,
}
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",
            Self::JsCancelled => "JS_CANCELLED",
        }
    }
    /// 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),
            "JS_CANCELLED" => Some(Self::JsCancelled),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobStateReason {
    JsrUnspecified = 0,
    /// no agent was available to accept the job
    JsrNoCapacity = 1,
    /// the room closed before an agent was assigned
    JsrRoomClosed = 2,
    /// the dispatch was deleted before an agent was assigned
    JsrDispatchDeleted = 3,
    /// the job failed and is being dispatched again
    JsrRetrying = 4,
}
impl JobStateReason {
    /// 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::JsrUnspecified => "JSR_UNSPECIFIED",
            Self::JsrNoCapacity => "JSR_NO_CAPACITY",
            Self::JsrRoomClosed => "JSR_ROOM_CLOSED",
            Self::JsrDispatchDeleted => "JSR_DISPATCH_DELETED",
            Self::JsrRetrying => "JSR_RETRYING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "JSR_UNSPECIFIED" => Some(Self::JsrUnspecified),
            "JSR_NO_CAPACITY" => Some(Self::JsrNoCapacity),
            "JSR_ROOM_CLOSED" => Some(Self::JsrRoomClosed),
            "JSR_DISPATCH_DELETED" => Some(Self::JsrDispatchDeleted),
            "JSR_RETRYING" => Some(Self::JsrRetrying),
            _ => 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>,
    /// The agent thread (an AT_ id, see agent/livekit_agent_thread.proto) the dispatched job's
    /// call reads and writes. Empty means the call keeps no durable thread.
    #[prost(string, tag = "7")]
    pub thread_id: ::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>,
    /// The agent thread (an AT_ id, see agent/livekit_agent_thread.proto) the dispatched job's
    /// call reads and writes. Empty means the call keeps no durable thread.
    #[prost(string, tag = "6")]
    pub thread_id: ::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>,
    /// The agent thread (an AT_ id, see agent/livekit_agent_thread.proto) the dispatched job's
    /// call reads and writes. Empty means the call keeps no durable thread.
    #[prost(string, tag = "9")]
    pub thread_id: ::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,
    #[prost(enumeration = "AgentDispatchTrigger", tag = "4")]
    pub trigger: i32,
}
#[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,
        }
    }
}
/// what created the dispatch
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AgentDispatchTrigger {
    AdtUnspecified = 0,
    /// a participant joining created the room, and with it the dispatch
    AdtJoin = 1,
    /// the CreateRoom API created the room, and with it the dispatch
    AdtRoomApi = 2,
    /// the CreateDispatch API
    AdtDispatchApi = 3,
}
impl AgentDispatchTrigger {
    /// 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::AdtUnspecified => "ADT_UNSPECIFIED",
            Self::AdtJoin => "ADT_JOIN",
            Self::AdtRoomApi => "ADT_ROOM_API",
            Self::AdtDispatchApi => "ADT_DISPATCH_API",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ADT_UNSPECIFIED" => Some(Self::AdtUnspecified),
            "ADT_JOIN" => Some(Self::AdtJoin),
            "ADT_ROOM_API" => Some(Self::AdtRoomApi),
            "ADT_DISPATCH_API" => Some(Self::AdtDispatchApi),
            _ => 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_pending, 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,
    /// set when event is room_finished
    #[prost(enumeration = "RoomEndReason", tag = "13")]
    pub room_end_reason: 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>,
    /// Stop sending audio RTP while outbound DTMF digits are sent.
    /// Always on when the telephone-event clock rate differs from the audio codec's.
    #[prost(bool, tag = "5")]
    pub drop_audio_during_dtmf: bool,
}
#[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>,
    /// SIP status code if ringing_timeout elapses. Unset means using system default.
    #[prost(enumeration = "SipStatusCode", tag = "21")]
    pub ringing_timeout_status: i32,
    /// 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>,
    /// Currently not usable with CreateSIPParticipant: sip_call_to is required, and
    /// the two cannot be combined. Use to_user_override to change the To header user.
    ///
    /// 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,
    /// Replaces the user part of the To header, leaving its host, port and transport
    /// as they would otherwise be. The request URI is not affected, so the call is
    /// still placed to sip_call_to. Empty means no override.
    ///
    /// Use this when the callee expects a To header that differs from the number
    /// being dialed. Setting "To" in the headers map is not a valid alternative:
    /// it adds a second To header rather than replacing the existing one, which
    /// makes the INVITE malformed.
    #[prost(string, tag = "27")]
    pub to_user_override: ::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,
    /// Deprecated: use dialtone. Setting play_dialtone (or play_ringtone) is equivalent to SIP_DIALTONE_ETSI when dialtone is unset.
    #[deprecated]
    #[prost(bool, tag = "6")]
    pub play_ringtone: bool,
    #[deprecated]
    #[prost(bool, tag = "13")]
    pub play_dialtone: bool,
    /// Optionally play dialtone in the room as an audible indicator for existing participants.
    #[prost(enumeration = "SipDialtone", tag = "28")]
    pub dialtone: i32,
    /// 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>,
    #[prost(message, optional, tag = "22")]
    pub destination: ::core::option::Option<Destination>,
    /// cloud only
    /// LiveKit SIP call ID (SCL_\[...\]) of a live inbound call in the same project.
    /// This is the ID that LiveKit assigns to the call (sip_call_id on
    /// SIPParticipantInfo), not the SIP Call-ID header from the provider. It is
    /// used for forwarding an inbound call, while keeping the original caller's ID
    /// as the caller ID of this new call.
    /// If sip_from_header is set, its user must match the caller's number. If not,
    /// the caller's number is used.
    ///
    /// NEXT ID: 30
    #[prost(string, tag = "29")]
    pub sip_source_call_id: ::prost::alloc::string::String,
}
#[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,
    /// Deprecated: use dialtone. Setting play_dialtone is equivalent to SIP_DIALTONE_ETSI when dialtone is unset.
    #[deprecated]
    #[prost(bool, tag = "4")]
    pub play_dialtone: bool,
    /// Optionally play dialtone to the SIP participant as an audible indicator of being transferred.
    #[prost(enumeration = "SipDialtone", tag = "7")]
    pub dialtone: i32,
    /// 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>,
}
/// Added in <https://github.com/livekit/protocol/pull/1730.> Not needed after all:
/// will be rolled back to an empty message once STR_CALL_ENDED is reported as an
/// error like every other failed transfer.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TransferSipParticipantResponse {
    #[prost(string, tag = "1")]
    pub transfer_id: ::prost::alloc::string::String,
    #[prost(enumeration = "SipTransferStatus", tag = "2")]
    pub status: i32,
    #[prost(enumeration = "SipTransferReason", tag = "3")]
    pub reason: i32,
    /// Set when the outcome was reported by a SIP response.
    #[prost(message, optional, tag = "4")]
    pub sip_status: ::core::option::Option<SipStatus>,
}
/// Details of a failed SIP transfer, attached to the error.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SipTransferError {
    #[prost(string, tag = "1")]
    pub transfer_id: ::prost::alloc::string::String,
    #[prost(enumeration = "SipTransferReason", tag = "2")]
    pub reason: i32,
    /// Set when the outcome was reported by a SIP response.
    #[prost(message, optional, tag = "3")]
    pub sip_status: ::core::option::Option<SipStatus>,
}
#[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>,
    #[prost(enumeration = "SipTransferReason", tag = "9")]
    pub reason: i32,
}
#[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,
        }
    }
}
/// Dial tone (ringback) played while a call is being placed or transferred.
/// Receivers treat unknown values as SIP_DIALTONE_ETSI.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SipDialtone {
    /// no tone
    Disabled = 0,
    /// 425 Hz, 1s on / 4s off; the tone play_dialtone used
    Etsi = 1,
    /// pick by the country of the called number, ETSI if unknown
    Auto = 2,
    /// North America (NANP)
    Us = 3,
    Uk = 4,
    Jp = 5,
    Au = 6,
}
impl SipDialtone {
    /// 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::Disabled => "SIP_DIALTONE_DISABLED",
            Self::Etsi => "SIP_DIALTONE_ETSI",
            Self::Auto => "SIP_DIALTONE_AUTO",
            Self::Us => "SIP_DIALTONE_US",
            Self::Uk => "SIP_DIALTONE_UK",
            Self::Jp => "SIP_DIALTONE_JP",
            Self::Au => "SIP_DIALTONE_AU",
        }
    }
    /// 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_DIALTONE_DISABLED" => Some(Self::Disabled),
            "SIP_DIALTONE_ETSI" => Some(Self::Etsi),
            "SIP_DIALTONE_AUTO" => Some(Self::Auto),
            "SIP_DIALTONE_US" => Some(Self::Us),
            "SIP_DIALTONE_UK" => Some(Self::Uk),
            "SIP_DIALTONE_JP" => Some(Self::Jp),
            "SIP_DIALTONE_AU" => Some(Self::Au),
            _ => 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 SipTransferReason {
    /// No reason reported
    StrUnspecified = 0,
    /// The transferee answered and the transfer completed
    StrCompleted = 1,
    /// The call ended before the transfer completed: remote BYE, room deleted or local hangup
    StrCallEnded = 2,
    /// The transferee, or its provider, rejected the transfer
    StrRejected = 3,
    /// The transferee did not answer in time
    StrRingingTimeout = 4,
    /// The provider stopped reporting the transfer status without a final response
    StrSubscriptionTerminated = 5,
    /// Canceled through the API
    StrCanceled = 6,
}
impl SipTransferReason {
    /// 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::StrUnspecified => "STR_UNSPECIFIED",
            Self::StrCompleted => "STR_COMPLETED",
            Self::StrCallEnded => "STR_CALL_ENDED",
            Self::StrRejected => "STR_REJECTED",
            Self::StrRingingTimeout => "STR_RINGING_TIMEOUT",
            Self::StrSubscriptionTerminated => "STR_SUBSCRIPTION_TERMINATED",
            Self::StrCanceled => "STR_CANCELED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "STR_UNSPECIFIED" => Some(Self::StrUnspecified),
            "STR_COMPLETED" => Some(Self::StrCompleted),
            "STR_CALL_ENDED" => Some(Self::StrCallEnded),
            "STR_REJECTED" => Some(Self::StrRejected),
            "STR_RINGING_TIMEOUT" => Some(Self::StrRingingTimeout),
            "STR_SUBSCRIPTION_TERMINATED" => Some(Self::StrSubscriptionTerminated),
            "STR_CANCELED" => Some(Self::StrCanceled),
            _ => 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>,
    #[prost(enumeration = "RoomEndReason", tag = "37")]
    pub room_end_reason: i32,
}
#[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,
        }
    }
}
/// Nested so that names like Value and Ping need not be unique across the
/// livekit package. `tip` throughout is the latest durable commit sequence.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AgentDb {
}
/// Nested message and enum types in `AgentDB`.
pub mod agent_db {
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct CreateRequest {
        /// Unset: never expires, and expires_at is then unset everywhere.
        /// Otherwise clamped to the server cap, and never extended.
        #[prost(message, optional, tag = "1")]
        pub ttl: ::core::option::Option<::pbjson_types::Duration>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct CreateResponse {
        /// "DB_..." for a standalone database, the thread id ("AT_...") for a thread's
        #[prost(string, tag = "1")]
        pub database_id: ::prost::alloc::string::String,
        #[prost(message, optional, tag = "2")]
        pub expires_at: ::core::option::Option<::pbjson_types::Timestamp>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GetRequest {
        #[prost(string, tag = "1")]
        pub database_id: ::prost::alloc::string::String,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ListRequest {
        /// server-clamped
        #[prost(int32, tag = "1")]
        pub page_size: i32,
        #[prost(string, tag = "2")]
        pub page_token: ::prost::alloc::string::String,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ListResponse {
        #[prost(message, repeated, tag = "1")]
        pub databases: ::prost::alloc::vec::Vec<AgentDatabase>,
        /// empty when exhausted
        #[prost(string, tag = "2")]
        pub next_page_token: ::prost::alloc::string::String,
    }
    /// One database, as get and list both report it.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AgentDatabase {
        #[prost(string, tag = "1")]
        pub database_id: ::prost::alloc::string::String,
        #[prost(string, tag = "2")]
        pub region: ::prost::alloc::string::String,
        #[prost(message, optional, tag = "3")]
        pub created_at: ::core::option::Option<::pbjson_types::Timestamp>,
        #[prost(message, optional, tag = "4")]
        pub expires_at: ::core::option::Option<::pbjson_types::Timestamp>,
        #[prost(int64, tag = "5")]
        pub tip: i64,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DeleteRequest {
        #[prost(string, tag = "1")]
        pub database_id: ::prost::alloc::string::String,
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DeleteResponse {
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ExportRequest {
        #[prost(string, tag = "1")]
        pub database_id: ::prost::alloc::string::String,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ExportResponse {
        /// pre-authenticated object-storage URL
        #[prost(string, tag = "1")]
        pub download_url: ::prost::alloc::string::String,
        /// of the URL, not the database
        #[prost(message, optional, tag = "2")]
        pub expires_at: ::core::option::Option<::pbjson_types::Timestamp>,
        /// what the export is consistent at
        #[prost(int64, tag = "3")]
        pub tip: i64,
    }
    /// Data plane: one WebSocket per database, one message per frame, correlated
    /// by a client-chosen request_id. Result batches are paced by Credit, so the
    /// server never sends more un-consumed batches than granted.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Wire {
    }
    /// Nested message and enum types in `Wire`.
    pub mod wire {
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ClientMessage {
            #[prost(uint32, tag = "1")]
            pub request_id: u32,
            #[prost(oneof = "client_message::Message", tags = "2, 3, 4, 5, 6, 7, 8, 9, 10, 11")]
            pub message: ::core::option::Option<client_message::Message>,
        }
        /// Nested message and enum types in `ClientMessage`.
        pub mod client_message {
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum Message {
                /// must be first on the socket
                #[prost(message, tag = "2")]
                Hello(super::Hello),
                /// answers ExecResult
                #[prost(message, tag = "3")]
                Exec(super::Statement),
                /// answers Columns + ColumnBatch* + Done
                #[prost(message, tag = "4")]
                Query(super::Statement),
                /// answers one result per statement, then Done
                #[prost(message, tag = "5")]
                Batch(super::Batch),
                #[prost(message, tag = "6")]
                Begin(super::Begin),
                #[prost(message, tag = "7")]
                Commit(super::Commit),
                #[prost(message, tag = "8")]
                Rollback(super::Rollback),
                #[prost(message, tag = "9")]
                Cancel(super::Cancel),
                #[prost(message, tag = "10")]
                Credit(super::Credit),
                #[prost(message, tag = "11")]
                Ping(super::Ping),
            }
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ServerMessage {
            #[prost(uint32, tag = "1")]
            pub request_id: u32,
            #[prost(oneof = "server_message::Message", tags = "2, 3, 4, 5, 6, 7, 8")]
            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 {
                #[prost(message, tag = "2")]
                HelloOk(super::HelloOk),
                #[prost(message, tag = "3")]
                Columns(super::Columns),
                #[prost(message, tag = "4")]
                ColumnBatch(super::ColumnBatch),
                #[prost(message, tag = "5")]
                ExecResult(super::ExecResult),
                #[prost(message, tag = "6")]
                Done(super::Done),
                #[prost(message, tag = "7")]
                Error(super::Error),
                #[prost(message, tag = "8")]
                Pong(super::Pong),
            }
        }
        /// SQLite's five storage classes.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Value {
            #[prost(oneof = "value::Value", tags = "1, 2, 3, 4, 5")]
            pub value: ::core::option::Option<value::Value>,
        }
        /// Nested message and enum types in `Value`.
        pub mod value {
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum Value {
                /// always true when set
                #[prost(bool, tag = "1")]
                NullValue(bool),
                #[prost(int64, tag = "2")]
                IntValue(i64),
                #[prost(double, tag = "3")]
                DoubleValue(f64),
                #[prost(string, tag = "4")]
                TextValue(::prost::alloc::string::String),
                #[prost(bytes, tag = "5")]
                BlobValue(::prost::alloc::vec::Vec<u8>),
            }
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Statement {
            #[prost(string, tag = "1")]
            pub sql: ::prost::alloc::string::String,
            /// positional
            #[prost(message, repeated, tag = "2")]
            pub params: ::prost::alloc::vec::Vec<Value>,
            #[prost(enumeration = "QueryLang", tag = "3")]
            pub lang: i32,
        }
        /// Applied atomically, in order, and answered with one result per
        /// statement, in order: Columns then ColumnBatch frames for a statement
        /// that returns rows, one ExecResult for one that does not, each tagged
        /// with the statement's 0-based index, then a single Done for the whole
        /// batch. A statement that returns no rows still sends its Columns. Credit
        /// paces the ColumnBatch frames of the batch as a whole.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Batch {
            #[prost(message, repeated, tag = "1")]
            pub statements: ::prost::alloc::vec::Vec<Statement>,
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Begin {
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Commit {
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Rollback {
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Cancel {
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Credit {
            /// additional batches the client can absorb
            #[prost(uint32, tag = "1")]
            pub batches: u32,
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Ping {
            #[prost(int64, tag = "1")]
            pub timestamp_ms: i64,
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Pong {
            #[prost(int64, tag = "1")]
            pub last_ping_timestamp_ms: i64,
            #[prost(int64, tag = "2")]
            pub timestamp_ms: i64,
        }
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Hello {
            #[prost(string, tag = "1")]
            pub token: ::prost::alloc::string::String,
            #[prost(string, tag = "2")]
            pub database_id: ::prost::alloc::string::String,
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct HelloOk {
            #[prost(int64, tag = "1")]
            pub tip: i64,
            #[prost(uint32, tag = "2")]
            pub ping_interval_ms: u32,
            #[prost(uint32, tag = "3")]
            pub ping_timeout_ms: u32,
        }
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Columns {
            #[prost(string, repeated, tag = "1")]
            pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
            /// index within a Batch; 0 and unused for a Query
            #[prost(uint32, tag = "2")]
            pub statement: u32,
        }
        /// Values are typed per row, as SQLite types them, so a column may mix
        /// classes: walk `types` and take the next entry from the matching array. Text
        /// and blobs are concatenated with one exclusive end offset each, so value i
        /// is data\[ends[i-1\]:ends\[i]\] with 0 implied before the first. A NULL occupies
        /// a tag only.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Column {
            /// one ValueType per row
            #[prost(bytes = "vec", tag = "1")]
            pub types: ::prost::alloc::vec::Vec<u8>,
            #[prost(sint64, repeated, tag = "2")]
            pub ints: ::prost::alloc::vec::Vec<i64>,
            #[prost(double, repeated, tag = "3")]
            pub doubles: ::prost::alloc::vec::Vec<f64>,
            #[prost(bytes = "vec", tag = "4")]
            pub text_data: ::prost::alloc::vec::Vec<u8>,
            #[prost(uint32, repeated, tag = "5")]
            pub text_ends: ::prost::alloc::vec::Vec<u32>,
            #[prost(bytes = "vec", tag = "6")]
            pub blob_data: ::prost::alloc::vec::Vec<u8>,
            #[prost(uint32, repeated, tag = "7")]
            pub blob_ends: ::prost::alloc::vec::Vec<u32>,
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ColumnBatch {
            /// one per name in Columns
            #[prost(message, repeated, tag = "1")]
            pub columns: ::prost::alloc::vec::Vec<Column>,
            #[prost(uint32, tag = "2")]
            pub rows: u32,
            /// index within a Batch; 0 and unused for a Query
            #[prost(uint32, tag = "3")]
            pub statement: u32,
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct ExecResult {
            #[prost(int64, tag = "1")]
            pub rows_affected: i64,
            #[prost(int64, tag = "2")]
            pub last_insert_id: i64,
            #[prost(int64, tag = "3")]
            pub tip: i64,
            /// index within a Batch; 0 and unused for an Exec
            #[prost(uint32, tag = "4")]
            pub statement: u32,
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Done {
            /// the snapshot the query ran at
            #[prost(int64, tag = "1")]
            pub tip: i64,
            #[prost(uint64, tag = "2")]
            pub total_rows: u64,
        }
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Error {
            /// stable, machine-readable
            #[prost(string, tag = "1")]
            pub code: ::prost::alloc::string::String,
            #[prost(string, tag = "2")]
            pub message: ::prost::alloc::string::String,
        }
        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
        #[repr(i32)]
        pub enum QueryLang {
            Sql = 0,
        }
        impl QueryLang {
            /// 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::Sql => "SQL",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "SQL" => Some(Self::Sql),
                    _ => None,
                }
            }
        }
        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
        #[repr(i32)]
        pub enum ValueType {
            Null = 0,
            Int = 1,
            Double = 2,
            Text = 3,
            Blob = 4,
        }
        impl ValueType {
            /// 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::Null => "NULL",
                    Self::Int => "INT",
                    Self::Double => "DOUBLE",
                    Self::Text => "TEXT",
                    Self::Blob => "BLOB",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "NULL" => Some(Self::Null),
                    "INT" => Some(Self::Int),
                    "DOUBLE" => Some(Self::Double),
                    "TEXT" => Some(Self::Text),
                    "BLOB" => Some(Self::Blob),
                    _ => None,
                }
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListReplaysRequest {
    /// optional
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub page_token: ::core::option::Option<TokenPagination>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListReplaysResponse {
    #[prost(message, repeated, tag = "1")]
    pub replays: ::prost::alloc::vec::Vec<ReplayInfo>,
    #[prost(message, optional, tag = "2")]
    pub next_page_token: ::core::option::Option<TokenPagination>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ReplayInfo {
    #[prost(string, tag = "1")]
    pub replay_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(int64, tag = "3")]
    pub start_time: i64,
    #[prost(int64, tag = "4")]
    pub duration_ms: i64,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlaybackRequest {
    #[prost(string, tag = "1")]
    pub replay_id: ::prost::alloc::string::String,
    /// name of room to play into
    #[prost(string, tag = "2")]
    pub playback_room: ::prost::alloc::string::String,
    /// initial timestamp (ms)
    #[prost(int64, tag = "3")]
    pub seek_offset_ms: i64,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlaybackResponse {
    #[prost(string, tag = "1")]
    pub playback_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SeekRequest {
    #[prost(string, tag = "1")]
    pub playback_id: ::prost::alloc::string::String,
    /// timestamp (ms)
    #[prost(int64, tag = "2")]
    pub seek_offset_ms: i64,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ClosePlaybackRequest {
    #[prost(string, tag = "1")]
    pub playback_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteReplayRequest {
    #[prost(string, tag = "1")]
    pub replay_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AgentEvent {
    #[prost(enumeration = "AgentEventType", tag = "1")]
    pub r#type: i32,
    #[prost(int32, tag = "2")]
    pub count: i32,
    #[prost(message, optional, tag = "3")]
    pub timestamp: ::core::option::Option<::pbjson_types::Timestamp>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AgentSecret {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(bytes = "vec", tag = "2")]
    pub value: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "4")]
    pub updated_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(enumeration = "AgentSecretKind", tag = "5")]
    pub kind: i32,
    #[prost(string, repeated, tag = "6")]
    pub deployments: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAgentRequest {
    #[deprecated]
    #[prost(string, tag = "1")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub secrets: ::prost::alloc::vec::Vec<AgentSecret>,
    #[deprecated]
    #[prost(int32, tag = "3")]
    pub replicas: i32,
    #[deprecated]
    #[prost(int32, tag = "4")]
    pub max_replicas: i32,
    #[deprecated]
    #[prost(string, tag = "5")]
    pub cpu_req: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "6")]
    pub regions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAgentResponse {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub status: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub version: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub presigned_url: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub tag: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "7")]
    pub server_regions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "8")]
    pub presigned_post_request: ::core::option::Option<PresignedPostRequest>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAgentV2Request {
    #[prost(message, repeated, tag = "1")]
    pub secrets: ::prost::alloc::vec::Vec<AgentSecret>,
    #[prost(string, repeated, tag = "2")]
    pub regions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateAgentV2Response {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub status: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "3")]
    pub server_regions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PromoteAgentRequest {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub src_deployment: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub dst_deployment: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PromoteAgentResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub src_deployment: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub dst_deployment: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub version_tag: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PresignedPostRequest {
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    #[prost(map = "string, string", tag = "2")]
    pub values: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AgentDeployment {
    #[prost(string, tag = "1")]
    pub region: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub status: ::prost::alloc::string::String,
    #[prost(int32, tag = "4")]
    pub replicas: i32,
    #[prost(int32, tag = "5")]
    pub min_replicas: i32,
    #[prost(int32, tag = "6")]
    pub max_replicas: i32,
    #[prost(string, tag = "7")]
    pub cpu_req: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub cur_cpu: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub cur_mem: ::prost::alloc::string::String,
    #[prost(string, tag = "10")]
    pub mem_req: ::prost::alloc::string::String,
    #[prost(string, tag = "11")]
    pub mem_limit: ::prost::alloc::string::String,
    #[prost(string, tag = "12")]
    pub cpu_limit: ::prost::alloc::string::String,
    #[prost(string, tag = "13")]
    pub server_region: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "14")]
    pub events: ::prost::alloc::vec::Vec<AgentEvent>,
    #[prost(string, tag = "15")]
    pub deployment: ::prost::alloc::string::String,
    #[prost(string, tag = "16")]
    pub version: ::prost::alloc::string::String,
    #[prost(string, tag = "17")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(bool, tag = "18")]
    pub deployment_enabled: bool,
    #[prost(message, optional, tag = "19")]
    pub last_scraped_at: ::core::option::Option<::pbjson_types::Timestamp>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AgentInfo {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub version: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "4")]
    pub agent_deployments: ::prost::alloc::vec::Vec<AgentDeployment>,
    #[prost(message, repeated, tag = "5")]
    pub secrets: ::prost::alloc::vec::Vec<AgentSecret>,
    #[prost(message, optional, tag = "6")]
    pub deployed_at: ::core::option::Option<::pbjson_types::Timestamp>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListAgentsRequest {
    #[prost(string, tag = "1")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAgentsResponse {
    #[prost(message, repeated, tag = "1")]
    pub agents: ::prost::alloc::vec::Vec<AgentInfo>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AgentVersion {
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub current: bool,
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, optional, tag = "4")]
    pub deployed_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(map = "string, string", tag = "5")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    #[prost(string, tag = "6")]
    pub status: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub owner: ::prost::alloc::string::String,
    #[prost(bool, tag = "8")]
    pub draining: bool,
    #[prost(bool, tag = "9")]
    pub active: bool,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListAgentVersionsRequest {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAgentVersionsResponse {
    #[prost(message, repeated, tag = "1")]
    pub versions: ::prost::alloc::vec::Vec<AgentVersion>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateAgentRequest {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(int32, tag = "3")]
    pub replicas: i32,
    #[deprecated]
    #[prost(int32, tag = "4")]
    pub max_replicas: i32,
    #[deprecated]
    #[prost(string, tag = "5")]
    pub cpu_req: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "6")]
    pub regions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "7")]
    pub secrets: ::prost::alloc::vec::Vec<AgentSecret>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateAgentResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RestartAgentRequest {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RestartAgentResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeployAgentRequest {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "3")]
    pub secrets: ::prost::alloc::vec::Vec<AgentSecret>,
    #[deprecated]
    #[prost(int32, tag = "4")]
    pub replicas: i32,
    #[deprecated]
    #[prost(int32, tag = "5")]
    pub max_replicas: i32,
    #[deprecated]
    #[prost(string, tag = "6")]
    pub cpu_req: ::prost::alloc::string::String,
    #[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 DeployAgentResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub agent_id: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(string, tag = "4")]
    pub presigned_url: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub tag: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "6")]
    pub presigned_post_request: ::core::option::Option<PresignedPostRequest>,
    #[prost(string, tag = "7")]
    pub deployment: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeployAgentV2Request {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub secrets: ::prost::alloc::vec::Vec<AgentSecret>,
    #[prost(string, tag = "3")]
    pub deployment: ::prost::alloc::string::String,
    #[prost(map = "string, string", tag = "4")]
    pub attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeployAgentV2Response {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub tag: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub presigned_req: ::core::option::Option<PresignedPostRequest>,
    #[prost(string, tag = "6")]
    pub deployment: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateAgentSecretsRequest {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub overwrite: bool,
    #[prost(message, repeated, tag = "4")]
    pub secrets: ::prost::alloc::vec::Vec<AgentSecret>,
    #[prost(string, repeated, tag = "5")]
    pub remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateAgentSecretsResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RollbackAgentRequest {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub version: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RollbackAgentResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteAgentRequest {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
    /// optional
    #[prost(string, tag = "3")]
    pub deployment: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteAgentResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListAgentSecretsRequest {
    #[prost(string, tag = "1")]
    pub agent_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAgentSecretsResponse {
    #[prost(message, repeated, tag = "1")]
    pub secrets: ::prost::alloc::vec::Vec<AgentSecret>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SettingsParam {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClientSettingsResponse {
    #[prost(message, repeated, tag = "1")]
    pub params: ::prost::alloc::vec::Vec<SettingsParam>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ClientSettingsRequest {
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PrivateLink {
    #[prost(string, tag = "1")]
    pub private_link_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub region: ::prost::alloc::string::String,
    #[prost(uint32, tag = "5")]
    pub port: u32,
    #[prost(string, tag = "6")]
    pub endpoint: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub connection_endpoint: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub cloud_region: ::prost::alloc::string::String,
    #[prost(oneof = "private_link::Config", tags = "3")]
    pub config: ::core::option::Option<private_link::Config>,
}
/// Nested message and enum types in `PrivateLink`.
pub mod private_link {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AwsConfig {
        /// Use the generic "endpoint" instead
        #[deprecated]
        #[prost(string, tag = "1")]
        pub endpoint: ::prost::alloc::string::String,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Config {
        #[deprecated]
        #[prost(message, tag = "3")]
        Aws(AwsConfig),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PrivateLinkStatus {
    #[prost(enumeration = "private_link_status::Status", tag = "1")]
    pub status: i32,
    #[prost(message, optional, tag = "2")]
    pub updated_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(string, tag = "3")]
    pub reason: ::prost::alloc::string::String,
}
/// Nested message and enum types in `PrivateLinkStatus`.
pub mod private_link_status {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Status {
        PrivateLinkStatusUnknown = 0,
        PrivateLinkStatusProvisioning = 1,
        PrivateLinkStatusPendingApproval = 2,
        PrivateLinkStatusHealthy = 3,
        PrivateLinkStatusUnhealthy = 4,
        PrivateLinkStatusApproved = 5,
    }
    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::PrivateLinkStatusUnknown => "PRIVATE_LINK_STATUS_UNKNOWN",
                Self::PrivateLinkStatusProvisioning => "PRIVATE_LINK_STATUS_PROVISIONING",
                Self::PrivateLinkStatusPendingApproval => "PRIVATE_LINK_STATUS_PENDING_APPROVAL",
                Self::PrivateLinkStatusHealthy => "PRIVATE_LINK_STATUS_HEALTHY",
                Self::PrivateLinkStatusUnhealthy => "PRIVATE_LINK_STATUS_UNHEALTHY",
                Self::PrivateLinkStatusApproved => "PRIVATE_LINK_STATUS_APPROVED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PRIVATE_LINK_STATUS_UNKNOWN" => Some(Self::PrivateLinkStatusUnknown),
                "PRIVATE_LINK_STATUS_PROVISIONING" => Some(Self::PrivateLinkStatusProvisioning),
                "PRIVATE_LINK_STATUS_PENDING_APPROVAL" => Some(Self::PrivateLinkStatusPendingApproval),
                "PRIVATE_LINK_STATUS_HEALTHY" => Some(Self::PrivateLinkStatusHealthy),
                "PRIVATE_LINK_STATUS_UNHEALTHY" => Some(Self::PrivateLinkStatusUnhealthy),
                "PRIVATE_LINK_STATUS_APPROVED" => Some(Self::PrivateLinkStatusApproved),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreatePrivateLinkRequest {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub region: ::prost::alloc::string::String,
    #[prost(uint32, tag = "4")]
    pub port: u32,
    #[prost(string, tag = "5")]
    pub endpoint: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "6")]
    pub cloud_region: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(oneof = "create_private_link_request::Config", tags = "2")]
    pub config: ::core::option::Option<create_private_link_request::Config>,
}
/// Nested message and enum types in `CreatePrivateLinkRequest`.
pub mod create_private_link_request {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AwsCreateConfig {
        #[deprecated]
        #[prost(string, tag = "1")]
        pub endpoint: ::prost::alloc::string::String,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Config {
        #[deprecated]
        #[prost(message, tag = "2")]
        Aws(AwsCreateConfig),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreatePrivateLinkResponse {
    #[prost(message, optional, tag = "1")]
    pub private_link: ::core::option::Option<PrivateLink>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DestroyPrivateLinkRequest {
    #[prost(string, tag = "1")]
    pub private_link_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DestroyPrivateLinkResponse {
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListPrivateLinksRequest {
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPrivateLinksResponse {
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<PrivateLink>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPrivateLinkStatusRequest {
    #[prost(string, tag = "1")]
    pub private_link_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPrivateLinkStatusResponse {
    #[prost(message, optional, tag = "1")]
    pub value: ::core::option::Option<PrivateLinkStatus>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AgentSecretKind {
    Unknown = 0,
    Environment = 1,
    File = 2,
}
impl AgentSecretKind {
    /// 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 => "AGENT_SECRET_KIND_UNKNOWN",
            Self::Environment => "AGENT_SECRET_KIND_ENVIRONMENT",
            Self::File => "AGENT_SECRET_KIND_FILE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AGENT_SECRET_KIND_UNKNOWN" => Some(Self::Unknown),
            "AGENT_SECRET_KIND_ENVIRONMENT" => Some(Self::Environment),
            "AGENT_SECRET_KIND_FILE" => Some(Self::File),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AgentEventType {
    Unknown = 0,
    ApplicationCrashed = 1,
    RestartedHighDiskUsage = 2,
    RestartedHighMemoryUsage = 3,
}
impl AgentEventType {
    /// 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 => "AGENT_EVENT_TYPE_UNKNOWN",
            Self::ApplicationCrashed => "AGENT_EVENT_TYPE_APPLICATION_CRASHED",
            Self::RestartedHighDiskUsage => "AGENT_EVENT_TYPE_RESTARTED_HIGH_DISK_USAGE",
            Self::RestartedHighMemoryUsage => "AGENT_EVENT_TYPE_RESTARTED_HIGH_MEMORY_USAGE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AGENT_EVENT_TYPE_UNKNOWN" => Some(Self::Unknown),
            "AGENT_EVENT_TYPE_APPLICATION_CRASHED" => Some(Self::ApplicationCrashed),
            "AGENT_EVENT_TYPE_RESTARTED_HIGH_DISK_USAGE" => Some(Self::RestartedHighDiskUsage),
            "AGENT_EVENT_TYPE_RESTARTED_HIGH_MEMORY_USAGE" => Some(Self::RestartedHighMemoryUsage),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SimulationRunSummary {
    #[prost(int32, tag = "1")]
    pub passed: i32,
    #[prost(int32, tag = "2")]
    pub failed: i32,
    #[prost(string, tag = "3")]
    pub going_well: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub to_improve: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "5")]
    pub issues: ::prost::alloc::vec::Vec<simulation_run_summary::Issue>,
    #[prost(map = "string, message", tag = "6")]
    pub chat_history: ::std::collections::HashMap<::prost::alloc::string::String, agent::ChatContext>,
}
/// Nested message and enum types in `SimulationRunSummary`.
pub mod simulation_run_summary {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Issue {
        #[prost(string, tag = "1")]
        pub description: ::prost::alloc::string::String,
        #[prost(string, tag = "2")]
        pub suggestion: ::prost::alloc::string::String,
        #[prost(string, tag = "3")]
        pub label: ::prost::alloc::string::String,
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SimulationRun {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub project_id: ::prost::alloc::string::String,
    #[prost(enumeration = "simulation_run::Status", tag = "3")]
    pub status: i32,
    #[prost(string, tag = "4")]
    pub agent_description: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub error: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "6")]
    pub created_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(message, repeated, tag = "7")]
    pub jobs: ::prost::alloc::vec::Vec<simulation_run::Job>,
    #[prost(string, tag = "9")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "10")]
    pub scenario_group: ::core::option::Option<ScenarioGroup>,
    #[prost(message, optional, tag = "11")]
    pub ended_at: ::core::option::Option<::pbjson_types::Timestamp>,
    #[prost(int32, tag = "12")]
    pub job_count: i32,
    #[prost(int32, tag = "13")]
    pub passed_count: i32,
    #[prost(int32, tag = "14")]
    pub failed_count: i32,
    #[prost(int32, tag = "15")]
    pub num_simulations: i32,
    /// Aggregate usage across all jobs in this run (sum of Job.usage).
    #[prost(message, optional, tag = "16")]
    pub usage: ::core::option::Option<simulation_run::Usage>,
    /// Maximum simulate jobs running in parallel for this run (0 = server default).
    #[prost(int32, tag = "17")]
    pub concurrency: i32,
    /// Conversation mode for every job in this run; unspecified = TEXT.
    #[prost(enumeration = "SimulationMode", tag = "18")]
    pub mode: i32,
    /// Run-level aggregates over this run's jobs.
    #[prost(message, optional, tag = "19")]
    pub metrics: ::core::option::Option<simulation_run::RunMetrics>,
    /// zstd-compressed SimulationRunSummary: decompress, then proto.Unmarshal.
    /// Compressed by default so the blob ships as-is on every hop.
    #[prost(bytes = "vec", tag = "20")]
    pub summary_zstd: ::prost::alloc::vec::Vec<u8>,
    /// How many issues the stored summary flagged. Present only once a summary
    /// landed — absent and 0 differ ("never summarized" vs "no issues") — and
    /// List responses carry it without the summary blob itself.
    #[prost(int32, optional, tag = "21")]
    pub issue_count: ::core::option::Option<i32>,
    /// The pipeline this run came from; unset when it did not come from one.
    #[prost(message, optional, tag = "22")]
    pub ci: ::core::option::Option<simulation_run::Ci>,
    /// Absent when the run ran each scenario once and required it to pass.
    #[prost(message, optional, tag = "23")]
    pub sampling: ::core::option::Option<simulation_run::SamplingOptions>,
}
/// Nested message and enum types in `SimulationRun`.
pub mod simulation_run {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Job {
        #[prost(string, tag = "1")]
        pub id: ::prost::alloc::string::String,
        #[prost(enumeration = "job::Status", tag = "2")]
        pub status: i32,
        #[prost(string, tag = "3")]
        pub instructions: ::prost::alloc::string::String,
        #[prost(string, tag = "4")]
        pub error: ::prost::alloc::string::String,
        #[prost(string, tag = "5")]
        pub agent_expectations: ::prost::alloc::string::String,
        #[prost(string, tag = "6")]
        pub label: ::prost::alloc::string::String,
        #[prost(string, repeated, tag = "7")]
        pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        #[prost(string, tag = "8")]
        pub room_name: ::prost::alloc::string::String,
        #[prost(message, optional, tag = "10")]
        pub started_at: ::core::option::Option<::pbjson_types::Timestamp>,
        #[prost(message, optional, tag = "11")]
        pub ended_at: ::core::option::Option<::pbjson_types::Timestamp>,
        #[prost(string, tag = "12")]
        pub room_id: ::prost::alloc::string::String,
        #[prost(message, optional, tag = "13")]
        pub usage: ::core::option::Option<job::Usage>,
        /// Quality metrics for this job's call. Unset when the job produced none.
        #[prost(message, optional, tag = "14")]
        pub metrics: ::core::option::Option<JobMetrics>,
        /// The Scenario.id this job ran; empty for generated runs. Every sample
        /// of one scenario shares it, so a run's jobs group back into scenarios.
        #[prost(string, tag = "15")]
        pub scenario_id: ::prost::alloc::string::String,
        /// 1-based sample of that scenario within the run; always 1 when the run's
        /// samples is 1.
        #[prost(int32, tag = "16")]
        pub sample: i32,
        /// Set on a failed job whose cause is known; error stays the detail.
        #[prost(enumeration = "job::FailureReason", tag = "19")]
        pub failure_reason: i32,
    }
    /// Nested message and enum types in `Job`.
    pub mod job {
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Usage {
            #[prost(int32, tag = "1")]
            pub text_turns_count: i32,
            #[prost(int32, tag = "2")]
            pub audio_turns_count: i32,
        }
        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
        #[repr(i32)]
        pub enum Status {
            Pending = 0,
            Running = 1,
            Completed = 2,
            Failed = 3,
            Cancelled = 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::Pending => "STATUS_PENDING",
                    Self::Running => "STATUS_RUNNING",
                    Self::Completed => "STATUS_COMPLETED",
                    Self::Failed => "STATUS_FAILED",
                    Self::Cancelled => "STATUS_CANCELLED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "STATUS_PENDING" => Some(Self::Pending),
                    "STATUS_RUNNING" => Some(Self::Running),
                    "STATUS_COMPLETED" => Some(Self::Completed),
                    "STATUS_FAILED" => Some(Self::Failed),
                    "STATUS_CANCELLED" => Some(Self::Cancelled),
                    _ => None,
                }
            }
        }
        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
        #[repr(i32)]
        pub enum FailureReason {
            Unspecified = 0,
            /// The agent under test never joined the simulation's room.
            AgentJoinTimeout = 1,
        }
        impl FailureReason {
            /// 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 => "FAILURE_REASON_UNSPECIFIED",
                    Self::AgentJoinTimeout => "FAILURE_REASON_AGENT_JOIN_TIMEOUT",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "FAILURE_REASON_UNSPECIFIED" => Some(Self::Unspecified),
                    "FAILURE_REASON_AGENT_JOIN_TIMEOUT" => Some(Self::AgentJoinTimeout),
                    _ => None,
                }
            }
        }
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct JobMetrics {
        /// the scenario verdict as 1/0
        #[prost(float, optional, tag = "3")]
        pub task_completion: ::core::option::Option<f32>,
        /// weighted mean of the judged and heard scores
        #[prost(float, optional, tag = "20")]
        pub overall_score: ::core::option::Option<f32>,
        #[prost(message, optional, tag = "4")]
        pub stt: ::core::option::Option<job_metrics::Stt>,
        #[prost(message, optional, tag = "5")]
        pub llm: ::core::option::Option<job_metrics::Llm>,
        #[prost(message, optional, tag = "6")]
        pub tts: ::core::option::Option<job_metrics::Tts>,
        #[prost(message, optional, tag = "7")]
        pub conversation: ::core::option::Option<job_metrics::Conversation>,
        /// One entry per turn, both speakers.
        #[prost(message, repeated, tag = "9")]
        pub turns: ::prost::alloc::vec::Vec<job_metrics::Turn>,
        /// text judge for judged scores; "" if none ran
        #[prost(string, tag = "10")]
        pub judge_model: ::prost::alloc::string::String,
        /// false = waveform-only capture (e.g. SIP)
        #[prost(bool, tag = "12")]
        pub has_remote_session: bool,
        /// audio only; call start (first speech edge); turn times relative to it
        #[prost(message, optional, tag = "13")]
        pub t0: ::core::option::Option<::pbjson_types::Timestamp>,
        /// Judged over the authored dialog (text and audio); needs the text judge.
        ///
        /// judged {0, 0.5, 1} per agent turn; job = mean
        #[prost(float, optional, tag = "14")]
        pub conciseness: ::core::option::Option<f32>,
        /// Whole-call issue flags; true = present, absent = not judged.
        #[prost(bool, optional, tag = "15")]
        pub unnecessary_tool_calls: ::core::option::Option<bool>,
        #[prost(bool, optional, tag = "16")]
        pub information_loss: ::core::option::Option<bool>,
        #[prost(bool, optional, tag = "17")]
        pub redundant_statements: ::core::option::Option<bool>,
        #[prost(bool, optional, tag = "18")]
        pub poor_question_quality: ::core::option::Option<bool>,
        /// 0-1, derived from the flags above
        #[prost(float, optional, tag = "19")]
        pub conversation_progression: ::core::option::Option<f32>,
        /// How the call ended. A failing end also sets the job's error.
        #[prost(enumeration = "job_metrics::EndReason", tag = "21")]
        pub end_reason: i32,
        /// The simulated caller's language, as a language tag: what it spoke or wrote.
        #[prost(string, tag = "22")]
        pub caller_language: ::prost::alloc::string::String,
        /// Audio only: the language the caller transcribed the agent in; "" means
        /// caller_language.
        #[prost(string, tag = "23")]
        pub caller_listen_language: ::prost::alloc::string::String,
        /// Audio only: what the caller's audio went through before the agent heard
        /// it. Absent for a clean call.
        #[prost(message, optional, tag = "24")]
        pub impairments: ::core::option::Option<super::SimulationImpairments>,
    }
    /// Nested message and enum types in `JobMetrics`.
    pub mod job_metrics {
        /// The agent's perception of the caller. Audio only.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct Stt {
            /// needs the RemoteSession; word_errors / words
            #[prost(float, optional, tag = "1")]
            pub wer: ::core::option::Option<f32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "2")]
            pub words: ::core::option::Option<u32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "3")]
            pub word_errors: ::core::option::Option<u32>,
            /// needs the RemoteSession; char_errors / chars
            #[prost(float, optional, tag = "4")]
            pub cer: ::core::option::Option<f32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "9")]
            pub chars: ::core::option::Option<u32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "10")]
            pub char_errors: ::core::option::Option<u32>,
            /// needs the RemoteSession; agent-reported STT/endpointing delay
            #[prost(uint32, optional, tag = "8")]
            pub stt_delay_ms: ::core::option::Option<u32>,
            /// Key entities (names, IDs, amounts) the caller said. Needs the text judge.
            ///
            /// recognized / uttered
            #[prost(float, optional, tag = "11")]
            pub entity_recognition: ::core::option::Option<f32>,
            #[prost(uint32, optional, tag = "12")]
            pub entities_uttered: ::core::option::Option<u32>,
            #[prost(uint32, optional, tag = "13")]
            pub entities_recognized: ::core::option::Option<u32>,
            /// Retention: an entity is acquired at the first saying heard right, and
            /// these count only the sayings after that, so recall separates keeping an
            /// entity from ever getting it.
            ///
            /// acquired_recognized / acquired_uttered
            #[prost(float, optional, tag = "14")]
            pub entity_recall: ::core::option::Option<f32>,
            #[prost(uint32, optional, tag = "15")]
            pub entities_acquired_uttered: ::core::option::Option<u32>,
            #[prost(uint32, optional, tag = "16")]
            pub entities_acquired_recognized: ::core::option::Option<u32>,
        }
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct Llm {
            /// needs the RemoteSession; time to first token
            #[prost(uint32, optional, tag = "1")]
            pub ttft_ms: ::core::option::Option<u32>,
            /// needs the RemoteSession; time to first sentence, the smallest speakable unit
            #[prost(uint32, optional, tag = "2")]
            pub ttfs_ms: ::core::option::Option<u32>,
            /// needs the RemoteSession
            #[prost(float, optional, tag = "3")]
            pub tokens_per_second: ::core::option::Option<f32>,
        }
        /// The agent's voice. Audio only.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct Tts {
            /// needs the RemoteSession; provider byte-level TTFB
            #[prost(uint32, optional, tag = "2")]
            pub ttfb_ms: ::core::option::Option<u32>,
            /// needs the RemoteSession; word_errors / words
            #[prost(float, optional, tag = "3")]
            pub wer: ::core::option::Option<f32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "7")]
            pub words: ::core::option::Option<u32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "8")]
            pub word_errors: ::core::option::Option<u32>,
            /// needs the RemoteSession; char_errors / chars
            #[prost(float, optional, tag = "9")]
            pub cer: ::core::option::Option<f32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "10")]
            pub chars: ::core::option::Option<u32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "11")]
            pub char_errors: ::core::option::Option<u32>,
            /// Key entities the agent said, as the caller heard them. Needs the text judge.
            ///
            /// recognized / uttered
            #[prost(float, optional, tag = "14")]
            pub entity_recognition: ::core::option::Option<f32>,
            #[prost(uint32, optional, tag = "15")]
            pub entities_uttered: ::core::option::Option<u32>,
            #[prost(uint32, optional, tag = "16")]
            pub entities_recognized: ::core::option::Option<u32>,
            /// acquired_recognized / acquired_uttered
            #[prost(float, optional, tag = "17")]
            pub entity_recall: ::core::option::Option<f32>,
            #[prost(uint32, optional, tag = "18")]
            pub entities_acquired_uttered: ::core::option::Option<u32>,
            #[prost(uint32, optional, tag = "19")]
            pub entities_acquired_recognized: ::core::option::Option<u32>,
        }
        /// Audio only.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct Conversation {
            /// 0-1
            #[prost(float, optional, tag = "1")]
            pub turn_taking_score: ::core::option::Option<f32>,
            /// floor-transfer offset; a gap is > 0, an overlap < 0
            #[prost(int32, optional, tag = "2")]
            pub heard_e2e_latency_p50_ms: ::core::option::Option<i32>,
            #[prost(int32, optional, tag = "3")]
            pub heard_e2e_latency_p95_ms: ::core::option::Option<i32>,
            #[prost(int32, optional, tag = "4")]
            pub heard_e2e_latency_p99_ms: ::core::option::Option<i32>,
            /// agent audio continuing past a barge-in
            #[prost(uint32, optional, tag = "5")]
            pub time_to_yield_ms: ::core::option::Option<u32>,
            /// agent started before the caller's turn ended
            #[prost(uint32, optional, tag = "6")]
            pub eot_misprediction_count: ::core::option::Option<u32>,
            /// overlapping speech / total speech
            #[prost(float, optional, tag = "7")]
            pub overlap_ratio: ::core::option::Option<f32>,
            /// pooling stats for overlap_ratio
            #[prost(uint32, optional, tag = "8")]
            pub overlap_speech_ms: ::core::option::Option<u32>,
            #[prost(uint32, optional, tag = "9")]
            pub total_speech_ms: ::core::option::Option<u32>,
            /// gaps past the natural-pause threshold
            #[prost(uint32, optional, tag = "11")]
            pub awkward_silence_count: ::core::option::Option<u32>,
            /// the simulated party spoke, the agent never responded
            #[prost(uint32, optional, tag = "12")]
            pub unanswered_turns: ::core::option::Option<u32>,
            /// needs the RemoteSession; agent paused for a non-interruption
            #[prost(uint32, optional, tag = "13")]
            pub false_interruption_count: ::core::option::Option<u32>,
            /// needs the RemoteSession; the agent's own claim
            #[prost(uint32, optional, tag = "15")]
            pub e2e_latency_ms: ::core::option::Option<u32>,
            /// the caller's acknowledgements over the agent's speech
            #[prost(uint32, optional, tag = "16")]
            pub backchannel_count: ::core::option::Option<u32>,
        }
        /// Rows exist for text and audio. The groups above hold the means and pools
        /// over these; anything not measured for a turn stays unset.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Turn {
            /// 1-based, conversation order
            #[prost(uint32, tag = "1")]
            pub index: u32,
            /// ASSISTANT = the agent under test, USER = simulator persona
            #[prost(enumeration = "super::super::agent::ChatRole", tag = "2")]
            pub role: i32,
            /// The words the judges read for this turn: the speaker's own, or as the
            /// other side heard them when those are unknown (the agent's, without a
            /// RemoteSession).
            #[prost(string, tag = "18")]
            pub text: ::prost::alloc::string::String,
            /// audio only; relative to t0; unset if the turn could not be aligned to the audio
            #[prost(uint32, optional, tag = "3")]
            pub start_ms: ::core::option::Option<u32>,
            /// audio only
            #[prost(uint32, optional, tag = "4")]
            pub end_ms: ::core::option::Option<u32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "5")]
            pub stt_delay_ms: ::core::option::Option<u32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "6")]
            pub llm_ttft_ms: ::core::option::Option<u32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "7")]
            pub llm_ttfs_ms: ::core::option::Option<u32>,
            /// needs the RemoteSession
            #[prost(float, optional, tag = "8")]
            pub llm_tps: ::core::option::Option<f32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "9")]
            pub tts_ttfb_ms: ::core::option::Option<u32>,
            /// needs the RemoteSession
            #[prost(uint32, optional, tag = "10")]
            pub e2e_latency_ms: ::core::option::Option<u32>,
            #[prost(int32, optional, tag = "11")]
            pub heard_e2e_latency_ms: ::core::option::Option<i32>,
            #[prost(uint32, optional, tag = "12")]
            pub time_to_yield_ms: ::core::option::Option<u32>,
            #[prost(float, optional, tag = "13")]
            pub turn_taking_score: ::core::option::Option<f32>,
            /// needs the text judge
            #[prost(float, optional, tag = "14")]
            pub conciseness: ::core::option::Option<f32>,
            #[prost(bool, optional, tag = "15")]
            pub eot_misprediction: ::core::option::Option<bool>,
            #[prost(bool, optional, tag = "16")]
            pub awkward_silence: ::core::option::Option<bool>,
            #[prost(bool, optional, tag = "17")]
            pub unanswered: ::core::option::Option<bool>,
            /// Audio only; needs the text judge. One per saying of a key entity in
            /// this turn, in order, as the other side heard it. Matched over the whole
            /// call's transcript, so a saying spanning turns sits on its first, and
            /// which of an entity's repeated sayings was heard is the alignment's
            /// best guess.
            #[prost(message, repeated, tag = "19")]
            pub entities: ::prost::alloc::vec::Vec<turn::Entity>,
            /// the agent's chat item id for the first message this turn holds, as its
            /// stored transcript carries it; "" without a RemoteSession
            #[prost(string, tag = "20")]
            pub item_id: ::prost::alloc::string::String,
        }
        /// Nested message and enum types in `Turn`.
        pub mod turn {
            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
            pub struct Entity {
                /// the entity as the speaker said it
                #[prost(string, tag = "1")]
                pub said: ::prost::alloc::string::String,
                /// the listener's normalized words where it landed; "" if dropped
                #[prost(string, tag = "2")]
                pub heard: ::prost::alloc::string::String,
                /// heard with no word errors
                #[prost(bool, tag = "3")]
                pub recognized: bool,
            }
        }
        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
        #[repr(i32)]
        pub enum EndReason {
            Unspecified = 0,
            /// the caller finished the scenario
            ScenarioCompleted = 1,
            /// the agent under test ended the call
            AgentEnded = 2,
            /// the agent under test went silent
            Inactivity = 3,
            /// the caller ran out of turns
            TurnLimit = 4,
            /// the agent under test kept replying with nothing
            EmptyResponse = 5,
            /// the agent under test failed mid-call
            AgentError = 6,
        }
        impl EndReason {
            /// 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 => "END_REASON_UNSPECIFIED",
                    Self::ScenarioCompleted => "END_REASON_SCENARIO_COMPLETED",
                    Self::AgentEnded => "END_REASON_AGENT_ENDED",
                    Self::Inactivity => "END_REASON_INACTIVITY",
                    Self::TurnLimit => "END_REASON_TURN_LIMIT",
                    Self::EmptyResponse => "END_REASON_EMPTY_RESPONSE",
                    Self::AgentError => "END_REASON_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 {
                    "END_REASON_UNSPECIFIED" => Some(Self::Unspecified),
                    "END_REASON_SCENARIO_COMPLETED" => Some(Self::ScenarioCompleted),
                    "END_REASON_AGENT_ENDED" => Some(Self::AgentEnded),
                    "END_REASON_INACTIVITY" => Some(Self::Inactivity),
                    "END_REASON_TURN_LIMIT" => Some(Self::TurnLimit),
                    "END_REASON_EMPTY_RESPONSE" => Some(Self::EmptyResponse),
                    "END_REASON_AGENT_ERROR" => Some(Self::AgentError),
                    _ => None,
                }
            }
        }
    }
    /// Aggregates over this run's jobs, so a run summary does not have to pull
    /// every job and turn. Reuses the JobMetrics group shapes.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct RunMetrics {
        /// share of jobs whose scenario verdict passed
        #[prost(float, optional, tag = "3")]
        pub scenario_pass_rate: ::core::option::Option<f32>,
        /// mean over scored jobs
        #[prost(float, optional, tag = "10")]
        pub overall_score: ::core::option::Option<f32>,
        #[prost(message, optional, tag = "4")]
        pub stt: ::core::option::Option<job_metrics::Stt>,
        #[prost(message, optional, tag = "5")]
        pub llm: ::core::option::Option<job_metrics::Llm>,
        #[prost(message, optional, tag = "6")]
        pub tts: ::core::option::Option<job_metrics::Tts>,
        #[prost(message, optional, tag = "7")]
        pub conversation: ::core::option::Option<job_metrics::Conversation>,
        /// Means over the jobs that report them.
        #[prost(float, optional, tag = "8")]
        pub conciseness: ::core::option::Option<f32>,
        #[prost(float, optional, tag = "9")]
        pub conversation_progression: ::core::option::Option<f32>,
    }
    /// The pipeline this run came from. Set by the client from its CI
    /// environment; absent for runs not started by a pipeline.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Ci {
        /// e.g. "github_actions"
        #[prost(string, tag = "1")]
        pub provider: ::prost::alloc::string::String,
        #[prost(string, tag = "2")]
        pub commit_sha: ::prost::alloc::string::String,
        /// branch or tag
        #[prost(string, tag = "3")]
        pub r#ref: ::prost::alloc::string::String,
        #[prost(string, tag = "4")]
        pub pull_request: ::prost::alloc::string::String,
        /// link back to the CI job
        #[prost(string, tag = "5")]
        pub run_url: ::prost::alloc::string::String,
        #[prost(string, tag = "6")]
        pub actor: ::prost::alloc::string::String,
    }
    /// Runs each scenario more than once, so a flaky sample is distinguishable
    /// from a broken scenario. Both fields are required when it is present.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SamplingOptions {
        /// Samples per scenario, > 1. The run holds scenarios × samples jobs,
        /// subject to the usual job cap.
        #[prost(int32, tag = "1")]
        pub samples: i32,
        /// The share of a scenario's samples that must pass for that scenario to
        /// pass, 0-1. A scenario needs round(rate × samples) of them, so 1
        /// requires every sample and 0.67 of 3 requires 2.
        #[prost(double, tag = "2")]
        pub pass_rate: f64,
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Create {
    }
    /// Nested message and enum types in `Create`.
    pub mod create {
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Request {
            #[prost(string, tag = "1")]
            pub project_id: ::prost::alloc::string::String,
            #[prost(string, tag = "2")]
            pub agent_name: ::prost::alloc::string::String,
            #[prost(int32, tag = "4")]
            pub num_simulations: i32,
            #[prost(string, tag = "6")]
            pub region: ::prost::alloc::string::String,
            /// When set, run these scenarios (loaded from a scenarios.yaml).
            /// When unset, generate num_simulations scenarios from the uploaded agent source.
            #[prost(message, optional, tag = "7")]
            pub scenario_group: ::core::option::Option<super::super::ScenarioGroup>,
            /// Maximum simulate jobs running in parallel for this run. Clamped to the
            /// project's concurrency quota; 0/unset uses the server default.
            #[prost(int32, optional, tag = "8")]
            pub concurrency: ::core::option::Option<i32>,
            /// Conversation mode for every job in this run; unspecified = TEXT.
            #[prost(enumeration = "super::super::SimulationMode", tag = "9")]
            pub mode: i32,
            /// Impairments applied to the simulated user's audio; AUDIO mode only.
            /// TODO(u9g): migrate these to SimulationImpairments.
            #[prost(bool, tag = "10")]
            pub background_noise: bool,
            #[prost(bool, tag = "11")]
            pub low_quality_microphone: bool,
            #[prost(bool, tag = "12")]
            pub packet_loss: bool,
            #[prost(message, optional, tag = "13")]
            pub ci: ::core::option::Option<super::Ci>,
            /// Absent runs each scenario once and requires it to pass. Requires
            /// scenario_group. The run fails if any scenario fails; pass@k and
            /// pass^k report over scenarios and neither gates.
            #[prost(message, optional, tag = "14")]
            pub sampling: ::core::option::Option<super::SamplingOptions>,
            /// When set, every job dials this number over SIP instead of dispatching
            /// agent_name, as CreateSIPParticipantRequest would. AUDIO mode only.
            #[prost(string, tag = "15")]
            pub sip_call_to: ::prost::alloc::string::String,
            /// Outbound trunk to dial through. Empty dials from sip_number, which must
            /// then be a LiveKit phone number the project owns.
            #[prost(string, tag = "16")]
            pub sip_trunk_id: ::prost::alloc::string::String,
            #[prost(string, tag = "17")]
            pub sip_number: ::prost::alloc::string::String,
            /// Named deployment of agent_name to dispatch to; empty is production.
            #[prost(string, tag = "18")]
            pub deployment: ::prost::alloc::string::String,
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Response {
            #[prost(string, tag = "1")]
            pub simulation_run_id: ::prost::alloc::string::String,
            #[prost(message, optional, tag = "2")]
            pub presigned_post_request: ::core::option::Option<super::super::PresignedPostRequest>,
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ConfirmSourceUpload {
    }
    /// Nested message and enum types in `ConfirmSourceUpload`.
    pub mod confirm_source_upload {
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Request {
            #[prost(string, tag = "1")]
            pub project_id: ::prost::alloc::string::String,
            #[prost(string, tag = "2")]
            pub simulation_run_id: ::prost::alloc::string::String,
            #[prost(string, tag = "3")]
            pub code_entrypoint: ::prost::alloc::string::String,
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Response {
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Get {
    }
    /// Nested message and enum types in `Get`.
    pub mod get {
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Request {
            #[prost(string, tag = "1")]
            pub project_id: ::prost::alloc::string::String,
            #[prost(string, tag = "2")]
            pub simulation_run_id: ::prost::alloc::string::String,
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Response {
            #[prost(message, optional, tag = "1")]
            pub run: ::core::option::Option<super::super::SimulationRun>,
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct List {
    }
    /// Nested message and enum types in `List`.
    pub mod list {
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Request {
            #[prost(string, tag = "1")]
            pub project_id: ::prost::alloc::string::String,
            #[prost(enumeration = "super::Status", optional, tag = "2")]
            pub status: ::core::option::Option<i32>,
            #[prost(message, optional, tag = "3")]
            pub page_token: ::core::option::Option<super::super::TokenPagination>,
            /// Half-open window [start_time, end_time) on created_at, the leading key
            /// of this list's keyset. Unset bounds mean no window, so existing callers
            /// keep their unbounded scan; the histogram's selected range sets both.
            #[prost(message, optional, tag = "4")]
            pub start_time: ::core::option::Option<::pbjson_types::Timestamp>,
            #[prost(message, optional, tag = "5")]
            pub end_time: ::core::option::Option<::pbjson_types::Timestamp>,
            /// Exact agent name. Unset means every agent — including the runs whose
            /// name is empty, which a bare string could not tell from no filter.
            #[prost(string, optional, tag = "6")]
            pub agent_name: ::core::option::Option<::prost::alloc::string::String>,
            /// Absent applies no mode filter. TEXT matches runs stored as TEXT or
            /// UNSPECIFIED, which `SimulationRun.mode` defines as the same mode.
            #[prost(enumeration = "super::super::SimulationMode", optional, tag = "7")]
            pub mode: ::core::option::Option<i32>,
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Response {
            #[prost(message, repeated, tag = "1")]
            pub runs: ::prost::alloc::vec::Vec<super::super::SimulationRun>,
            #[prost(message, optional, tag = "2")]
            pub next_page_token: ::core::option::Option<super::super::TokenPagination>,
        }
    }
    /// Counts of the runs `List` would return over the same window, bucketed by
    /// created_at instead of paginated.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Counts {
    }
    /// Nested message and enum types in `Counts`.
    pub mod counts {
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Request {
            #[prost(string, tag = "1")]
            pub project_id: ::prost::alloc::string::String,
            /// Both bounds required: a bucketed scan of a project's whole history is
            /// never what a caller wants.
            #[prost(message, optional, tag = "2")]
            pub start_time: ::core::option::Option<::pbjson_types::Timestamp>,
            #[prost(message, optional, tag = "3")]
            pub end_time: ::core::option::Option<::pbjson_types::Timestamp>,
            /// Applied as `List` applies it: a filter the rows honour and the bars
            /// above them drop would make the histogram an answer about a wider set.
            #[prost(enumeration = "super::Status", optional, tag = "4")]
            pub status: ::core::option::Option<i32>,
            #[prost(string, optional, tag = "5")]
            pub agent_name: ::core::option::Option<::prost::alloc::string::String>,
            #[prost(enumeration = "super::super::SimulationMode", optional, tag = "6")]
            pub mode: ::core::option::Option<i32>,
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Response {
            /// Buckets holding at least one run, ascending by bucket_start. Empty
            /// buckets are omitted; each run lands in exactly one bucket, so the
            /// counts sum to the number of runs in the window.
            #[prost(message, repeated, tag = "1")]
            pub buckets: ::prost::alloc::vec::Vec<Bucket>,
            /// The bucket width the server chose from the window, so the client
            /// zero-fills the omitted buckets on the grid the counts were built on.
            #[prost(message, optional, tag = "2")]
            pub interval: ::core::option::Option<::pbjson_types::Duration>,
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Bucket {
            #[prost(message, optional, tag = "1")]
            pub bucket_start: ::core::option::Option<::pbjson_types::Timestamp>,
            #[prost(uint64, tag = "2")]
            pub count: u64,
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Cancel {
    }
    /// Nested message and enum types in `Cancel`.
    pub mod cancel {
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Request {
            #[prost(string, tag = "1")]
            pub project_id: ::prost::alloc::string::String,
            #[prost(string, tag = "2")]
            pub simulation_run_id: ::prost::alloc::string::String,
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Response {
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Usage {
        #[prost(int32, tag = "1")]
        pub text_turns_count: i32,
        #[prost(int32, tag = "2")]
        pub audio_turns_count: i32,
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Status {
        PendingUpload = 0,
        Generating = 1,
        Running = 2,
        Summarizing = 3,
        Completed = 4,
        Failed = 5,
        Cancelled = 6,
    }
    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::PendingUpload => "STATUS_PENDING_UPLOAD",
                Self::Generating => "STATUS_GENERATING",
                Self::Running => "STATUS_RUNNING",
                Self::Summarizing => "STATUS_SUMMARIZING",
                Self::Completed => "STATUS_COMPLETED",
                Self::Failed => "STATUS_FAILED",
                Self::Cancelled => "STATUS_CANCELLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_PENDING_UPLOAD" => Some(Self::PendingUpload),
                "STATUS_GENERATING" => Some(Self::Generating),
                "STATUS_RUNNING" => Some(Self::Running),
                "STATUS_SUMMARIZING" => Some(Self::Summarizing),
                "STATUS_COMPLETED" => Some(Self::Completed),
                "STATUS_FAILED" => Some(Self::Failed),
                "STATUS_CANCELLED" => Some(Self::Cancelled),
                _ => None,
            }
        }
    }
}
/// A single scenario, mirroring one entry in a scenarios.yaml file. Scenarios
/// are no longer stored server-side; the yaml file is the source of truth.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Scenario {
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub instructions: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub agent_expectations: ::prost::alloc::string::String,
    /// Surfaced to the agent under test as SimulationContext scenario tags.
    #[prost(map = "string, string", tag = "4")]
    pub tags: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Arbitrary JSON-encoded object, surfaced to the agent under test as
    /// SimulationContext userdata (e.g. inputs and benchmark target state).
    #[prost(string, tag = "5")]
    pub userdata: ::prost::alloc::string::String,
    /// SCN_-prefixed guid. Stable across edits to label, instructions, or
    /// expectations, so runs of the same scenario can be correlated over time.
    #[prost(string, tag = "6")]
    pub id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Scenario`.
pub mod scenario {
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct CreateFromSession {
    }
    /// Nested message and enum types in `CreateFromSession`.
    pub mod create_from_session {
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Request {
            #[prost(string, tag = "1")]
            pub project_id: ::prost::alloc::string::String,
            #[prost(string, tag = "2")]
            pub room_id: ::prost::alloc::string::String,
            #[prost(string, tag = "3")]
            pub region: ::prost::alloc::string::String,
        }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Response {
            #[prost(message, optional, tag = "1")]
            pub scenario: ::core::option::Option<super::super::Scenario>,
        }
    }
}
/// A named group of scenarios, mirroring a whole scenarios.yaml file.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScenarioGroup {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub scenarios: ::prost::alloc::vec::Vec<Scenario>,
    /// SCNG_-prefixed guid. Stable identity of the scenarios file, independent
    /// of its name.
    #[prost(string, tag = "3")]
    pub id: ::prost::alloc::string::String,
}
/// What the simulated caller's audio went through before the agent heard it.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SimulationImpairments {
    #[prost(bool, tag = "1")]
    pub background_noise: bool,
    #[prost(bool, tag = "2")]
    pub low_quality_microphone: bool,
    #[prost(bool, tag = "3")]
    pub packet_loss: bool,
}
/// Carried (protojson-encoded) in the Job's lk.simulator.dispatch attribute, set
/// on the agent dispatch, so the agent under test can read the scenario + run
/// identity synchronously at job start.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SimulationDispatch {
    #[prost(string, tag = "1")]
    pub simulation_run_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub job_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub scenario: ::core::option::Option<Scenario>,
    #[prost(enumeration = "SimulationMode", tag = "4")]
    pub mode: i32,
}
/// How the simulated user interacts with the agent under test.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SimulationMode {
    Unspecified = 0,
    /// The simulator chats over text streams (no audio).
    Text = 1,
    /// The simulator publishes/subscribes audio in the room.
    Audio = 2,
}
impl SimulationMode {
    /// 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 => "SIMULATION_MODE_UNSPECIFIED",
            Self::Text => "SIMULATION_MODE_TEXT",
            Self::Audio => "SIMULATION_MODE_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 {
            "SIMULATION_MODE_UNSPECIFIED" => Some(Self::Unspecified),
            "SIMULATION_MODE_TEXT" => Some(Self::Text),
            "SIMULATION_MODE_AUDIO" => Some(Self::Audio),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkerInfo {
    #[prost(string, tag = "1")]
    pub worker_type: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub agent_name: ::prost::alloc::string::String,
    #[prost(float, tag = "3")]
    pub active_jobs: f32,
    #[prost(string, tag = "4")]
    pub sdk_version: ::prost::alloc::string::String,
    #[prost(float, tag = "5")]
    pub worker_load: f32,
    #[prost(int32, tag = "6")]
    pub protocol_version: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Node {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub ip: ::prost::alloc::string::String,
    #[prost(uint32, tag = "3")]
    pub num_cpus: u32,
    #[prost(message, optional, tag = "4")]
    pub stats: ::core::option::Option<NodeStats>,
    #[prost(enumeration = "NodeType", tag = "5")]
    pub r#type: i32,
    #[prost(enumeration = "NodeState", tag = "6")]
    pub state: i32,
    #[prost(string, tag = "7")]
    pub region: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NodeStats {
    /// when server was started
    #[prost(int64, tag = "1")]
    pub started_at: i64,
    /// when server last reported its status
    #[prost(int64, tag = "2")]
    pub updated_at: i64,
    /// room
    #[prost(int32, tag = "3")]
    pub num_rooms: i32,
    #[prost(int32, tag = "4")]
    pub num_clients: i32,
    #[prost(int32, tag = "5")]
    pub num_tracks_in: i32,
    #[prost(int32, tag = "6")]
    pub num_tracks_out: i32,
    #[prost(int32, tag = "36")]
    pub num_track_publish_attempts: i32,
    #[deprecated]
    #[prost(float, tag = "37")]
    pub track_publish_attempts_per_sec: f32,
    #[prost(int32, tag = "38")]
    pub num_track_publish_success: i32,
    #[deprecated]
    #[prost(float, tag = "39")]
    pub track_publish_success_per_sec: f32,
    #[prost(int32, tag = "51")]
    pub num_track_publish_cancels: i32,
    #[prost(int32, tag = "40")]
    pub num_track_subscribe_attempts: i32,
    #[deprecated]
    #[prost(float, tag = "41")]
    pub track_subscribe_attempts_per_sec: f32,
    #[prost(int32, tag = "42")]
    pub num_track_subscribe_success: i32,
    #[deprecated]
    #[prost(float, tag = "43")]
    pub track_subscribe_success_per_sec: f32,
    #[prost(int32, tag = "52")]
    pub num_track_subscribe_cancels: i32,
    /// packet
    #[prost(uint64, tag = "7")]
    pub bytes_in: u64,
    #[prost(uint64, tag = "8")]
    pub bytes_out: u64,
    #[prost(uint64, tag = "9")]
    pub packets_in: u64,
    #[prost(uint64, tag = "10")]
    pub packets_out: u64,
    #[prost(uint64, tag = "11")]
    pub nack_total: u64,
    #[deprecated]
    #[prost(float, tag = "12")]
    pub bytes_in_per_sec: f32,
    #[deprecated]
    #[prost(float, tag = "13")]
    pub bytes_out_per_sec: f32,
    #[prost(float, tag = "14")]
    pub packets_in_per_sec: f32,
    #[deprecated]
    #[prost(float, tag = "15")]
    pub packets_out_per_sec: f32,
    #[deprecated]
    #[prost(float, tag = "16")]
    pub nack_per_sec: f32,
    /// system
    #[prost(uint32, tag = "17")]
    pub num_cpus: u32,
    #[prost(float, tag = "18")]
    pub load_avg_last1min: f32,
    #[prost(float, tag = "19")]
    pub load_avg_last5min: f32,
    #[prost(float, tag = "20")]
    pub load_avg_last15min: f32,
    #[prost(float, tag = "21")]
    pub cpu_load: f32,
    #[deprecated]
    #[prost(float, tag = "33")]
    pub memory_load: f32,
    #[prost(uint64, tag = "34")]
    pub memory_total: u64,
    #[prost(uint64, tag = "35")]
    pub memory_used: u64,
    #[prost(uint32, tag = "28")]
    pub sys_packets_out: u32,
    #[prost(uint32, tag = "29")]
    pub sys_packets_dropped: u32,
    #[deprecated]
    #[prost(float, tag = "30")]
    pub sys_packets_out_per_sec: f32,
    #[deprecated]
    #[prost(float, tag = "31")]
    pub sys_packets_dropped_per_sec: f32,
    #[deprecated]
    #[prost(float, tag = "32")]
    pub sys_packets_dropped_pct_per_sec: f32,
    /// retransmissions
    #[prost(uint64, tag = "22")]
    pub retransmit_bytes_out: u64,
    #[prost(uint64, tag = "23")]
    pub retransmit_packets_out: u64,
    #[deprecated]
    #[prost(float, tag = "24")]
    pub retransmit_bytes_out_per_sec: f32,
    #[deprecated]
    #[prost(float, tag = "25")]
    pub retransmit_packets_out_per_sec: f32,
    /// participant joins
    #[prost(uint64, tag = "26")]
    pub participant_signal_connected: u64,
    #[deprecated]
    #[prost(float, tag = "27")]
    pub participant_signal_connected_per_sec: f32,
    #[deprecated]
    #[prost(uint64, tag = "55")]
    pub participant_signal_failed: u64,
    #[deprecated]
    #[prost(uint64, tag = "56")]
    pub participant_signal_validation_failed: u64,
    #[prost(uint64, tag = "44")]
    pub participant_rtc_connected: u64,
    #[deprecated]
    #[prost(float, tag = "45")]
    pub participant_rtc_connected_per_sec: f32,
    #[prost(uint64, tag = "46")]
    pub participant_rtc_init: u64,
    #[deprecated]
    #[prost(float, tag = "47")]
    pub participant_rtc_init_per_sec: f32,
    #[prost(uint64, tag = "53")]
    pub participant_rtc_canceled: u64,
    #[prost(uint64, tag = "54")]
    pub participant_rtc_active: u64,
    /// forward metrics
    #[prost(uint32, tag = "48")]
    pub forward_latency: u32,
    #[deprecated]
    #[prost(uint32, tag = "49")]
    pub forward_jitter: u32,
    /// mean forwarding work per write to a subscriber, in ns: (end of fan-out - dequeue) / writes
    #[prost(uint32, tag = "57")]
    pub forward_processing_per_write: u32,
    #[prost(message, repeated, tag = "50")]
    pub rates: ::prost::alloc::vec::Vec<NodeStatsRate>,
}
/// rates of different node stats (per second)
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct NodeStatsRate {
    #[prost(int64, tag = "1")]
    pub started_at: i64,
    #[prost(int64, tag = "2")]
    pub ended_at: i64,
    #[prost(int64, tag = "3")]
    pub duration: i64,
    #[prost(float, tag = "4")]
    pub track_publish_attempts: f32,
    #[prost(float, tag = "5")]
    pub track_publish_success: f32,
    #[prost(float, tag = "24")]
    pub track_publish_cancels: f32,
    #[prost(float, tag = "6")]
    pub track_subscribe_attempts: f32,
    #[prost(float, tag = "7")]
    pub track_subscribe_success: f32,
    #[prost(float, tag = "25")]
    pub track_subscribe_cancels: f32,
    #[prost(float, tag = "8")]
    pub bytes_in: f32,
    #[prost(float, tag = "9")]
    pub bytes_out: f32,
    #[prost(float, tag = "10")]
    pub packets_in: f32,
    #[prost(float, tag = "11")]
    pub packets_out: f32,
    #[prost(float, tag = "12")]
    pub nack_total: f32,
    #[prost(float, tag = "13")]
    pub sys_packets_out: f32,
    #[prost(float, tag = "14")]
    pub sys_packets_dropped: f32,
    #[prost(float, tag = "15")]
    pub retransmit_bytes_out: f32,
    #[prost(float, tag = "16")]
    pub retransmit_packets_out: f32,
    #[prost(float, tag = "17")]
    pub participant_signal_connected: f32,
    #[prost(float, tag = "28")]
    pub participant_signal_failed: f32,
    #[prost(float, tag = "29")]
    pub participant_signal_validation_failed: f32,
    #[prost(float, tag = "18")]
    pub participant_rtc_connected: f32,
    #[prost(float, tag = "19")]
    pub participant_rtc_init: f32,
    #[prost(float, tag = "26")]
    pub participant_rtc_canceled: f32,
    #[prost(float, tag = "27")]
    pub participant_rtc_active: f32,
    /// time weighted averages across stats windows forming part of a rate measurement interval
    #[prost(float, tag = "20")]
    pub cpu_load: f32,
    #[prost(float, tag = "21")]
    pub memory_load: f32,
    #[prost(float, tag = "22")]
    pub memory_used: f32,
    #[prost(float, tag = "23")]
    pub memory_total: f32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartSession {
    #[prost(string, tag = "1")]
    pub room_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub connection_id: ::prost::alloc::string::String,
    /// if a client is reconnecting (i.e. resume instead of restart)
    #[prost(bool, tag = "4")]
    pub reconnect: bool,
    #[prost(bool, tag = "9")]
    pub auto_subscribe: bool,
    #[prost(bool, optional, tag = "25")]
    pub auto_subscribe_data_track: ::core::option::Option<bool>,
    #[deprecated]
    #[prost(bool, tag = "10")]
    pub hidden: bool,
    #[prost(message, optional, tag = "11")]
    pub client: ::core::option::Option<ClientInfo>,
    #[deprecated]
    #[prost(bool, tag = "12")]
    pub recorder: bool,
    #[prost(string, tag = "13")]
    pub name: ::prost::alloc::string::String,
    /// A user's ClaimGrants serialized in JSON
    #[prost(string, tag = "14")]
    pub grants_json: ::prost::alloc::string::String,
    #[prost(bool, tag = "15")]
    pub adaptive_stream: bool,
    /// if reconnect, client will set current sid
    #[prost(string, tag = "16")]
    pub participant_id: ::prost::alloc::string::String,
    #[prost(enumeration = "ReconnectReason", tag = "17")]
    pub reconnect_reason: i32,
    #[prost(bool, optional, tag = "18")]
    pub subscriber_allow_pause: ::core::option::Option<bool>,
    #[prost(bool, tag = "19")]
    pub disable_ice_lite: bool,
    #[prost(message, optional, tag = "20")]
    pub create_room: ::core::option::Option<CreateRoomRequest>,
    #[prost(message, repeated, tag = "21")]
    pub add_track_requests: ::prost::alloc::vec::Vec<AddTrackRequest>,
    #[prost(message, optional, tag = "22")]
    pub publisher_offer: ::core::option::Option<SessionDescription>,
    #[prost(message, optional, tag = "23")]
    pub sync_state: ::core::option::Option<SyncState>,
    #[prost(bool, tag = "24")]
    pub use_single_peer_connection: bool,
    #[prost(int64, tag = "26")]
    pub token_expires_at: i64,
    /// API key that issued the join token, for correlating sessions with the key
    #[prost(string, tag = "27")]
    pub api_key: ::prost::alloc::string::String,
}
/// room info that should not be returned to clients
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoomInternal {
    #[prost(message, optional, tag = "1")]
    pub track_egress: ::core::option::Option<AutoTrackEgress>,
    #[prost(message, optional, tag = "2")]
    pub participant_egress: ::core::option::Option<AutoParticipantEgress>,
    #[prost(message, optional, tag = "3")]
    pub playout_delay: ::core::option::Option<PlayoutDelay>,
    #[prost(message, repeated, tag = "5")]
    pub agent_dispatches: ::prost::alloc::vec::Vec<RoomAgentDispatch>,
    #[prost(bool, tag = "4")]
    pub sync_streams: bool,
    #[prost(bool, tag = "6")]
    pub replay_enabled: bool,
    #[prost(bool, tag = "7")]
    pub export_room: bool,
    #[prost(map = "string, string", tag = "8")]
    pub tags: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct IceConfig {
    #[prost(enumeration = "IceCandidateType", tag = "1")]
    pub preference_subscriber: i32,
    #[prost(enumeration = "IceCandidateType", tag = "2")]
    pub preference_publisher: i32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum NodeType {
    Server = 0,
    Controller = 1,
    Media = 2,
    Turn = 4,
    Sweeper = 5,
    Director = 6,
    HostedAgent = 7,
    Settings = 8,
}
impl NodeType {
    /// 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::Server => "SERVER",
            Self::Controller => "CONTROLLER",
            Self::Media => "MEDIA",
            Self::Turn => "TURN",
            Self::Sweeper => "SWEEPER",
            Self::Director => "DIRECTOR",
            Self::HostedAgent => "HOSTED_AGENT",
            Self::Settings => "SETTINGS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SERVER" => Some(Self::Server),
            "CONTROLLER" => Some(Self::Controller),
            "MEDIA" => Some(Self::Media),
            "TURN" => Some(Self::Turn),
            "SWEEPER" => Some(Self::Sweeper),
            "DIRECTOR" => Some(Self::Director),
            "HOSTED_AGENT" => Some(Self::HostedAgent),
            "SETTINGS" => Some(Self::Settings),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum NodeState {
    StartingUp = 0,
    Serving = 1,
    ShuttingDown = 2,
    Suspended = 3,
}
impl NodeState {
    /// 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::StartingUp => "STARTING_UP",
            Self::Serving => "SERVING",
            Self::ShuttingDown => "SHUTTING_DOWN",
            Self::Suspended => "SUSPENDED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "STARTING_UP" => Some(Self::StartingUp),
            "SERVING" => Some(Self::Serving),
            "SHUTTING_DOWN" => Some(Self::ShuttingDown),
            "SUSPENDED" => Some(Self::Suspended),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IceCandidateType {
    IctNone = 0,
    IctTcp = 1,
    IctTls = 2,
}
impl IceCandidateType {
    /// 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::IctNone => "ICT_NONE",
            Self::IctTcp => "ICT_TCP",
            Self::IctTls => "ICT_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 {
            "ICT_NONE" => Some(Self::IctNone),
            "ICT_TCP" => Some(Self::IctTcp),
            "ICT_TLS" => Some(Self::IctTls),
            _ => None,
        }
    }
}
/// SearchPhoneNumbersRequest - Request to search available phone numbers
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SearchPhoneNumbersRequest {
    /// Filter by country code (e.g., "US", "CA")
    #[prost(string, tag = "1")]
    pub country_code: ::prost::alloc::string::String,
    /// Filter by area code (e.g., "415")
    #[prost(string, optional, tag = "2")]
    pub area_code: ::core::option::Option<::prost::alloc::string::String>,
    /// Maximum number of results (default: 50)
    #[prost(int32, optional, tag = "3")]
    pub limit: ::core::option::Option<i32>,
    /// Token for pagination (empty for first page)
    #[prost(message, optional, tag = "4")]
    pub page_token: ::core::option::Option<TokenPagination>,
}
/// SearchPhoneNumbersResponse - Response containing available phone numbers
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchPhoneNumbersResponse {
    /// List of available phone numbers
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<PhoneNumber>,
    /// Token for next page (empty if no more pages)
    #[prost(message, optional, tag = "2")]
    pub next_page_token: ::core::option::Option<TokenPagination>,
}
/// PurchasePhoneNumberRequest - Request to purchase phone numbers
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PurchasePhoneNumberRequest {
    /// Phone numbers to purchase (e.g., \["+1234567890", "+1234567891"\])
    #[prost(string, repeated, tag = "1")]
    pub phone_numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// SIP dispatch rule ID to apply to all purchased numbers
    #[prost(string, optional, tag = "2")]
    pub sip_dispatch_rule_id: ::core::option::Option<::prost::alloc::string::String>,
}
/// PurchasePhoneNumberResponse - Response containing the purchased phone numbers
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurchasePhoneNumberResponse {
    /// Details of the purchased phone numbers
    #[prost(message, repeated, tag = "1")]
    pub phone_numbers: ::prost::alloc::vec::Vec<PhoneNumber>,
}
/// ListPhoneNumbersRequest - Request to list phone numbers
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListPhoneNumbersRequest {
    /// Maximum number of results (default: 50)
    #[prost(int32, optional, tag = "1")]
    pub limit: ::core::option::Option<i32>,
    /// Filter by statuses (active, pending, released)
    #[prost(enumeration = "PhoneNumberStatus", repeated, tag = "2")]
    pub statuses: ::prost::alloc::vec::Vec<i32>,
    /// Token for pagination (empty for first page)
    #[prost(message, optional, tag = "3")]
    pub page_token: ::core::option::Option<TokenPagination>,
    /// Filter by SIP dispatch rule ID
    #[prost(string, optional, tag = "4")]
    pub sip_dispatch_rule_id: ::core::option::Option<::prost::alloc::string::String>,
}
/// ListPhoneNumbersResponse - Response containing phone numbers
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPhoneNumbersResponse {
    /// List of phone numbers
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<PhoneNumber>,
    /// Token for next page (empty if no more pages)
    #[prost(message, optional, tag = "2")]
    pub next_page_token: ::core::option::Option<TokenPagination>,
    /// Total number of phone numbers
    #[prost(int32, tag = "3")]
    pub total_count: i32,
    /// Total number of offline phone numbers
    #[prost(int32, tag = "4")]
    pub offline_count: i32,
}
/// GetPhoneNumberRequest - Request to get a phone number
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPhoneNumberRequest {
    /// Use phone number ID for direct lookup
    #[prost(string, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    /// Use phone number string for lookup
    #[prost(string, optional, tag = "2")]
    pub phone_number: ::core::option::Option<::prost::alloc::string::String>,
}
/// GetPhoneNumberResponse - Response containing the phone number
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetPhoneNumberResponse {
    /// The phone number details
    #[prost(message, optional, tag = "1")]
    pub phone_number: ::core::option::Option<PhoneNumber>,
}
/// UpdatePhoneNumberRequest - Request to update a phone number
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdatePhoneNumberRequest {
    /// Use phone number ID for direct lookup
    #[prost(string, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    /// Use phone number string for lookup
    #[prost(string, optional, tag = "2")]
    pub phone_number: ::core::option::Option<::prost::alloc::string::String>,
    /// SIP dispatch rule ID to assign to the phone number
    #[prost(string, optional, tag = "3")]
    pub sip_dispatch_rule_id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "4")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
}
/// UpdatePhoneNumberResponse - Response containing the updated phone number
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePhoneNumberResponse {
    /// The updated phone number details
    #[prost(message, optional, tag = "1")]
    pub phone_number: ::core::option::Option<PhoneNumber>,
}
/// ReleasePhoneNumbersRequest - Request to release phone numbers
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ReleasePhoneNumbersRequest {
    /// Use phone number IDs for direct lookup
    #[prost(string, repeated, tag = "1")]
    pub ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Use phone number strings for lookup
    #[prost(string, repeated, tag = "2")]
    pub phone_numbers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// ReleasePhoneNumbersResponse - Response for releasing phone numbers
///
/// Empty response - operation completed successfully
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ReleasePhoneNumbersResponse {
}
/// PhoneNumber - Unified phone number type for inventory and purchased numbers
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PhoneNumber {
    /// Unique identifier
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Human-readable name/label for the phone number
    #[prost(string, tag = "17")]
    pub name: ::prost::alloc::string::String,
    /// Phone number in E.164 format (e.g., "+14155552671")
    #[prost(string, tag = "2")]
    pub e164_format: ::prost::alloc::string::String,
    /// Country code (e.g., "US")
    #[prost(string, tag = "3")]
    pub country_code: ::prost::alloc::string::String,
    /// Area code (e.g., "415")
    #[prost(string, tag = "4")]
    pub area_code: ::prost::alloc::string::String,
    /// Number type (mobile, local, toll-free, unknown)
    #[prost(enumeration = "PhoneNumberType", tag = "5")]
    pub number_type: i32,
    /// City/locality (e.g., "San Francisco")
    #[prost(string, tag = "6")]
    pub locality: ::prost::alloc::string::String,
    /// State/region (e.g., "CA")
    #[prost(string, tag = "7")]
    pub region: ::prost::alloc::string::String,
    /// Spam score for fraud detection
    #[prost(double, tag = "8")]
    pub spam_score: f64,
    /// Creation timestamp
    #[prost(message, optional, tag = "9")]
    pub created_at: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Last update timestamp
    #[prost(message, optional, tag = "10")]
    pub updated_at: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Available capabilities (e.g., "voice", "sms")
    #[prost(string, repeated, tag = "11")]
    pub capabilities: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Current status
    #[prost(enumeration = "PhoneNumberStatus", tag = "12")]
    pub status: i32,
    /// Inbound calling status
    #[prost(enumeration = "PhoneNumberInboundStatus", tag = "18")]
    pub inbound_status: i32,
    /// Outbound calling status
    #[prost(enumeration = "PhoneNumberOutboundStatus", tag = "19")]
    pub outbound_status: i32,
    /// Assignment timestamp
    #[prost(message, optional, tag = "13")]
    pub assigned_at: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Release timestamp (if applicable)
    #[prost(message, optional, tag = "14")]
    pub released_at: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Associated SIP dispatch rule ID (deprecated: use sip_dispatch_rule_ids instead)
    #[deprecated]
    #[prost(string, tag = "15")]
    pub sip_dispatch_rule_id: ::prost::alloc::string::String,
    /// Associated SIP dispatch rule IDs
    #[prost(string, repeated, tag = "16")]
    pub sip_dispatch_rule_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Phone number status enumeration
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PhoneNumberStatus {
    /// Default value
    Unspecified = 0,
    /// Number is active and ready for use
    Active = 1,
    /// Number is being provisioned
    Pending = 2,
    /// Number has been released
    Released = 3,
    /// Number is offline (provider is unreachable)
    Offline = 4,
}
impl PhoneNumberStatus {
    /// 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 => "PHONE_NUMBER_STATUS_UNSPECIFIED",
            Self::Active => "PHONE_NUMBER_STATUS_ACTIVE",
            Self::Pending => "PHONE_NUMBER_STATUS_PENDING",
            Self::Released => "PHONE_NUMBER_STATUS_RELEASED",
            Self::Offline => "PHONE_NUMBER_STATUS_OFFLINE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PHONE_NUMBER_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
            "PHONE_NUMBER_STATUS_ACTIVE" => Some(Self::Active),
            "PHONE_NUMBER_STATUS_PENDING" => Some(Self::Pending),
            "PHONE_NUMBER_STATUS_RELEASED" => Some(Self::Released),
            "PHONE_NUMBER_STATUS_OFFLINE" => Some(Self::Offline),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PhoneNumberInboundStatus {
    /// Default value
    PhoneNumberInStatusUnspecified = 0,
    /// Number is serving inbound calls
    PhoneNumberInStatusActive = 1,
    /// Inbound calling is unavailable
    PhoneNumberInStatusUnavailable = 2,
    /// Number is not serving calls (not associated with dispatch rules)
    PhoneNumberInStatusDetached = 3,
}
impl PhoneNumberInboundStatus {
    /// 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::PhoneNumberInStatusUnspecified => "PHONE_NUMBER_IN_STATUS_UNSPECIFIED",
            Self::PhoneNumberInStatusActive => "PHONE_NUMBER_IN_STATUS_ACTIVE",
            Self::PhoneNumberInStatusUnavailable => "PHONE_NUMBER_IN_STATUS_UNAVAILABLE",
            Self::PhoneNumberInStatusDetached => "PHONE_NUMBER_IN_STATUS_DETACHED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PHONE_NUMBER_IN_STATUS_UNSPECIFIED" => Some(Self::PhoneNumberInStatusUnspecified),
            "PHONE_NUMBER_IN_STATUS_ACTIVE" => Some(Self::PhoneNumberInStatusActive),
            "PHONE_NUMBER_IN_STATUS_UNAVAILABLE" => Some(Self::PhoneNumberInStatusUnavailable),
            "PHONE_NUMBER_IN_STATUS_DETACHED" => Some(Self::PhoneNumberInStatusDetached),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PhoneNumberOutboundStatus {
    /// Default value
    PhoneNumberOutStatusUnspecified = 0,
    /// Number is can be used to initiate outbound calls
    PhoneNumberOutStatusActive = 1,
    /// Outbound calling is unavailable
    PhoneNumberOutStatusUnavailable = 2,
}
impl PhoneNumberOutboundStatus {
    /// 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::PhoneNumberOutStatusUnspecified => "PHONE_NUMBER_OUT_STATUS_UNSPECIFIED",
            Self::PhoneNumberOutStatusActive => "PHONE_NUMBER_OUT_STATUS_ACTIVE",
            Self::PhoneNumberOutStatusUnavailable => "PHONE_NUMBER_OUT_STATUS_UNAVAILABLE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PHONE_NUMBER_OUT_STATUS_UNSPECIFIED" => Some(Self::PhoneNumberOutStatusUnspecified),
            "PHONE_NUMBER_OUT_STATUS_ACTIVE" => Some(Self::PhoneNumberOutStatusActive),
            "PHONE_NUMBER_OUT_STATUS_UNAVAILABLE" => Some(Self::PhoneNumberOutStatusUnavailable),
            _ => None,
        }
    }
}
/// Phone number type enumeration
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PhoneNumberType {
    /// Default value - unknown or parsing error
    Unknown = 0,
    /// Mobile phone number
    Mobile = 1,
    /// Local/fixed line number
    Local = 2,
    /// Toll-free number
    TollFree = 3,
}
impl PhoneNumberType {
    /// 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 => "PHONE_NUMBER_TYPE_UNKNOWN",
            Self::Mobile => "PHONE_NUMBER_TYPE_MOBILE",
            Self::Local => "PHONE_NUMBER_TYPE_LOCAL",
            Self::TollFree => "PHONE_NUMBER_TYPE_TOLL_FREE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PHONE_NUMBER_TYPE_UNKNOWN" => Some(Self::Unknown),
            "PHONE_NUMBER_TYPE_MOBILE" => Some(Self::Mobile),
            "PHONE_NUMBER_TYPE_LOCAL" => Some(Self::Local),
            "PHONE_NUMBER_TYPE_TOLL_FREE" => Some(Self::TollFree),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TokenSourceRequest {
    /// The name of the room being requested when generating credentials
    #[prost(string, optional, tag = "1")]
    pub room_name: ::core::option::Option<::prost::alloc::string::String>,
    /// The name of the participant being requested for this client when generating credentials
    #[prost(string, optional, tag = "2")]
    pub participant_name: ::core::option::Option<::prost::alloc::string::String>,
    /// The identity of the participant being requested for this client when generating credentials
    #[prost(string, optional, tag = "3")]
    pub participant_identity: ::core::option::Option<::prost::alloc::string::String>,
    /// Any participant metadata being included along with the credentials generation operation
    #[prost(string, optional, tag = "4")]
    pub participant_metadata: ::core::option::Option<::prost::alloc::string::String>,
    /// Any participant attributes being included along with the credentials generation operation
    #[prost(map = "string, string", tag = "5")]
    pub participant_attributes: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// A RoomConfiguration object can be passed to request extra parameters should be included when
    /// generating connection credentials - dispatching agents, defining egress settings, etc
    /// More info: <https://docs.livekit.io/home/get-started/authentication/#room-configuration>
    #[prost(message, optional, tag = "6")]
    pub room_config: ::core::option::Option<RoomConfiguration>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TokenSourceResponse {
    #[prost(string, tag = "1")]
    pub server_url: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub participant_token: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetRemoteHeadersV1Request {
    /// list of headers to include
    #[prost(string, repeated, tag = "1")]
    pub include: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// list of headers to exclude
    #[prost(string, repeated, tag = "2")]
    pub exclude: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetRemoteHeadersV1Response {
    #[prost(map = "string, string", tag = "1")]
    pub headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EndCallV1Request {
    #[prost(map = "string, string", tag = "1")]
    pub headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EndCallV1Response {
}
include!("livekit.serde.rs");
// @@protoc_insertion_point(module)