livekit-api 0.9.1

// @generated by generate.sh from openapi.yaml. Do not edit.

#[allow(unused_imports)]
use progenitor_client::{encode_path, ClientHooks, OperationInfo, RequestBuilderExt};
#[allow(unused_imports)]
pub use progenitor_client::{ByteStream, ClientInfo, Error, ResponseValue};
// Types used as operation parameters and responses.
#[allow(clippy::all)]
pub mod types {
    /*PIIRedactionCategory is the canonical taxonomy of PII entity types a project
    may select for redaction. It is the shared contract across Cloud, backend,
    and the dashboard so none of them need to import the redaction library.

    Each value's name maps 1:1 to the snake_case identifier the redaction model
    emits: strip the PII_REDACTION_CATEGORY_ prefix and lowercase (see
    PIIRedactionCategory.Canonical in Go). A guard test in cloud-observability
    asserts this set stays in sync with redact.KnownCategories.

    Numbers are permanent and assigned in append order; never renumber or reuse
    one. Add a new category with the next free number, then classify it via
    PIIRedactionCategory.Class in Go.*/
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum CloudProtocolPiiRedactionCategory {
        #[serde(rename = "PII_REDACTION_CATEGORY_UNSPECIFIED")]
        PiiRedactionCategoryUnspecified,
        #[serde(rename = "PII_REDACTION_CATEGORY_ACCOUNT_NUMBER")]
        PiiRedactionCategoryAccountNumber,
        #[serde(rename = "PII_REDACTION_CATEGORY_AGE")]
        PiiRedactionCategoryAge,
        #[serde(rename = "PII_REDACTION_CATEGORY_BANK_ACCOUNT")]
        PiiRedactionCategoryBankAccount,
        #[serde(rename = "PII_REDACTION_CATEGORY_DATE")]
        PiiRedactionCategoryDate,
        #[serde(rename = "PII_REDACTION_CATEGORY_DOB")]
        PiiRedactionCategoryDob,
        #[serde(rename = "PII_REDACTION_CATEGORY_DRIVER_LICENSE")]
        PiiRedactionCategoryDriverLicense,
        #[serde(rename = "PII_REDACTION_CATEGORY_EDUCATION_LEVEL")]
        PiiRedactionCategoryEducationLevel,
        #[serde(rename = "PII_REDACTION_CATEGORY_EMAIL_ADDRESS")]
        PiiRedactionCategoryEmailAddress,
        #[serde(rename = "PII_REDACTION_CATEGORY_GOVERNMENT_ID")]
        PiiRedactionCategoryGovernmentId,
        #[serde(rename = "PII_REDACTION_CATEGORY_HEALTHCARE_NUMBER")]
        PiiRedactionCategoryHealthcareNumber,
        #[serde(rename = "PII_REDACTION_CATEGORY_IP_ADDRESS")]
        PiiRedactionCategoryIpAddress,
        #[serde(rename = "PII_REDACTION_CATEGORY_LICENSE_PLATE")]
        PiiRedactionCategoryLicensePlate,
        #[serde(rename = "PII_REDACTION_CATEGORY_LOCATION")]
        PiiRedactionCategoryLocation,
        #[serde(rename = "PII_REDACTION_CATEGORY_LOCATION_ADDRESS")]
        PiiRedactionCategoryLocationAddress,
        #[serde(rename = "PII_REDACTION_CATEGORY_LOCATION_CITY")]
        PiiRedactionCategoryLocationCity,
        #[serde(rename = "PII_REDACTION_CATEGORY_LOCATION_COORDINATE")]
        PiiRedactionCategoryLocationCoordinate,
        #[serde(rename = "PII_REDACTION_CATEGORY_LOCATION_COUNTRY")]
        PiiRedactionCategoryLocationCountry,
        #[serde(rename = "PII_REDACTION_CATEGORY_LOCATION_STATE")]
        PiiRedactionCategoryLocationState,
        #[serde(rename = "PII_REDACTION_CATEGORY_LOCATION_ZIP")]
        PiiRedactionCategoryLocationZip,
        #[serde(rename = "PII_REDACTION_CATEGORY_NAME")]
        PiiRedactionCategoryName,
        #[serde(rename = "PII_REDACTION_CATEGORY_NAME_GIVEN")]
        PiiRedactionCategoryNameGiven,
        #[serde(rename = "PII_REDACTION_CATEGORY_NAME_FAMILY")]
        PiiRedactionCategoryNameFamily,
        #[serde(rename = "PII_REDACTION_CATEGORY_NUMERICAL_PII")]
        PiiRedactionCategoryNumericalPii,
        #[serde(rename = "PII_REDACTION_CATEGORY_OCCUPATION")]
        PiiRedactionCategoryOccupation,
        #[serde(rename = "PII_REDACTION_CATEGORY_ORIGIN")]
        PiiRedactionCategoryOrigin,
        #[serde(rename = "PII_REDACTION_CATEGORY_PASSPORT_NUMBER")]
        PiiRedactionCategoryPassportNumber,
        #[serde(rename = "PII_REDACTION_CATEGORY_PASSWORD")]
        PiiRedactionCategoryPassword,
        #[serde(rename = "PII_REDACTION_CATEGORY_PHONE_NUMBER")]
        PiiRedactionCategoryPhoneNumber,
        #[serde(rename = "PII_REDACTION_CATEGORY_ROUTING_NUMBER")]
        PiiRedactionCategoryRoutingNumber,
        #[serde(rename = "PII_REDACTION_CATEGORY_SSN")]
        PiiRedactionCategorySsn,
        #[serde(rename = "PII_REDACTION_CATEGORY_SWIFT_CODE")]
        PiiRedactionCategorySwiftCode,
        #[serde(rename = "PII_REDACTION_CATEGORY_URL")]
        PiiRedactionCategoryUrl,
        #[serde(rename = "PII_REDACTION_CATEGORY_USERNAME")]
        PiiRedactionCategoryUsername,
        #[serde(rename = "PII_REDACTION_CATEGORY_VEHICLE_ID")]
        PiiRedactionCategoryVehicleId,
        #[serde(rename = "PII_REDACTION_CATEGORY_CREDIT_CARD")]
        PiiRedactionCategoryCreditCard,
        #[serde(rename = "PII_REDACTION_CATEGORY_CREDIT_CARD_EXPIRATION")]
        PiiRedactionCategoryCreditCardExpiration,
        #[serde(rename = "PII_REDACTION_CATEGORY_CVV")]
        PiiRedactionCategoryCvv,
        #[serde(rename = "PII_REDACTION_CATEGORY_LANGUAGE")]
        PiiRedactionCategoryLanguage,
        #[serde(rename = "PII_REDACTION_CATEGORY_ORGANIZATION")]
        PiiRedactionCategoryOrganization,
        #[serde(rename = "PII_REDACTION_CATEGORY_POLITICAL_AFFILIATION")]
        PiiRedactionCategoryPoliticalAffiliation,
        #[serde(rename = "PII_REDACTION_CATEGORY_RELIGION")]
        PiiRedactionCategoryReligion,
    }
    impl ::std::fmt::Display for CloudProtocolPiiRedactionCategory {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::PiiRedactionCategoryUnspecified => {
                    f.write_str("PII_REDACTION_CATEGORY_UNSPECIFIED")
                }
                Self::PiiRedactionCategoryAccountNumber => {
                    f.write_str("PII_REDACTION_CATEGORY_ACCOUNT_NUMBER")
                }
                Self::PiiRedactionCategoryAge => f.write_str("PII_REDACTION_CATEGORY_AGE"),
                Self::PiiRedactionCategoryBankAccount => {
                    f.write_str("PII_REDACTION_CATEGORY_BANK_ACCOUNT")
                }
                Self::PiiRedactionCategoryDate => f.write_str("PII_REDACTION_CATEGORY_DATE"),
                Self::PiiRedactionCategoryDob => f.write_str("PII_REDACTION_CATEGORY_DOB"),
                Self::PiiRedactionCategoryDriverLicense => {
                    f.write_str("PII_REDACTION_CATEGORY_DRIVER_LICENSE")
                }
                Self::PiiRedactionCategoryEducationLevel => {
                    f.write_str("PII_REDACTION_CATEGORY_EDUCATION_LEVEL")
                }
                Self::PiiRedactionCategoryEmailAddress => {
                    f.write_str("PII_REDACTION_CATEGORY_EMAIL_ADDRESS")
                }
                Self::PiiRedactionCategoryGovernmentId => {
                    f.write_str("PII_REDACTION_CATEGORY_GOVERNMENT_ID")
                }
                Self::PiiRedactionCategoryHealthcareNumber => {
                    f.write_str("PII_REDACTION_CATEGORY_HEALTHCARE_NUMBER")
                }
                Self::PiiRedactionCategoryIpAddress => {
                    f.write_str("PII_REDACTION_CATEGORY_IP_ADDRESS")
                }
                Self::PiiRedactionCategoryLicensePlate => {
                    f.write_str("PII_REDACTION_CATEGORY_LICENSE_PLATE")
                }
                Self::PiiRedactionCategoryLocation => {
                    f.write_str("PII_REDACTION_CATEGORY_LOCATION")
                }
                Self::PiiRedactionCategoryLocationAddress => {
                    f.write_str("PII_REDACTION_CATEGORY_LOCATION_ADDRESS")
                }
                Self::PiiRedactionCategoryLocationCity => {
                    f.write_str("PII_REDACTION_CATEGORY_LOCATION_CITY")
                }
                Self::PiiRedactionCategoryLocationCoordinate => {
                    f.write_str("PII_REDACTION_CATEGORY_LOCATION_COORDINATE")
                }
                Self::PiiRedactionCategoryLocationCountry => {
                    f.write_str("PII_REDACTION_CATEGORY_LOCATION_COUNTRY")
                }
                Self::PiiRedactionCategoryLocationState => {
                    f.write_str("PII_REDACTION_CATEGORY_LOCATION_STATE")
                }
                Self::PiiRedactionCategoryLocationZip => {
                    f.write_str("PII_REDACTION_CATEGORY_LOCATION_ZIP")
                }
                Self::PiiRedactionCategoryName => f.write_str("PII_REDACTION_CATEGORY_NAME"),
                Self::PiiRedactionCategoryNameGiven => {
                    f.write_str("PII_REDACTION_CATEGORY_NAME_GIVEN")
                }
                Self::PiiRedactionCategoryNameFamily => {
                    f.write_str("PII_REDACTION_CATEGORY_NAME_FAMILY")
                }
                Self::PiiRedactionCategoryNumericalPii => {
                    f.write_str("PII_REDACTION_CATEGORY_NUMERICAL_PII")
                }
                Self::PiiRedactionCategoryOccupation => {
                    f.write_str("PII_REDACTION_CATEGORY_OCCUPATION")
                }
                Self::PiiRedactionCategoryOrigin => f.write_str("PII_REDACTION_CATEGORY_ORIGIN"),
                Self::PiiRedactionCategoryPassportNumber => {
                    f.write_str("PII_REDACTION_CATEGORY_PASSPORT_NUMBER")
                }
                Self::PiiRedactionCategoryPassword => {
                    f.write_str("PII_REDACTION_CATEGORY_PASSWORD")
                }
                Self::PiiRedactionCategoryPhoneNumber => {
                    f.write_str("PII_REDACTION_CATEGORY_PHONE_NUMBER")
                }
                Self::PiiRedactionCategoryRoutingNumber => {
                    f.write_str("PII_REDACTION_CATEGORY_ROUTING_NUMBER")
                }
                Self::PiiRedactionCategorySsn => f.write_str("PII_REDACTION_CATEGORY_SSN"),
                Self::PiiRedactionCategorySwiftCode => {
                    f.write_str("PII_REDACTION_CATEGORY_SWIFT_CODE")
                }
                Self::PiiRedactionCategoryUrl => f.write_str("PII_REDACTION_CATEGORY_URL"),
                Self::PiiRedactionCategoryUsername => {
                    f.write_str("PII_REDACTION_CATEGORY_USERNAME")
                }
                Self::PiiRedactionCategoryVehicleId => {
                    f.write_str("PII_REDACTION_CATEGORY_VEHICLE_ID")
                }
                Self::PiiRedactionCategoryCreditCard => {
                    f.write_str("PII_REDACTION_CATEGORY_CREDIT_CARD")
                }
                Self::PiiRedactionCategoryCreditCardExpiration => {
                    f.write_str("PII_REDACTION_CATEGORY_CREDIT_CARD_EXPIRATION")
                }
                Self::PiiRedactionCategoryCvv => f.write_str("PII_REDACTION_CATEGORY_CVV"),
                Self::PiiRedactionCategoryLanguage => {
                    f.write_str("PII_REDACTION_CATEGORY_LANGUAGE")
                }
                Self::PiiRedactionCategoryOrganization => {
                    f.write_str("PII_REDACTION_CATEGORY_ORGANIZATION")
                }
                Self::PiiRedactionCategoryPoliticalAffiliation => {
                    f.write_str("PII_REDACTION_CATEGORY_POLITICAL_AFFILIATION")
                }
                Self::PiiRedactionCategoryReligion => {
                    f.write_str("PII_REDACTION_CATEGORY_RELIGION")
                }
            }
        }
    }
    impl ::std::str::FromStr for CloudProtocolPiiRedactionCategory {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "PII_REDACTION_CATEGORY_UNSPECIFIED" => Ok(Self::PiiRedactionCategoryUnspecified),
                "PII_REDACTION_CATEGORY_ACCOUNT_NUMBER" => {
                    Ok(Self::PiiRedactionCategoryAccountNumber)
                }
                "PII_REDACTION_CATEGORY_AGE" => Ok(Self::PiiRedactionCategoryAge),
                "PII_REDACTION_CATEGORY_BANK_ACCOUNT" => Ok(Self::PiiRedactionCategoryBankAccount),
                "PII_REDACTION_CATEGORY_DATE" => Ok(Self::PiiRedactionCategoryDate),
                "PII_REDACTION_CATEGORY_DOB" => Ok(Self::PiiRedactionCategoryDob),
                "PII_REDACTION_CATEGORY_DRIVER_LICENSE" => {
                    Ok(Self::PiiRedactionCategoryDriverLicense)
                }
                "PII_REDACTION_CATEGORY_EDUCATION_LEVEL" => {
                    Ok(Self::PiiRedactionCategoryEducationLevel)
                }
                "PII_REDACTION_CATEGORY_EMAIL_ADDRESS" => {
                    Ok(Self::PiiRedactionCategoryEmailAddress)
                }
                "PII_REDACTION_CATEGORY_GOVERNMENT_ID" => {
                    Ok(Self::PiiRedactionCategoryGovernmentId)
                }
                "PII_REDACTION_CATEGORY_HEALTHCARE_NUMBER" => {
                    Ok(Self::PiiRedactionCategoryHealthcareNumber)
                }
                "PII_REDACTION_CATEGORY_IP_ADDRESS" => Ok(Self::PiiRedactionCategoryIpAddress),
                "PII_REDACTION_CATEGORY_LICENSE_PLATE" => {
                    Ok(Self::PiiRedactionCategoryLicensePlate)
                }
                "PII_REDACTION_CATEGORY_LOCATION" => Ok(Self::PiiRedactionCategoryLocation),
                "PII_REDACTION_CATEGORY_LOCATION_ADDRESS" => {
                    Ok(Self::PiiRedactionCategoryLocationAddress)
                }
                "PII_REDACTION_CATEGORY_LOCATION_CITY" => {
                    Ok(Self::PiiRedactionCategoryLocationCity)
                }
                "PII_REDACTION_CATEGORY_LOCATION_COORDINATE" => {
                    Ok(Self::PiiRedactionCategoryLocationCoordinate)
                }
                "PII_REDACTION_CATEGORY_LOCATION_COUNTRY" => {
                    Ok(Self::PiiRedactionCategoryLocationCountry)
                }
                "PII_REDACTION_CATEGORY_LOCATION_STATE" => {
                    Ok(Self::PiiRedactionCategoryLocationState)
                }
                "PII_REDACTION_CATEGORY_LOCATION_ZIP" => Ok(Self::PiiRedactionCategoryLocationZip),
                "PII_REDACTION_CATEGORY_NAME" => Ok(Self::PiiRedactionCategoryName),
                "PII_REDACTION_CATEGORY_NAME_GIVEN" => Ok(Self::PiiRedactionCategoryNameGiven),
                "PII_REDACTION_CATEGORY_NAME_FAMILY" => Ok(Self::PiiRedactionCategoryNameFamily),
                "PII_REDACTION_CATEGORY_NUMERICAL_PII" => {
                    Ok(Self::PiiRedactionCategoryNumericalPii)
                }
                "PII_REDACTION_CATEGORY_OCCUPATION" => Ok(Self::PiiRedactionCategoryOccupation),
                "PII_REDACTION_CATEGORY_ORIGIN" => Ok(Self::PiiRedactionCategoryOrigin),
                "PII_REDACTION_CATEGORY_PASSPORT_NUMBER" => {
                    Ok(Self::PiiRedactionCategoryPassportNumber)
                }
                "PII_REDACTION_CATEGORY_PASSWORD" => Ok(Self::PiiRedactionCategoryPassword),
                "PII_REDACTION_CATEGORY_PHONE_NUMBER" => Ok(Self::PiiRedactionCategoryPhoneNumber),
                "PII_REDACTION_CATEGORY_ROUTING_NUMBER" => {
                    Ok(Self::PiiRedactionCategoryRoutingNumber)
                }
                "PII_REDACTION_CATEGORY_SSN" => Ok(Self::PiiRedactionCategorySsn),
                "PII_REDACTION_CATEGORY_SWIFT_CODE" => Ok(Self::PiiRedactionCategorySwiftCode),
                "PII_REDACTION_CATEGORY_URL" => Ok(Self::PiiRedactionCategoryUrl),
                "PII_REDACTION_CATEGORY_USERNAME" => Ok(Self::PiiRedactionCategoryUsername),
                "PII_REDACTION_CATEGORY_VEHICLE_ID" => Ok(Self::PiiRedactionCategoryVehicleId),
                "PII_REDACTION_CATEGORY_CREDIT_CARD" => Ok(Self::PiiRedactionCategoryCreditCard),
                "PII_REDACTION_CATEGORY_CREDIT_CARD_EXPIRATION" => {
                    Ok(Self::PiiRedactionCategoryCreditCardExpiration)
                }
                "PII_REDACTION_CATEGORY_CVV" => Ok(Self::PiiRedactionCategoryCvv),
                "PII_REDACTION_CATEGORY_LANGUAGE" => Ok(Self::PiiRedactionCategoryLanguage),
                "PII_REDACTION_CATEGORY_ORGANIZATION" => Ok(Self::PiiRedactionCategoryOrganization),
                "PII_REDACTION_CATEGORY_POLITICAL_AFFILIATION" => {
                    Ok(Self::PiiRedactionCategoryPoliticalAffiliation)
                }
                "PII_REDACTION_CATEGORY_RELIGION" => Ok(Self::PiiRedactionCategoryReligion),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for CloudProtocolPiiRedactionCategory {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for CloudProtocolPiiRedactionCategory {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`DatabaseServiceCreateDatabaseBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct DatabaseServiceCreateDatabaseBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub ttl: ::std::option::Option<::pbjson_types::Duration>,
    }
    //Represents a JSON array.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct GoogleProtobufListValue {
        //Repeated field of dynamically typed values.
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub values: ::std::vec::Vec<GoogleProtobufValue>,
    }
    /*Represents a JSON `null`.

    `NullValue` is a sentinel, using an enum with only one value to represent
    the null value for the `Value` type union.

    A field of type `NullValue` with any value other than `0` is considered
    invalid. Most ProtoJSON serializers will emit a Value with a `null_value` set
    as a JSON `null` regardless of the integer value, and so will round trip to
    a `0` value.*/
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum GoogleProtobufNullValue {
        #[serde(rename = "NULL_VALUE")]
        NullValue,
    }
    impl ::std::fmt::Display for GoogleProtobufNullValue {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::NullValue => f.write_str("NULL_VALUE"),
            }
        }
    }
    impl ::std::str::FromStr for GoogleProtobufNullValue {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "NULL_VALUE" => Ok(Self::NullValue),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GoogleProtobufNullValue {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GoogleProtobufNullValue {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    /*Represents a JSON object.

    An unordered key-value map, intending to perfectly capture the semantics of a
    JSON object. This enables parsing any arbitrary JSON payload as a message
    field in ProtoJSON format.

    This follows RFC 8259 guidelines for interoperable JSON: notably this type
    cannot represent large Int64 values or `NaN`/`Infinity` numbers,
    since the JSON format generally does not support those values in its number
    type.

    If you do not intend to parse arbitrary JSON into your message, a custom
    typed message should be preferred instead of using this type.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct GoogleProtobufStruct(
        pub ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>,
    );
    impl ::std::ops::Deref for GoogleProtobufStruct {
        type Target = ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>;
        fn deref(
            &self,
        ) -> &::std::collections::HashMap<::std::string::String, GoogleProtobufValue> {
            &self.0
        }
    }
    impl ::std::convert::From<GoogleProtobufStruct>
        for ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>
    {
        fn from(value: GoogleProtobufStruct) -> Self {
            value.0
        }
    }
    impl
        ::std::convert::From<
            ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>,
        > for GoogleProtobufStruct
    {
        fn from(
            value: ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>,
        ) -> Self {
            Self(value)
        }
    }
    //`GoogleProtobufStructFieldsEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct GoogleProtobufStructFieldsEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<GoogleProtobufValue>,
    }
    /*Represents a JSON value.

    `Value` represents a dynamically typed value which can be either
    null, a number, a string, a boolean, a recursive struct value, or a
    list of values. A producer of value is expected to set one of these
    variants. Absence of any variant is an invalid state.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct GoogleProtobufValue(pub ::serde_json::Value);
    impl ::std::ops::Deref for GoogleProtobufValue {
        type Target = ::serde_json::Value;
        fn deref(&self) -> &::serde_json::Value {
            &self.0
        }
    }
    impl ::std::convert::From<GoogleProtobufValue> for ::serde_json::Value {
        fn from(value: GoogleProtobufValue) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Value> for GoogleProtobufValue {
        fn from(value: ::serde_json::Value) -> Self {
            Self(value)
        }
    }
    //`LivekitAgentAgentConfigUpdate`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAgentAgentConfigUpdate {
        #[serde(rename = "createdAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub created_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub instructions: ::std::option::Option<::std::string::String>,
        #[serde(rename = "toolsAdded", default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub tools_added: ::std::vec::Vec<::std::string::String>,
        #[serde(
            rename = "toolsRemoved",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub tools_removed: ::std::vec::Vec<::std::string::String>,
    }
    //`LivekitAgentAgentHandoff`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAgentAgentHandoff {
        #[serde(rename = "createdAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub created_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "newAgentId", skip_serializing_if = "::std::option::Option::is_none")]
        pub new_agent_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "oldAgentId", skip_serializing_if = "::std::option::Option::is_none")]
        pub old_agent_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitAgentAgentThreadThreadAttributesEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAgentAgentThreadThreadAttributesEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //`LivekitAgentChatContext`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAgentChatContext {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitAgentChatContextChatItem>,
    }
    //`LivekitAgentChatContextChatItem`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub enum LivekitAgentChatContextChatItem {
        #[serde(rename = "agentConfigUpdate")]
        AgentConfigUpdate(LivekitAgentAgentConfigUpdate),
        #[serde(rename = "agentHandoff")]
        AgentHandoff(LivekitAgentAgentHandoff),
        #[serde(rename = "functionCall")]
        FunctionCall(LivekitAgentFunctionCall),
        #[serde(rename = "functionCallOutput")]
        FunctionCallOutput(LivekitAgentFunctionCallOutput),
        #[serde(rename = "message")]
        Message(LivekitAgentChatMessage),
    }
    impl ::std::convert::From<LivekitAgentAgentConfigUpdate> for LivekitAgentChatContextChatItem {
        fn from(value: LivekitAgentAgentConfigUpdate) -> Self {
            Self::AgentConfigUpdate(value)
        }
    }
    impl ::std::convert::From<LivekitAgentAgentHandoff> for LivekitAgentChatContextChatItem {
        fn from(value: LivekitAgentAgentHandoff) -> Self {
            Self::AgentHandoff(value)
        }
    }
    impl ::std::convert::From<LivekitAgentFunctionCall> for LivekitAgentChatContextChatItem {
        fn from(value: LivekitAgentFunctionCall) -> Self {
            Self::FunctionCall(value)
        }
    }
    impl ::std::convert::From<LivekitAgentFunctionCallOutput> for LivekitAgentChatContextChatItem {
        fn from(value: LivekitAgentFunctionCallOutput) -> Self {
            Self::FunctionCallOutput(value)
        }
    }
    impl ::std::convert::From<LivekitAgentChatMessage> for LivekitAgentChatContextChatItem {
        fn from(value: LivekitAgentChatMessage) -> Self {
            Self::Message(value)
        }
    }
    //`LivekitAgentChatMessage`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAgentChatMessage {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub content: ::std::vec::Vec<LivekitAgentChatMessageChatContent>,
        #[serde(rename = "createdAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub created_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub extra: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub interrupted: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub metrics: ::std::option::Option<LivekitAgentMetricsReport>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<LivekitAgentChatRole>,
        #[serde(
            rename = "transcriptConfidence",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transcript_confidence: ::std::option::Option<f64>,
    }
    //`LivekitAgentChatMessageChatContent`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitAgentChatMessageChatContent(pub ::std::option::Option<Text>);
    impl ::std::ops::Deref for LivekitAgentChatMessageChatContent {
        type Target = ::std::option::Option<Text>;
        fn deref(&self) -> &::std::option::Option<Text> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitAgentChatMessageChatContent> for ::std::option::Option<Text> {
        fn from(value: LivekitAgentChatMessageChatContent) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::std::option::Option<Text>> for LivekitAgentChatMessageChatContent {
        fn from(value: ::std::option::Option<Text>) -> Self {
            Self(value)
        }
    }
    //`LivekitAgentChatMessageExtraEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAgentChatMessageExtraEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //`LivekitAgentChatRole`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitAgentChatRole {
        #[serde(rename = "DEVELOPER")]
        Developer,
        #[serde(rename = "SYSTEM")]
        System,
        #[serde(rename = "USER")]
        User,
        #[serde(rename = "ASSISTANT")]
        Assistant,
    }
    impl ::std::fmt::Display for LivekitAgentChatRole {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Developer => f.write_str("DEVELOPER"),
                Self::System => f.write_str("SYSTEM"),
                Self::User => f.write_str("USER"),
                Self::Assistant => f.write_str("ASSISTANT"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitAgentChatRole {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "DEVELOPER" => Ok(Self::Developer),
                "SYSTEM" => Ok(Self::System),
                "USER" => Ok(Self::User),
                "ASSISTANT" => Ok(Self::Assistant),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitAgentChatRole {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitAgentChatRole {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitAgentFunctionCall`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAgentFunctionCall {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub arguments: ::std::option::Option<::std::string::String>,
        #[serde(rename = "callId", skip_serializing_if = "::std::option::Option::is_none")]
        pub call_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "createdAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub created_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
    }
    //`LivekitAgentFunctionCallOutput`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAgentFunctionCallOutput {
        #[serde(rename = "callId", skip_serializing_if = "::std::option::Option::is_none")]
        pub call_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "createdAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub created_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "isError", skip_serializing_if = "::std::option::Option::is_none")]
        pub is_error: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub output: ::std::option::Option<::std::string::String>,
    }
    //`LivekitAgentMetricsReport`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAgentMetricsReport {
        #[serde(rename = "e2eLatency", skip_serializing_if = "::std::option::Option::is_none")]
        pub e2e_latency: ::std::option::Option<f64>,
        #[serde(rename = "endOfTurnDelay", skip_serializing_if = "::std::option::Option::is_none")]
        pub end_of_turn_delay: ::std::option::Option<f64>,
        #[serde(rename = "llmNodeTps", skip_serializing_if = "::std::option::Option::is_none")]
        pub llm_node_tps: ::std::option::Option<f64>,
        #[serde(rename = "llmNodeTtfs", skip_serializing_if = "::std::option::Option::is_none")]
        pub llm_node_ttfs: ::std::option::Option<f64>,
        #[serde(rename = "llmNodeTtft", skip_serializing_if = "::std::option::Option::is_none")]
        pub llm_node_ttft: ::std::option::Option<f64>,
        #[serde(
            rename = "onUserTurnCompletedDelay",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub on_user_turn_completed_delay: ::std::option::Option<f64>,
        #[serde(
            rename = "startedSpeakingAt",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub started_speaking_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(
            rename = "stoppedSpeakingAt",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub stopped_speaking_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(
            rename = "transcriptionDelay",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transcription_delay: ::std::option::Option<f64>,
        #[serde(rename = "ttsNodeTtfb", skip_serializing_if = "::std::option::Option::is_none")]
        pub tts_node_ttfb: ::std::option::Option<f64>,
    }
    //`LivekitAliOssUpload`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAliOssUpload {
        #[serde(rename = "accessKey", skip_serializing_if = "::std::option::Option::is_none")]
        pub access_key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub bucket: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub endpoint: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub secret: ::std::option::Option<::std::string::String>,
    }
    //`LivekitAudioCodec`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitAudioCodec {
        #[serde(rename = "DEFAULT_AC")]
        DefaultAc,
        #[serde(rename = "OPUS")]
        Opus,
        #[serde(rename = "AAC")]
        Aac,
        #[serde(rename = "AC_MP3")]
        AcMp3,
    }
    impl ::std::fmt::Display for LivekitAudioCodec {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::DefaultAc => f.write_str("DEFAULT_AC"),
                Self::Opus => f.write_str("OPUS"),
                Self::Aac => f.write_str("AAC"),
                Self::AcMp3 => f.write_str("AC_MP3"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitAudioCodec {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "DEFAULT_AC" => Ok(Self::DefaultAc),
                "OPUS" => Ok(Self::Opus),
                "AAC" => Ok(Self::Aac),
                "AC_MP3" => Ok(Self::AcMp3),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitAudioCodec {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitAudioCodec {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitAudioMixing`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitAudioMixing {
        #[serde(rename = "DEFAULT_MIXING")]
        DefaultMixing,
        #[serde(rename = "DUAL_CHANNEL_AGENT")]
        DualChannelAgent,
        #[serde(rename = "DUAL_CHANNEL_ALTERNATE")]
        DualChannelAlternate,
    }
    impl ::std::fmt::Display for LivekitAudioMixing {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::DefaultMixing => f.write_str("DEFAULT_MIXING"),
                Self::DualChannelAgent => f.write_str("DUAL_CHANNEL_AGENT"),
                Self::DualChannelAlternate => f.write_str("DUAL_CHANNEL_ALTERNATE"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitAudioMixing {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "DEFAULT_MIXING" => Ok(Self::DefaultMixing),
                "DUAL_CHANNEL_AGENT" => Ok(Self::DualChannelAgent),
                "DUAL_CHANNEL_ALTERNATE" => Ok(Self::DualChannelAlternate),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitAudioMixing {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitAudioMixing {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitAutoParticipantEgress`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitAutoParticipantEgress {
        Variant0 {
            advanced: LivekitEncodingOptions,
            #[serde(
                rename = "fileOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            file_outputs: ::std::vec::Vec<LivekitEncodedFileOutput>,
            #[serde(
                rename = "segmentOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            segment_outputs: ::std::vec::Vec<LivekitSegmentedFileOutput>,
        },
        Variant1 {
            #[serde(
                rename = "fileOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            file_outputs: ::std::vec::Vec<LivekitEncodedFileOutput>,
            preset: LivekitEncodingOptionsPreset,
            #[serde(
                rename = "segmentOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            segment_outputs: ::std::vec::Vec<LivekitSegmentedFileOutput>,
        },
    }
    //`LivekitAutoTrackEgress`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitAutoTrackEgress {
        Variant0 {
            #[serde(rename = "aliOSS")]
            ali_oss: LivekitAliOssUpload,
            //disables upload of json manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //see docs for templating (default {track_id}-{time})
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            filepath: ::std::option::Option<::std::string::String>,
        },
        Variant1 {
            azure: LivekitAzureBlobUpload,
            //disables upload of json manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //see docs for templating (default {track_id}-{time})
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            filepath: ::std::option::Option<::std::string::String>,
        },
        Variant2 {
            //disables upload of json manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //see docs for templating (default {track_id}-{time})
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            filepath: ::std::option::Option<::std::string::String>,
            gcp: LivekitGcpUpload,
        },
        Variant3 {
            //disables upload of json manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //see docs for templating (default {track_id}-{time})
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            filepath: ::std::option::Option<::std::string::String>,
            s3: LivekitS3Upload,
        },
    }
    //`LivekitAzureBlobUpload`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitAzureBlobUpload {
        #[serde(rename = "accountKey", skip_serializing_if = "::std::option::Option::is_none")]
        pub account_key: ::std::option::Option<::std::string::String>,
        #[serde(rename = "accountName", skip_serializing_if = "::std::option::Option::is_none")]
        pub account_name: ::std::option::Option<::std::string::String>,
        #[serde(rename = "containerName", skip_serializing_if = "::std::option::Option::is_none")]
        pub container_name: ::std::option::Option<::std::string::String>,
    }
    //`LivekitEncodedFileOutput`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitEncodedFileOutput {
        Variant0 {
            #[serde(rename = "aliOSS")]
            ali_oss: LivekitAliOssUpload,
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            #[serde(rename = "fileType", skip_serializing_if = "::std::option::Option::is_none")]
            file_type: ::std::option::Option<LivekitEncodedFileType>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            filepath: ::std::option::Option<::std::string::String>,
        },
        Variant1 {
            azure: LivekitAzureBlobUpload,
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            #[serde(rename = "fileType", skip_serializing_if = "::std::option::Option::is_none")]
            file_type: ::std::option::Option<LivekitEncodedFileType>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            filepath: ::std::option::Option<::std::string::String>,
        },
        Variant2 {
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            #[serde(rename = "fileType", skip_serializing_if = "::std::option::Option::is_none")]
            file_type: ::std::option::Option<LivekitEncodedFileType>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            filepath: ::std::option::Option<::std::string::String>,
            gcp: LivekitGcpUpload,
        },
        Variant3 {
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            #[serde(rename = "fileType", skip_serializing_if = "::std::option::Option::is_none")]
            file_type: ::std::option::Option<LivekitEncodedFileType>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            filepath: ::std::option::Option<::std::string::String>,
            s3: LivekitS3Upload,
        },
    }
    //`LivekitEncodedFileType`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitEncodedFileType {
        #[serde(rename = "DEFAULT_FILETYPE")]
        DefaultFiletype,
        #[serde(rename = "MP4")]
        Mp4,
        #[serde(rename = "OGG")]
        Ogg,
        #[serde(rename = "MP3")]
        Mp3,
    }
    impl ::std::fmt::Display for LivekitEncodedFileType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::DefaultFiletype => f.write_str("DEFAULT_FILETYPE"),
                Self::Mp4 => f.write_str("MP4"),
                Self::Ogg => f.write_str("OGG"),
                Self::Mp3 => f.write_str("MP3"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitEncodedFileType {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "DEFAULT_FILETYPE" => Ok(Self::DefaultFiletype),
                "MP4" => Ok(Self::Mp4),
                "OGG" => Ok(Self::Ogg),
                "MP3" => Ok(Self::Mp3),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitEncodedFileType {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitEncodedFileType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitEncodingOptions`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitEncodingOptions {
        //(default 128)
        #[serde(rename = "audioBitrate", skip_serializing_if = "::std::option::Option::is_none")]
        pub audio_bitrate: ::std::option::Option<i32>,
        #[serde(rename = "audioCodec", skip_serializing_if = "::std::option::Option::is_none")]
        pub audio_codec: ::std::option::Option<LivekitAudioCodec>,
        //(default 44100)
        #[serde(rename = "audioFrequency", skip_serializing_if = "::std::option::Option::is_none")]
        pub audio_frequency: ::std::option::Option<i32>,
        //--- Deprecated --- quality setting on audio encoder
        #[serde(rename = "audioQuality", skip_serializing_if = "::std::option::Option::is_none")]
        pub audio_quality: ::std::option::Option<i32>,
        //(default 24)
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub depth: ::std::option::Option<i32>,
        //(default 30)
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub framerate: ::std::option::Option<i32>,
        //(default 1080)
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub height: ::std::option::Option<i32>,
        //in seconds (default 4s for streaming, segment duration for segmented output, encoder default for files)
        #[serde(
            rename = "keyFrameInterval",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub key_frame_interval: ::std::option::Option<f64>,
        //(default 4500)
        #[serde(rename = "videoBitrate", skip_serializing_if = "::std::option::Option::is_none")]
        pub video_bitrate: ::std::option::Option<i32>,
        #[serde(rename = "videoCodec", skip_serializing_if = "::std::option::Option::is_none")]
        pub video_codec: ::std::option::Option<LivekitVideoCodec>,
        //quality setting on video encoder
        #[serde(rename = "videoQuality", skip_serializing_if = "::std::option::Option::is_none")]
        pub video_quality: ::std::option::Option<i32>,
        //(default 1920)
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub width: ::std::option::Option<i32>,
    }
    //`LivekitEncodingOptionsPreset`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitEncodingOptionsPreset {
        #[serde(rename = "H264_720P_30")]
        H264720p30,
        #[serde(rename = "H264_720P_60")]
        H264720p60,
        #[serde(rename = "H264_1080P_30")]
        H2641080p30,
        #[serde(rename = "H264_1080P_60")]
        H2641080p60,
        #[serde(rename = "PORTRAIT_H264_720P_30")]
        PortraitH264720p30,
        #[serde(rename = "PORTRAIT_H264_720P_60")]
        PortraitH264720p60,
        #[serde(rename = "PORTRAIT_H264_1080P_30")]
        PortraitH2641080p30,
        #[serde(rename = "PORTRAIT_H264_1080P_60")]
        PortraitH2641080p60,
        #[serde(rename = "PASSTHROUGH")]
        Passthrough,
    }
    impl ::std::fmt::Display for LivekitEncodingOptionsPreset {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::H264720p30 => f.write_str("H264_720P_30"),
                Self::H264720p60 => f.write_str("H264_720P_60"),
                Self::H2641080p30 => f.write_str("H264_1080P_30"),
                Self::H2641080p60 => f.write_str("H264_1080P_60"),
                Self::PortraitH264720p30 => f.write_str("PORTRAIT_H264_720P_30"),
                Self::PortraitH264720p60 => f.write_str("PORTRAIT_H264_720P_60"),
                Self::PortraitH2641080p30 => f.write_str("PORTRAIT_H264_1080P_30"),
                Self::PortraitH2641080p60 => f.write_str("PORTRAIT_H264_1080P_60"),
                Self::Passthrough => f.write_str("PASSTHROUGH"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitEncodingOptionsPreset {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "H264_720P_30" => Ok(Self::H264720p30),
                "H264_720P_60" => Ok(Self::H264720p60),
                "H264_1080P_30" => Ok(Self::H2641080p30),
                "H264_1080P_60" => Ok(Self::H2641080p60),
                "PORTRAIT_H264_720P_30" => Ok(Self::PortraitH264720p30),
                "PORTRAIT_H264_720P_60" => Ok(Self::PortraitH264720p60),
                "PORTRAIT_H264_1080P_30" => Ok(Self::PortraitH2641080p30),
                "PORTRAIT_H264_1080P_60" => Ok(Self::PortraitH2641080p60),
                "PASSTHROUGH" => Ok(Self::Passthrough),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitEncodingOptionsPreset {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitEncodingOptionsPreset {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitFilterParams`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitFilterParams {
        #[serde(
            rename = "excludeEvents",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub exclude_events: ::std::vec::Vec<::std::string::String>,
        #[serde(
            rename = "includeEvents",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub include_events: ::std::vec::Vec<::std::string::String>,
    }
    //`LivekitGcpUpload`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitGcpUpload {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub bucket: ::std::option::Option<::std::string::String>,
        //service account credentials serialized in JSON "credentials.json"
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub credentials: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub proxy: ::std::option::Option<LivekitProxyConfig>,
    }
    //`LivekitImageCodec`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitImageCodec {
        #[serde(rename = "IC_DEFAULT")]
        IcDefault,
        #[serde(rename = "IC_JPEG")]
        IcJpeg,
    }
    impl ::std::fmt::Display for LivekitImageCodec {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::IcDefault => f.write_str("IC_DEFAULT"),
                Self::IcJpeg => f.write_str("IC_JPEG"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitImageCodec {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "IC_DEFAULT" => Ok(Self::IcDefault),
                "IC_JPEG" => Ok(Self::IcJpeg),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitImageCodec {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitImageCodec {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitImageFileSuffix`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitImageFileSuffix {
        #[serde(rename = "IMAGE_SUFFIX_INDEX")]
        ImageSuffixIndex,
        #[serde(rename = "IMAGE_SUFFIX_TIMESTAMP")]
        ImageSuffixTimestamp,
        #[serde(rename = "IMAGE_SUFFIX_NONE_OVERWRITE")]
        ImageSuffixNoneOverwrite,
    }
    impl ::std::fmt::Display for LivekitImageFileSuffix {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::ImageSuffixIndex => f.write_str("IMAGE_SUFFIX_INDEX"),
                Self::ImageSuffixTimestamp => f.write_str("IMAGE_SUFFIX_TIMESTAMP"),
                Self::ImageSuffixNoneOverwrite => f.write_str("IMAGE_SUFFIX_NONE_OVERWRITE"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitImageFileSuffix {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "IMAGE_SUFFIX_INDEX" => Ok(Self::ImageSuffixIndex),
                "IMAGE_SUFFIX_TIMESTAMP" => Ok(Self::ImageSuffixTimestamp),
                "IMAGE_SUFFIX_NONE_OVERWRITE" => Ok(Self::ImageSuffixNoneOverwrite),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitImageFileSuffix {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitImageFileSuffix {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //Capture images at a specified interval
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitImageOutput {
        Variant0 {
            #[serde(rename = "aliOSS")]
            ali_oss: LivekitAliOssUpload,
            //in seconds (required)
            #[serde(
                rename = "captureInterval",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            capture_interval: ::std::option::Option<i64>,
            //disable upload of manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //(optional)
            #[serde(
                rename = "filenamePrefix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_prefix: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "filenameSuffix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_suffix: ::std::option::Option<LivekitImageFileSuffix>,
            //(optional, defaults to track height)
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            height: ::std::option::Option<i32>,
            #[serde(rename = "imageCodec", skip_serializing_if = "::std::option::Option::is_none")]
            image_codec: ::std::option::Option<LivekitImageCodec>,
            //(optional, defaults to track width)
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            width: ::std::option::Option<i32>,
        },
        Variant1 {
            azure: LivekitAzureBlobUpload,
            //in seconds (required)
            #[serde(
                rename = "captureInterval",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            capture_interval: ::std::option::Option<i64>,
            //disable upload of manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //(optional)
            #[serde(
                rename = "filenamePrefix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_prefix: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "filenameSuffix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_suffix: ::std::option::Option<LivekitImageFileSuffix>,
            //(optional, defaults to track height)
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            height: ::std::option::Option<i32>,
            #[serde(rename = "imageCodec", skip_serializing_if = "::std::option::Option::is_none")]
            image_codec: ::std::option::Option<LivekitImageCodec>,
            //(optional, defaults to track width)
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            width: ::std::option::Option<i32>,
        },
        Variant2 {
            //in seconds (required)
            #[serde(
                rename = "captureInterval",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            capture_interval: ::std::option::Option<i64>,
            //disable upload of manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //(optional)
            #[serde(
                rename = "filenamePrefix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_prefix: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "filenameSuffix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_suffix: ::std::option::Option<LivekitImageFileSuffix>,
            gcp: LivekitGcpUpload,
            //(optional, defaults to track height)
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            height: ::std::option::Option<i32>,
            #[serde(rename = "imageCodec", skip_serializing_if = "::std::option::Option::is_none")]
            image_codec: ::std::option::Option<LivekitImageCodec>,
            //(optional, defaults to track width)
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            width: ::std::option::Option<i32>,
        },
        Variant3 {
            //in seconds (required)
            #[serde(
                rename = "captureInterval",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            capture_interval: ::std::option::Option<i64>,
            //disable upload of manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //(optional)
            #[serde(
                rename = "filenamePrefix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_prefix: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "filenameSuffix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_suffix: ::std::option::Option<LivekitImageFileSuffix>,
            //(optional, defaults to track height)
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            height: ::std::option::Option<i32>,
            #[serde(rename = "imageCodec", skip_serializing_if = "::std::option::Option::is_none")]
            image_codec: ::std::option::Option<LivekitImageCodec>,
            s3: LivekitS3Upload,
            //(optional, defaults to track width)
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            width: ::std::option::Option<i32>,
        },
    }
    //`LivekitJobRestartPolicy`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitJobRestartPolicy {
        #[serde(rename = "JRP_ON_FAILURE")]
        JrpOnFailure,
        #[serde(rename = "JRP_NEVER")]
        JrpNever,
    }
    impl ::std::fmt::Display for LivekitJobRestartPolicy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::JrpOnFailure => f.write_str("JRP_ON_FAILURE"),
                Self::JrpNever => f.write_str("JRP_NEVER"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitJobRestartPolicy {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "JRP_ON_FAILURE" => Ok(Self::JrpOnFailure),
                "JRP_NEVER" => Ok(Self::JrpNever),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitJobRestartPolicy {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitJobRestartPolicy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitPresignedPostRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPresignedPostRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub values: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    }
    //`LivekitPresignedPostRequestValuesEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPresignedPostRequestValuesEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //`LivekitProxyConfig`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitProxyConfig {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub password: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub username: ::std::option::Option<::std::string::String>,
    }
    /*AgentAnalytics is one agent's analytics over a time range. Common concerns are
    grouped so they read the same whether you fetch one agent or the whole roster:
    `sessions`, `performance`, and `usage` are always found under those names.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1AgentAnalytics {
        #[serde(rename = "agentId", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub performance:
            ::std::option::Option<LivekitPublicapiAnalyticsV1AgentAnalyticsPerformance>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub sessions: ::std::option::Option<LivekitPublicapiAnalyticsV1AgentAnalyticsSessions>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub usage: ::std::option::Option<LivekitPublicapiAnalyticsV1AgentAnalyticsUsage>,
    }
    //`LivekitPublicapiAnalyticsV1AgentAnalyticsPerformance`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1AgentAnalyticsPerformance {
        //Fraction 0..1 of turns the user interrupted the agent.
        #[serde(
            rename = "interruptedRate",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub interrupted_rate: ::std::option::Option<f64>,
        #[serde(rename = "joinLatency", skip_serializing_if = "::std::option::Option::is_none")]
        pub join_latency: ::std::option::Option<LivekitPublicapiAnalyticsV1Percentiles>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub latency: ::std::option::Option<LivekitPublicapiAnalyticsV1LatencyBreakdown>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub turns: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiAnalyticsV1AgentAnalyticsSessions`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1AgentAnalyticsSessions {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub active: ::std::option::Option<::std::string::String>,
        #[serde(rename = "dispatchErrors", skip_serializing_if = "::std::option::Option::is_none")]
        pub dispatch_errors: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub estimate: ::std::option::Option<LivekitPublicapiAnalyticsV1Estimate>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub total: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiAnalyticsV1AgentAnalyticsUsage`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1AgentAnalyticsUsage {
        #[serde(
            rename = "avgTokensPerSession",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub avg_tokens_per_session: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub models: ::std::vec::Vec<LivekitPublicapiAnalyticsV1ModelUsage>,
    }
    //`LivekitPublicapiAnalyticsV1AgentsGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1AgentsGetRequest {
        #[serde(rename = "agentId", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub range: ::std::option::Option<LivekitPublicapiAnalyticsV1TimeRange>,
    }
    //`LivekitPublicapiAnalyticsV1AgentsGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1AgentsGetResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub analytics: ::std::option::Option<LivekitPublicapiAnalyticsV1AgentAnalytics>,
    }
    //`LivekitPublicapiAnalyticsV1AgentsListRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1AgentsListRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub range: ::std::option::Option<LivekitPublicapiAnalyticsV1TimeRange>,
    }
    //`LivekitPublicapiAnalyticsV1AgentsListResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1AgentsListResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiAnalyticsV1AgentAnalytics>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    //CountryCount is a per-country connection count for the top-countries breakdown.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1CountryCount {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub count: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
    }
    //DataPoint is one point of a per-session time series (quality, bandwidth, fps).
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1DataPoint {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub timestamp: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<f64>,
    }
    /*Estimate flags a value that is approximate over large windows, with its
    tolerance. A consumer should not treat an estimated value as exact.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1Estimate {
        //Fractional tolerance (e.g. 0.01 for +/-1%). Zero when unknown.
        #[serde(rename = "errorMargin", skip_serializing_if = "::std::option::Option::is_none")]
        pub error_margin: ::std::option::Option<f64>,
        #[serde(rename = "isEstimate", skip_serializing_if = "::std::option::Option::is_none")]
        pub is_estimate: ::std::option::Option<bool>,
    }
    //LatencyBreakdown is where an average agent reply's time goes, in milliseconds.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1LatencyBreakdown {
        #[serde(rename = "avgReplyMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub avg_reply_ms: ::std::option::Option<f64>,
        #[serde(rename = "eouMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub eou_ms: ::std::option::Option<f64>,
        #[serde(rename = "llmTtftMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub llm_ttft_ms: ::std::option::Option<f64>,
        #[serde(rename = "sttDelayMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub stt_delay_ms: ::std::option::Option<f64>,
        #[serde(rename = "ttsTtfbMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub tts_ttfb_ms: ::std::option::Option<f64>,
    }
    /*ModelUsage is per-model usage over the window. `component` is the stage the
    model served (llm, tts, realtime); latency is TTFT for llm/realtime rows and
    TTFB for tts rows.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1ModelUsage {
        #[serde(rename = "cachedTokens", skip_serializing_if = "::std::option::Option::is_none")]
        pub cached_tokens: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub component: ::std::option::Option<::std::string::String>,
        #[serde(rename = "inTokens", skip_serializing_if = "::std::option::Option::is_none")]
        pub in_tokens: ::std::option::Option<::std::string::String>,
        #[serde(rename = "latencyP50Ms", skip_serializing_if = "::std::option::Option::is_none")]
        pub latency_p50_ms: ::std::option::Option<f64>,
        #[serde(rename = "latencyP95Ms", skip_serializing_if = "::std::option::Option::is_none")]
        pub latency_p95_ms: ::std::option::Option<f64>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub model: ::std::option::Option<::std::string::String>,
        #[serde(rename = "outTokens", skip_serializing_if = "::std::option::Option::is_none")]
        pub out_tokens: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub provider: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub requests: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub sessions: ::std::option::Option<::std::string::String>,
        #[serde(rename = "ttsChars", skip_serializing_if = "::std::option::Option::is_none")]
        pub tts_chars: ::std::option::Option<::std::string::String>,
    }
    /*ParticipantInfo is one participant identity of a room session, as the
    dashboard's participants table shows it.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1ParticipantInfo {
        #[serde(rename = "joinedAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub joined_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(rename = "leftAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub left_at: ::std::option::Option<::pbjson_types::Timestamp>,
        //Country name, e.g. "United States"; "Unknown" when the rollup has none.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub location: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "participantIdentity",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub participant_identity: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "participantName",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub participant_name: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "publishedSources",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub published_sources: ::std::option::Option<LivekitPublicapiAnalyticsV1PublishedSources>,
        //LiveKit region display name; "Unknown" when the region isn't recognized.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        /*The participant's participant sessions, oldest join first: one per
        connection, so each reconnect adds one. At most 50: a participant that
        reconnected more often has its oldest 50 here. Empty when they couldn't be
        read; the rest of the row still returns.*/
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub sessions: ::std::vec::Vec<LivekitPublicapiAnalyticsV1ParticipantSession>,
    }
    /*ParticipantSession is one participant session of a participant: one
    join-to-leave stretch, identified by its participant session id (PA_...),
    with the client it connected from. A participant that reconnects, from the
    same device or another, has several.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1ParticipantSession {
        //Client browser, e.g. "chrome".
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub browser: ::std::option::Option<::std::string::String>,
        //Milliseconds the client took to connect.
        #[serde(
            rename = "connectionTimeMs",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub connection_time_ms: ::std::option::Option<i32>,
        /*Transport the client connected over: "UDP", "TCP" or "TURN"; empty when
        not reported.*/
        #[serde(rename = "connectionType", skip_serializing_if = "::std::option::Option::is_none")]
        pub connection_type: ::std::option::Option<::std::string::String>,
        //Client device model, e.g. "iPhone 15".
        #[serde(rename = "deviceModel", skip_serializing_if = "::std::option::Option::is_none")]
        pub device_model: ::std::option::Option<::std::string::String>,
        /*Seconds from joined_at to left_at, as the dashboard counts them. While no
        leave is recorded, to the session's end once it has one, else to now.*/
        #[serde(
            rename = "durationSeconds",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub duration_seconds: ::std::option::Option<::std::string::String>,
        #[serde(rename = "joinedAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub joined_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(rename = "leftAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub left_at: ::std::option::Option<::pbjson_types::Timestamp>,
        //Country name, e.g. "United States"; "Unknown" when the rollup has none.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub location: ::std::option::Option<::std::string::String>,
        /*Client operating system: "ios", "android", "windows", "mac" or "linux";
        empty when not reported.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub os: ::std::option::Option<::std::string::String>,
        //The participant session id (PA_...).
        #[serde(
            rename = "participantSessionId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub participant_session_id: ::std::option::Option<::std::string::String>,
        //LiveKit region display name; "Unknown" when the region isn't recognized.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        //LiveKit client SDK version, e.g. "2.6.1". The SDK's name isn't recorded.
        #[serde(rename = "sdkVersion", skip_serializing_if = "::std::option::Option::is_none")]
        pub sdk_version: ::std::option::Option<::std::string::String>,
    }
    //ParticipantSortField is the column a participant listing is ordered by.
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitPublicapiAnalyticsV1ParticipantSortField {
        #[serde(rename = "PARTICIPANT_SORT_FIELD_UNSPECIFIED")]
        ParticipantSortFieldUnspecified,
        #[serde(rename = "PARTICIPANT_SORT_FIELD_JOINED_AT")]
        ParticipantSortFieldJoinedAt,
        #[serde(rename = "PARTICIPANT_SORT_FIELD_LEFT_AT")]
        ParticipantSortFieldLeftAt,
    }
    impl ::std::fmt::Display for LivekitPublicapiAnalyticsV1ParticipantSortField {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::ParticipantSortFieldUnspecified => {
                    f.write_str("PARTICIPANT_SORT_FIELD_UNSPECIFIED")
                }
                Self::ParticipantSortFieldJoinedAt => {
                    f.write_str("PARTICIPANT_SORT_FIELD_JOINED_AT")
                }
                Self::ParticipantSortFieldLeftAt => f.write_str("PARTICIPANT_SORT_FIELD_LEFT_AT"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitPublicapiAnalyticsV1ParticipantSortField {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "PARTICIPANT_SORT_FIELD_UNSPECIFIED" => Ok(Self::ParticipantSortFieldUnspecified),
                "PARTICIPANT_SORT_FIELD_JOINED_AT" => Ok(Self::ParticipantSortFieldJoinedAt),
                "PARTICIPANT_SORT_FIELD_LEFT_AT" => Ok(Self::ParticipantSortFieldLeftAt),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitPublicapiAnalyticsV1ParticipantSortField {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
        for LivekitPublicapiAnalyticsV1ParticipantSortField
    {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //Percentiles is a p50/p90/p99 triple in milliseconds.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1Percentiles {
        #[serde(rename = "p50Ms", skip_serializing_if = "::std::option::Option::is_none")]
        pub p50_ms: ::std::option::Option<f64>,
        #[serde(rename = "p90Ms", skip_serializing_if = "::std::option::Option::is_none")]
        pub p90_ms: ::std::option::Option<f64>,
        #[serde(rename = "p99Ms", skip_serializing_if = "::std::option::Option::is_none")]
        pub p99_ms: ::std::option::Option<f64>,
    }
    //PlatformShare is a per-platform share of connections (fraction 0..1).
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1PlatformShare {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub share: ::std::option::Option<f64>,
    }
    /*ProjectAnalytics is the project overview over a time range, grouped the same
    way: `sessions` and `participants`.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1ProjectAnalytics {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub participants:
            ::std::option::Option<LivekitPublicapiAnalyticsV1ProjectAnalyticsParticipants>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub sessions: ::std::option::Option<LivekitPublicapiAnalyticsV1ProjectAnalyticsSessions>,
    }
    //`LivekitPublicapiAnalyticsV1ProjectAnalyticsParticipants`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1ProjectAnalyticsParticipants {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub platforms: ::std::vec::Vec<LivekitPublicapiAnalyticsV1PlatformShare>,
        #[serde(
            rename = "topCountries",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub top_countries: ::std::vec::Vec<LivekitPublicapiAnalyticsV1CountryCount>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub total: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiAnalyticsV1ProjectAnalyticsSessions`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1ProjectAnalyticsSessions {
        #[serde(rename = "agentMinutes", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_minutes: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "avgDurationSeconds",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub avg_duration_seconds: ::std::option::Option<f64>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub served: ::std::option::Option<::std::string::String>,
        #[serde(rename = "withAgents", skip_serializing_if = "::std::option::Option::is_none")]
        pub with_agents: ::std::option::Option<::std::string::String>,
        #[serde(rename = "withTelephony", skip_serializing_if = "::std::option::Option::is_none")]
        pub with_telephony: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiAnalyticsV1ProjectOverviewGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1ProjectOverviewGetRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub range: ::std::option::Option<LivekitPublicapiAnalyticsV1TimeRange>,
    }
    //`LivekitPublicapiAnalyticsV1ProjectOverviewGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1ProjectOverviewGetResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub analytics: ::std::option::Option<LivekitPublicapiAnalyticsV1ProjectAnalytics>,
    }
    //PublishedSources is which track sources a participant published.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1PublishedSources {
        #[serde(rename = "cameraTrack", skip_serializing_if = "::std::option::Option::is_none")]
        pub camera_track: ::std::option::Option<bool>,
        #[serde(
            rename = "microphoneTrack",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub microphone_track: ::std::option::Option<bool>,
        #[serde(
            rename = "screenShareAudio",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub screen_share_audio: ::std::option::Option<bool>,
        #[serde(
            rename = "screenShareTrack",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub screen_share_track: ::std::option::Option<bool>,
    }
    /*Session is one room-session list row. Bandwidth and connection time are on
    GetSession's detail only.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1Session {
        #[serde(rename = "endedAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub ended_at: ::std::option::Option<::pbjson_types::Timestamp>,
        /*False while the session's full detail (end time, participant counts,
        duration) is still being finalized; the detail endpoints are complete once
        it is true.*/
        #[serde(rename = "hasDetailData", skip_serializing_if = "::std::option::Option::is_none")]
        pub has_detail_data: ::std::option::Option<bool>,
        #[serde(rename = "lastActive", skip_serializing_if = "::std::option::Option::is_none")]
        pub last_active: ::std::option::Option<::pbjson_types::Timestamp>,
        /*Distinct participants (by identity) connected for more than zero seconds
        during the session. Not a live count: a closed session keeps its total.*/
        #[serde(
            rename = "numParticipants",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub num_participants: ::std::option::Option<i32>,
        #[serde(rename = "roomName", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_name: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "startedAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub started_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<LivekitPublicapiAnalyticsV1SessionStatus>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub tags: ::std::vec::Vec<::std::string::String>,
    }
    /*SessionDetail is the richer per-session view: a superset of Session with the
    room id, totals, the first page of participants, and per-metric timelines.
    The timelines share one grid sized from the session's length, the
    dashboard's: one point per bucket, 0 where a bucket has no data.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionDetail {
        //Bytes participants published, all track types.
        #[serde(rename = "bandwidthIn", skip_serializing_if = "::std::option::Option::is_none")]
        pub bandwidth_in: ::std::option::Option<::std::string::String>,
        //Bytes participants subscribed to, all track types.
        #[serde(rename = "bandwidthOut", skip_serializing_if = "::std::option::Option::is_none")]
        pub bandwidth_out: ::std::option::Option<::std::string::String>,
        /*WebRTC connection time in seconds, summed over standard participants and
        self-hosted agents (cloud agents excluded), as the dashboard counts it.*/
        #[serde(
            rename = "connectionSeconds",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub connection_seconds: ::std::option::Option<::std::string::String>,
        #[serde(rename = "endedAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub ended_at: ::std::option::Option<::pbjson_types::Timestamp>,
        //Same count as Session.num_participants.
        #[serde(
            rename = "numParticipants",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub num_participants: ::std::option::Option<i32>,
        /*The first page of participants, newest join first (at most 50). When
        participants_page.has_more, continue with ListSessionParticipants: pass
        participants_page.next_cursor as page.cursor, with sort_by and sort_order
        unset (or joined_at descending, the same thing).*/
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub participants: ::std::vec::Vec<LivekitPublicapiAnalyticsV1ParticipantInfo>,
        #[serde(
            rename = "participantsPage",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub participants_page: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
        //Published audio plus video bitrate, in bits per second.
        #[serde(rename = "publishBps", default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub publish_bps: ::std::vec::Vec<LivekitPublicapiAnalyticsV1DataPoint>,
        //Published video frame rate.
        #[serde(rename = "publishFps", default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub publish_fps: ::std::vec::Vec<LivekitPublicapiAnalyticsV1DataPoint>,
        //Average connection quality as a 0-1 fraction of the 0-5 track score.
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub quality: ::std::vec::Vec<LivekitPublicapiAnalyticsV1DataPoint>,
        #[serde(rename = "roomName", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_name: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "startedAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub started_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<LivekitPublicapiAnalyticsV1SessionStatus>,
        //Subscribed audio plus video bitrate, in bits per second.
        #[serde(
            rename = "subscribeBps",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub subscribe_bps: ::std::vec::Vec<LivekitPublicapiAnalyticsV1DataPoint>,
        //Subscribed video frame rate.
        #[serde(
            rename = "subscribeFps",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub subscribe_fps: ::std::vec::Vec<LivekitPublicapiAnalyticsV1DataPoint>,
        //The session's tags, as on Session.
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub tags: ::std::vec::Vec<::std::string::String>,
    }
    /*SessionEvent is one event of a room session, such as a participant joining
    or a track being published.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionEvent {
        /*The identity of the participant the event is about; empty for a room
        event, or an API call that names no participant.*/
        #[serde(
            rename = "participantIdentity",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub participant_identity: ::std::option::Option<::std::string::String>,
        /*The participant session (PA_...) the event is about; empty when
        participant_identity is.*/
        #[serde(
            rename = "participantSessionId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub participant_session_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub payload: ::std::option::Option<GoogleProtobufStruct>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub timestamp: ::std::option::Option<::pbjson_types::Timestamp>,
        //The event's type, an AnalyticsEventType name such as PARTICIPANT_JOINED.
        #[serde(rename = "type", skip_serializing_if = "::std::option::Option::is_none")]
        pub type_: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiAnalyticsV1SessionEventsListRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionEventsListRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        /*Only the events of this participant session (PA_...), as the
        participants list's ParticipantSession.participant_session_id names
        it. Room events and API calls name no participant session, so they
        are left out. Anything but a PA_ id is InvalidArgument.*/
        #[serde(
            rename = "participantSessionId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub participant_session_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sortOrder", skip_serializing_if = "::std::option::Option::is_none")]
        pub sort_order: ::std::option::Option<LivekitPublicapiCommonV1SortOrder>,
        /*Event types to return, by name, such as TRACK_PUBLISHED: the names of
        LiveKit's AnalyticsEventType. Each matches exactly. Empty returns the
        dashboard's seven defaults, or with participant_session_id its eleven
        participant defaults, track events included (see ListSessionEvents).
        An unknown name is InvalidArgument.*/
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub types: ::std::vec::Vec<::std::string::String>,
    }
    //`LivekitPublicapiAnalyticsV1SessionEventsListResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionEventsListResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiAnalyticsV1SessionEvent>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    /*SessionFilter narrows a session listing. Only these fields are filterable
    upstream (the rest are rollup-stage values that would break keyset paging).*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionFilter {
        //Cloud agent id (CA_...) — return only sessions this agent served. Duration is not filterable in v1.
        #[serde(rename = "agentId", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub range: ::std::option::Option<LivekitPublicapiAnalyticsV1TimeRange>,
        /*Room-name prefix match (case-sensitive): returns sessions whose room name
        starts with this value, e.g. `demo-` matches `demo-1` and `demo-lobby`.*/
        #[serde(rename = "roomName", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_name: ::std::option::Option<::std::string::String>,
        //Exact room-session id match (RM_...).
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
        //OR semantics; empty matches any status.
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub statuses: ::std::vec::Vec<LivekitPublicapiAnalyticsV1SessionStatus>,
        //OR semantics.
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub tags: ::std::vec::Vec<::std::string::String>,
    }
    //`LivekitPublicapiAnalyticsV1SessionParticipantsListRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionParticipantsListRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sortBy", skip_serializing_if = "::std::option::Option::is_none")]
        pub sort_by: ::std::option::Option<LivekitPublicapiAnalyticsV1ParticipantSortField>,
        #[serde(rename = "sortOrder", skip_serializing_if = "::std::option::Option::is_none")]
        pub sort_order: ::std::option::Option<LivekitPublicapiCommonV1SortOrder>,
    }
    //`LivekitPublicapiAnalyticsV1SessionParticipantsListResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionParticipantsListResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiAnalyticsV1ParticipantInfo>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    //SessionStatus is the lifecycle state of a session.
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitPublicapiAnalyticsV1SessionStatus {
        #[serde(rename = "SESSION_STATUS_UNSPECIFIED")]
        SessionStatusUnspecified,
        #[serde(rename = "SESSION_STATUS_ACTIVE")]
        SessionStatusActive,
        #[serde(rename = "SESSION_STATUS_CLOSED")]
        SessionStatusClosed,
    }
    impl ::std::fmt::Display for LivekitPublicapiAnalyticsV1SessionStatus {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::SessionStatusUnspecified => f.write_str("SESSION_STATUS_UNSPECIFIED"),
                Self::SessionStatusActive => f.write_str("SESSION_STATUS_ACTIVE"),
                Self::SessionStatusClosed => f.write_str("SESSION_STATUS_CLOSED"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitPublicapiAnalyticsV1SessionStatus {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "SESSION_STATUS_UNSPECIFIED" => Ok(Self::SessionStatusUnspecified),
                "SESSION_STATUS_ACTIVE" => Ok(Self::SessionStatusActive),
                "SESSION_STATUS_CLOSED" => Ok(Self::SessionStatusClosed),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitPublicapiAnalyticsV1SessionStatus {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitPublicapiAnalyticsV1SessionStatus {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitPublicapiAnalyticsV1SessionsGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionsGetRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiAnalyticsV1SessionsGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionsGetResponse {
        /*Absent while the session's detail is still being finalized (see
        Session.has_detail_data on the list row).*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub detail: ::std::option::Option<LivekitPublicapiAnalyticsV1SessionDetail>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub session: ::std::option::Option<LivekitPublicapiAnalyticsV1Session>,
    }
    //`LivekitPublicapiAnalyticsV1SessionsListRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionsListRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub filter: ::std::option::Option<LivekitPublicapiAnalyticsV1SessionFilter>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sortOrder", skip_serializing_if = "::std::option::Option::is_none")]
        pub sort_order: ::std::option::Option<LivekitPublicapiCommonV1SortOrder>,
    }
    //`LivekitPublicapiAnalyticsV1SessionsListResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1SessionsListResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiAnalyticsV1Session>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    /*TimeRange is a half-open window [start_time, end_time). An unset end means
    "now"; an unset start means "end minus a service default" (24h for session
    lists, 7d for stats). Windows are bounded server-side (stats: 62 days).*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiAnalyticsV1TimeRange {
        #[serde(rename = "endTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub end_time: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(rename = "startTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub start_time: ::std::option::Option<::pbjson_types::Timestamp>,
    }
    //PageInfo is the cursor-pagination metadata shared by every list response.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiCommonV1PageInfo {
        #[serde(rename = "hasMore", skip_serializing_if = "::std::option::Option::is_none")]
        pub has_more: ::std::option::Option<bool>,
        /*Pass as `cursor` on the next request to fetch the following page. Empty on
        the last page.*/
        #[serde(rename = "nextCursor", skip_serializing_if = "::std::option::Option::is_none")]
        pub next_cursor: ::std::option::Option<::std::string::String>,
    }
    /*PageRequest is the shared cursor-pagination request fragment. Embed it in a
    list request.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiCommonV1PageRequest {
        /*Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
        from the beginning.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub cursor: ::std::option::Option<::std::string::String>,
        //Maximum items to return; 0 lets the server pick a default.
        #[serde(rename = "pageSize", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_size: ::std::option::Option<i32>,
    }
    /*SortOrder is the direction of a list request's sort. A list that lets the
    caller pick a direction takes it as `sort_order` and documents its default
    column and direction; one that can also sort on more than one column adds
    its own `<X>SortField sort_by`.*/
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitPublicapiCommonV1SortOrder {
        #[serde(rename = "SORT_ORDER_UNSPECIFIED")]
        SortOrderUnspecified,
        #[serde(rename = "SORT_ORDER_ASC")]
        SortOrderAsc,
        #[serde(rename = "SORT_ORDER_DESC")]
        SortOrderDesc,
    }
    impl ::std::fmt::Display for LivekitPublicapiCommonV1SortOrder {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::SortOrderUnspecified => f.write_str("SORT_ORDER_UNSPECIFIED"),
                Self::SortOrderAsc => f.write_str("SORT_ORDER_ASC"),
                Self::SortOrderDesc => f.write_str("SORT_ORDER_DESC"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitPublicapiCommonV1SortOrder {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "SORT_ORDER_UNSPECIFIED" => Ok(Self::SortOrderUnspecified),
                "SORT_ORDER_ASC" => Ok(Self::SortOrderAsc),
                "SORT_ORDER_DESC" => Ok(Self::SortOrderDesc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitPublicapiCommonV1SortOrder {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitPublicapiCommonV1SortOrder {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitPublicapiDatabasesV1DatabasesCreateRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiDatabasesV1DatabasesCreateRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub ttl: ::std::option::Option<::pbjson_types::Duration>,
    }
    //`LivekitPublicapiDatabasesV1DatabasesCreateResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiDatabasesV1DatabasesCreateResponse {
        #[serde(rename = "databaseId", skip_serializing_if = "::std::option::Option::is_none")]
        pub database_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "expiresAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub expires_at: ::std::option::Option<::pbjson_types::Timestamp>,
    }
    //`LivekitPublicapiDatabasesV1DatabasesDeleteRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiDatabasesV1DatabasesDeleteRequest {
        #[serde(rename = "databaseId", skip_serializing_if = "::std::option::Option::is_none")]
        pub database_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiDatabasesV1DatabasesDeleteResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiDatabasesV1DatabasesDeleteResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiDatabasesV1DatabasesDeleteResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiDatabasesV1DatabasesDeleteResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiDatabasesV1DatabasesDeleteResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiDatabasesV1DatabasesDeleteResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiDatabasesV1DatabasesExportRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiDatabasesV1DatabasesExportRequest {
        #[serde(rename = "databaseId", skip_serializing_if = "::std::option::Option::is_none")]
        pub database_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiDatabasesV1DatabasesExportResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiDatabasesV1DatabasesExportResponse {
        //Pre-authenticated object-storage URL.
        #[serde(rename = "downloadUrl", skip_serializing_if = "::std::option::Option::is_none")]
        pub download_url: ::std::option::Option<::std::string::String>,
        #[serde(rename = "expiresAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub expires_at: ::std::option::Option<::pbjson_types::Timestamp>,
        //The commit sequence the export is consistent at.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub tip: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiDatabasesV1DatabasesGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiDatabasesV1DatabasesGetRequest {
        #[serde(rename = "databaseId", skip_serializing_if = "::std::option::Option::is_none")]
        pub database_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiDatabasesV1DatabasesGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiDatabasesV1DatabasesGetResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub database: ::std::option::Option<::livekit_protocol::agent_db::AgentDatabase>,
    }
    //`LivekitPublicapiDatabasesV1DatabasesListRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiDatabasesV1DatabasesListRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiDatabasesV1DatabasesListResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiDatabasesV1DatabasesListResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<::livekit_protocol::agent_db::AgentDatabase>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    /*LogLevel is a log record's level, as the dashboard's logs panel shows and
    filters it. Agents name levels differently by runtime, such as Python's
    CRITICAL and Node's FATAL, so a record's level comes from its OpenTelemetry
    severity number, or from its level name when it has none; a level means the
    same for Python and Node agents.*/
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitPublicapiObservabilityV1LogLevel {
        #[serde(rename = "LOG_LEVEL_UNSPECIFIED")]
        LogLevelUnspecified,
        #[serde(rename = "LOG_LEVEL_TRACE")]
        LogLevelTrace,
        #[serde(rename = "LOG_LEVEL_DEBUG")]
        LogLevelDebug,
        #[serde(rename = "LOG_LEVEL_INFO")]
        LogLevelInfo,
        #[serde(rename = "LOG_LEVEL_WARN")]
        LogLevelWarn,
        #[serde(rename = "LOG_LEVEL_ERROR")]
        LogLevelError,
        #[serde(rename = "LOG_LEVEL_FATAL")]
        LogLevelFatal,
    }
    impl ::std::fmt::Display for LivekitPublicapiObservabilityV1LogLevel {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::LogLevelUnspecified => f.write_str("LOG_LEVEL_UNSPECIFIED"),
                Self::LogLevelTrace => f.write_str("LOG_LEVEL_TRACE"),
                Self::LogLevelDebug => f.write_str("LOG_LEVEL_DEBUG"),
                Self::LogLevelInfo => f.write_str("LOG_LEVEL_INFO"),
                Self::LogLevelWarn => f.write_str("LOG_LEVEL_WARN"),
                Self::LogLevelError => f.write_str("LOG_LEVEL_ERROR"),
                Self::LogLevelFatal => f.write_str("LOG_LEVEL_FATAL"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitPublicapiObservabilityV1LogLevel {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "LOG_LEVEL_UNSPECIFIED" => Ok(Self::LogLevelUnspecified),
                "LOG_LEVEL_TRACE" => Ok(Self::LogLevelTrace),
                "LOG_LEVEL_DEBUG" => Ok(Self::LogLevelDebug),
                "LOG_LEVEL_INFO" => Ok(Self::LogLevelInfo),
                "LOG_LEVEL_WARN" => Ok(Self::LogLevelWarn),
                "LOG_LEVEL_ERROR" => Ok(Self::LogLevelError),
                "LOG_LEVEL_FATAL" => Ok(Self::LogLevelFatal),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitPublicapiObservabilityV1LogLevel {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitPublicapiObservabilityV1LogLevel {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //LogRecord is one log record a session's agent exported.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1LogRecord {
        /*The record's attributes, typed and nested as the agent recorded them,
        with its resource's and scope's attributes merged in; the record's own
        value wins. An integer beyond ±2^53 is its decimal string, and bytes are
        base64.*/
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub attributes: ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>,
        /*A structured logger's body fields other than its message; empty for a
        plain text body.*/
        #[serde(
            rename = "bodyFields",
            default,
            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
        )]
        pub body_fields: ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>,
        //The record's id, the same on every read.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub level: ::std::option::Option<LivekitPublicapiObservabilityV1LogLevel>,
        //The logger that wrote the record (its logger.name attribute).
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub logger: ::std::option::Option<::std::string::String>,
        /*The record's text. A structured logger's body keeps it under its event,
        message or msg field; a structured body with none of them is written
        here whole, as JSON.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub message: ::std::option::Option<::std::string::String>,
        //The level's name as the agent logged it, such as "WARN" or "CRITICAL".
        #[serde(rename = "severityText", skip_serializing_if = "::std::option::Option::is_none")]
        pub severity_text: ::std::option::Option<::std::string::String>,
        #[serde(rename = "spanId", skip_serializing_if = "::std::option::Option::is_none")]
        pub span_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub timestamp: ::std::option::Option<::pbjson_types::Timestamp>,
        /*The trace and span the record was logged in, as lowercase hex; empty when
        it was logged outside one. They link the record to its span in
        GetSessionTraces.*/
        #[serde(rename = "traceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub trace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiObservabilityV1LogRecordAttributesEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1LogRecordAttributesEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<GoogleProtobufValue>,
    }
    //`LivekitPublicapiObservabilityV1LogRecordBodyFieldsEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1LogRecordBodyFieldsEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<GoogleProtobufValue>,
    }
    //`LivekitPublicapiObservabilityV1LogsGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1LogsGetRequest {
        /*Only records at these levels, as the dashboard's logs filter selects
        them, for example only TRACE and FATAL. Empty returns every record,
        including those with no level, such as a passed evaluation.
        LOG_LEVEL_UNSPECIFIED is InvalidArgument.*/
        #[serde(rename = "logLevels", default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub log_levels: ::std::vec::Vec<LivekitPublicapiObservabilityV1LogLevel>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        //The session's RM_ id.
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sortOrder", skip_serializing_if = "::std::option::Option::is_none")]
        pub sort_order: ::std::option::Option<LivekitPublicapiCommonV1SortOrder>,
    }
    //`LivekitPublicapiObservabilityV1LogsGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1LogsGetResponse {
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub records: ::std::vec::Vec<LivekitPublicapiObservabilityV1LogRecord>,
    }
    //MetricHistogram summarizes the values a histogram point recorded.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1MetricHistogram {
        /*A histogram's buckets, with one more count than bounds: bucket_counts[0]
        counts the values up to bucket_bounds[0], bucket_counts[i] those in
        (bucket_bounds[i-1], bucket_bounds[i]], and the last count those above
        the last bound. Both are empty for an exponential histogram.*/
        #[serde(
            rename = "bucketBounds",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub bucket_bounds: ::std::vec::Vec<f64>,
        #[serde(
            rename = "bucketCounts",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub bucket_counts: ::std::vec::Vec<::std::string::String>,
        //How many values were recorded.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub count: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub max: ::std::option::Option<f64>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub min: ::std::option::Option<f64>,
        //Their sum, minimum and maximum; unset when the agent didn't record them.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub sum: ::std::option::Option<f64>,
    }
    //MetricKind is the OpenTelemetry data type a metric point was exported as.
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitPublicapiObservabilityV1MetricKind {
        #[serde(rename = "METRIC_KIND_UNSPECIFIED")]
        MetricKindUnspecified,
        #[serde(rename = "METRIC_KIND_GAUGE")]
        MetricKindGauge,
        #[serde(rename = "METRIC_KIND_SUM")]
        MetricKindSum,
        #[serde(rename = "METRIC_KIND_HISTOGRAM")]
        MetricKindHistogram,
        #[serde(rename = "METRIC_KIND_EXPONENTIAL_HISTOGRAM")]
        MetricKindExponentialHistogram,
    }
    impl ::std::fmt::Display for LivekitPublicapiObservabilityV1MetricKind {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::MetricKindUnspecified => f.write_str("METRIC_KIND_UNSPECIFIED"),
                Self::MetricKindGauge => f.write_str("METRIC_KIND_GAUGE"),
                Self::MetricKindSum => f.write_str("METRIC_KIND_SUM"),
                Self::MetricKindHistogram => f.write_str("METRIC_KIND_HISTOGRAM"),
                Self::MetricKindExponentialHistogram => {
                    f.write_str("METRIC_KIND_EXPONENTIAL_HISTOGRAM")
                }
            }
        }
    }
    impl ::std::str::FromStr for LivekitPublicapiObservabilityV1MetricKind {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "METRIC_KIND_UNSPECIFIED" => Ok(Self::MetricKindUnspecified),
                "METRIC_KIND_GAUGE" => Ok(Self::MetricKindGauge),
                "METRIC_KIND_SUM" => Ok(Self::MetricKindSum),
                "METRIC_KIND_HISTOGRAM" => Ok(Self::MetricKindHistogram),
                "METRIC_KIND_EXPONENTIAL_HISTOGRAM" => Ok(Self::MetricKindExponentialHistogram),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitPublicapiObservabilityV1MetricKind {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitPublicapiObservabilityV1MetricKind {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    /*MetricPoint is one OpenTelemetry metric data point a session's agent
    exported. It is the raw metric the agent emits, so it won't exactly match
    the dashboard's metrics panel, which derives its numbers from the transcript
    and traces. Only agents that export OpenTelemetry metrics to LiveKit Cloud
    produce points; an agent whose code installs its own MeterProvider exports
    none to LiveKit Cloud.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitPublicapiObservabilityV1MetricPoint {
        Variant0 {
            /*The point's attributes, typed and nested as the agent recorded them, with
            its resource's and scope's attributes merged in, such as room_id, job_id,
            lk.agent_name and the model's model_name; the point's own value wins. With
            two agents in one session, the resource's can be the other agent's. An
            integer beyond ±2^53 is its decimal string, and bytes are base64.*/
            #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
            attributes: ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>,
            #[serde(rename = "endTime", skip_serializing_if = "::std::option::Option::is_none")]
            end_time: ::std::option::Option<::pbjson_types::Timestamp>,
            histogram: LivekitPublicapiObservabilityV1MetricHistogram,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            kind: ::std::option::Option<LivekitPublicapiObservabilityV1MetricKind>,
            /*The metric's name, such as lk.agents.turn.e2e_latency or
            gen_ai.client.token.usage. The upstream aggregator can file several
            metrics that share their attributes under one name (GetSessionMetrics).*/
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            name: ::std::option::Option<::std::string::String>,
            #[serde(rename = "startTime", skip_serializing_if = "::std::option::Option::is_none")]
            start_time: ::std::option::Option<::pbjson_types::Timestamp>,
            /*The metric's unit as the agent declared it, such as "s" or "{token}";
            empty when it declared none.*/
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            unit: ::std::option::Option<::std::string::String>,
        },
        Variant1 {
            /*The point's attributes, typed and nested as the agent recorded them, with
            its resource's and scope's attributes merged in, such as room_id, job_id,
            lk.agent_name and the model's model_name; the point's own value wins. With
            two agents in one session, the resource's can be the other agent's. An
            integer beyond ±2^53 is its decimal string, and bytes are base64.*/
            #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
            attributes: ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>,
            #[serde(rename = "endTime", skip_serializing_if = "::std::option::Option::is_none")]
            end_time: ::std::option::Option<::pbjson_types::Timestamp>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            kind: ::std::option::Option<LivekitPublicapiObservabilityV1MetricKind>,
            /*The metric's name, such as lk.agents.turn.e2e_latency or
            gen_ai.client.token.usage. The upstream aggregator can file several
            metrics that share their attributes under one name (GetSessionMetrics).*/
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            name: ::std::option::Option<::std::string::String>,
            #[serde(rename = "startTime", skip_serializing_if = "::std::option::Option::is_none")]
            start_time: ::std::option::Option<::pbjson_types::Timestamp>,
            /*The metric's unit as the agent declared it, such as "s" or "{token}";
            empty when it declared none.*/
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            unit: ::std::option::Option<::std::string::String>,
            //A gauge's or sum's value.
            value: f64,
        },
    }
    //`LivekitPublicapiObservabilityV1MetricPointAttributesEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1MetricPointAttributesEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<GoogleProtobufValue>,
    }
    //`LivekitPublicapiObservabilityV1MetricsGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1MetricsGetRequest {
        /*Only the points of these metrics, matched exactly, such as
        lk.agents.turn.e2e_latency. Empty returns every metric. At most 50
        names, each 1 to 256 characters.*/
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub names: ::std::vec::Vec<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        //The session's RM_ id.
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiObservabilityV1MetricsGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1MetricsGetResponse {
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
        /*By end time, oldest first; points that end together are ordered by
        start time, a point with none first, then by kind and a hash of what
        they recorded, not by name. A page continues
        after the previous page's last point, so on an ACTIVE session a point
        exported mid-read with a later time comes on a later page, and one
        with an earlier time is missed until a new read.*/
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub points: ::std::vec::Vec<LivekitPublicapiObservabilityV1MetricPoint>,
    }
    /*RecordingFileType is the recording requested from GetSessionRecordingURL.
    The session's conversation as typed items comes from GetSessionTranscript,
    not from a recording.*/
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitPublicapiObservabilityV1RecordingFileType {
        #[serde(rename = "RECORDING_FILE_TYPE_UNSPECIFIED")]
        RecordingFileTypeUnspecified,
        #[serde(rename = "RECORDING_FILE_TYPE_AUDIO")]
        RecordingFileTypeAudio,
        #[serde(rename = "RECORDING_FILE_TYPE_CHAT_HISTORY")]
        RecordingFileTypeChatHistory,
    }
    impl ::std::fmt::Display for LivekitPublicapiObservabilityV1RecordingFileType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::RecordingFileTypeUnspecified => {
                    f.write_str("RECORDING_FILE_TYPE_UNSPECIFIED")
                }
                Self::RecordingFileTypeAudio => f.write_str("RECORDING_FILE_TYPE_AUDIO"),
                Self::RecordingFileTypeChatHistory => {
                    f.write_str("RECORDING_FILE_TYPE_CHAT_HISTORY")
                }
            }
        }
    }
    impl ::std::str::FromStr for LivekitPublicapiObservabilityV1RecordingFileType {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "RECORDING_FILE_TYPE_UNSPECIFIED" => Ok(Self::RecordingFileTypeUnspecified),
                "RECORDING_FILE_TYPE_AUDIO" => Ok(Self::RecordingFileTypeAudio),
                "RECORDING_FILE_TYPE_CHAT_HISTORY" => Ok(Self::RecordingFileTypeChatHistory),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitPublicapiObservabilityV1RecordingFileType {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
        for LivekitPublicapiObservabilityV1RecordingFileType
    {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitPublicapiObservabilityV1RecordingGetUrlRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1RecordingGetUrlRequest {
        /*How long the URL stays valid, in seconds. Unset or 0 is 900 (15
        minutes), and anything longer is clamped to 900 without an error;
        expires_at says what was granted.*/
        #[serde(rename = "expirySeconds", skip_serializing_if = "::std::option::Option::is_none")]
        pub expiry_seconds: ::std::option::Option<i64>,
        #[serde(rename = "fileType", skip_serializing_if = "::std::option::Option::is_none")]
        pub file_type: ::std::option::Option<LivekitPublicapiObservabilityV1RecordingFileType>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiObservabilityV1RecordingGetUrlResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1RecordingGetUrlResponse {
        #[serde(rename = "expiresAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub expires_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(
            rename = "recordingStartedAt",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub recording_started_at: ::std::option::Option<::pbjson_types::Timestamp>,
        /*A signed URL that downloads the recording straight from the object
        store in the project's data region, without credentials, until
        expires_at. Audio is Ogg; chat history is JSON served with
        Content-Encoding: gzip.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }
    //Role is who a transcript message is from.
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitPublicapiObservabilityV1Role {
        #[serde(rename = "ROLE_UNSPECIFIED")]
        RoleUnspecified,
        #[serde(rename = "ROLE_USER")]
        RoleUser,
        #[serde(rename = "ROLE_AGENT")]
        RoleAgent,
        #[serde(rename = "ROLE_SYSTEM")]
        RoleSystem,
        #[serde(rename = "ROLE_DEVELOPER")]
        RoleDeveloper,
    }
    impl ::std::fmt::Display for LivekitPublicapiObservabilityV1Role {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::RoleUnspecified => f.write_str("ROLE_UNSPECIFIED"),
                Self::RoleUser => f.write_str("ROLE_USER"),
                Self::RoleAgent => f.write_str("ROLE_AGENT"),
                Self::RoleSystem => f.write_str("ROLE_SYSTEM"),
                Self::RoleDeveloper => f.write_str("ROLE_DEVELOPER"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitPublicapiObservabilityV1Role {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ROLE_UNSPECIFIED" => Ok(Self::RoleUnspecified),
                "ROLE_USER" => Ok(Self::RoleUser),
                "ROLE_AGENT" => Ok(Self::RoleAgent),
                "ROLE_SYSTEM" => Ok(Self::RoleSystem),
                "ROLE_DEVELOPER" => Ok(Self::RoleDeveloper),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitPublicapiObservabilityV1Role {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitPublicapiObservabilityV1Role {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    /*Span is one unit of work in the session's trace, such as an agent turn or
    an LLM request.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1Span {
        /*The span's attributes, typed and nested as the agent recorded them, with
        its resource's and scope's attributes merged in, such as lk.agent_name;
        the span's own value wins. An integer beyond ±2^53 is its decimal string,
        and bytes are base64.*/
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub attributes: ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>,
        #[serde(rename = "endTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub end_time: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub events: ::std::vec::Vec<LivekitPublicapiObservabilityV1SpanEvent>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub kind: ::std::option::Option<LivekitPublicapiObservabilityV1SpanKind>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        /*Empty for a root span. A span whose parent isn't among the session's
        spans is a root too, as the dashboard shows it.*/
        #[serde(rename = "parentSpanId", skip_serializing_if = "::std::option::Option::is_none")]
        pub parent_span_id: ::std::option::Option<::std::string::String>,
        //The span's ids, as lowercase hex.
        #[serde(rename = "spanId", skip_serializing_if = "::std::option::Option::is_none")]
        pub span_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "startTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub start_time: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<LivekitPublicapiObservabilityV1SpanStatus>,
        #[serde(rename = "statusMessage", skip_serializing_if = "::std::option::Option::is_none")]
        pub status_message: ::std::option::Option<::std::string::String>,
        #[serde(rename = "traceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub trace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiObservabilityV1SpanAttributesEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1SpanAttributesEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<GoogleProtobufValue>,
    }
    /*SpanEvent is a timestamped event recorded within a Span, such as an
    exception.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1SpanEvent {
        //The event's own attributes, typed and nested as the agent recorded them.
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub attributes: ::std::collections::HashMap<::std::string::String, GoogleProtobufValue>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub timestamp: ::std::option::Option<::pbjson_types::Timestamp>,
    }
    //`LivekitPublicapiObservabilityV1SpanEventAttributesEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1SpanEventAttributesEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<GoogleProtobufValue>,
    }
    //SpanKind is a span's OpenTelemetry kind.
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitPublicapiObservabilityV1SpanKind {
        #[serde(rename = "SPAN_KIND_UNSPECIFIED")]
        SpanKindUnspecified,
        #[serde(rename = "SPAN_KIND_INTERNAL")]
        SpanKindInternal,
        #[serde(rename = "SPAN_KIND_SERVER")]
        SpanKindServer,
        #[serde(rename = "SPAN_KIND_CLIENT")]
        SpanKindClient,
        #[serde(rename = "SPAN_KIND_PRODUCER")]
        SpanKindProducer,
        #[serde(rename = "SPAN_KIND_CONSUMER")]
        SpanKindConsumer,
    }
    impl ::std::fmt::Display for LivekitPublicapiObservabilityV1SpanKind {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::SpanKindUnspecified => f.write_str("SPAN_KIND_UNSPECIFIED"),
                Self::SpanKindInternal => f.write_str("SPAN_KIND_INTERNAL"),
                Self::SpanKindServer => f.write_str("SPAN_KIND_SERVER"),
                Self::SpanKindClient => f.write_str("SPAN_KIND_CLIENT"),
                Self::SpanKindProducer => f.write_str("SPAN_KIND_PRODUCER"),
                Self::SpanKindConsumer => f.write_str("SPAN_KIND_CONSUMER"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitPublicapiObservabilityV1SpanKind {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "SPAN_KIND_UNSPECIFIED" => Ok(Self::SpanKindUnspecified),
                "SPAN_KIND_INTERNAL" => Ok(Self::SpanKindInternal),
                "SPAN_KIND_SERVER" => Ok(Self::SpanKindServer),
                "SPAN_KIND_CLIENT" => Ok(Self::SpanKindClient),
                "SPAN_KIND_PRODUCER" => Ok(Self::SpanKindProducer),
                "SPAN_KIND_CONSUMER" => Ok(Self::SpanKindConsumer),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitPublicapiObservabilityV1SpanKind {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitPublicapiObservabilityV1SpanKind {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //SpanStatus is a span's OpenTelemetry status code.
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitPublicapiObservabilityV1SpanStatus {
        #[serde(rename = "SPAN_STATUS_UNSPECIFIED")]
        SpanStatusUnspecified,
        #[serde(rename = "SPAN_STATUS_OK")]
        SpanStatusOk,
        #[serde(rename = "SPAN_STATUS_ERROR")]
        SpanStatusError,
    }
    impl ::std::fmt::Display for LivekitPublicapiObservabilityV1SpanStatus {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::SpanStatusUnspecified => f.write_str("SPAN_STATUS_UNSPECIFIED"),
                Self::SpanStatusOk => f.write_str("SPAN_STATUS_OK"),
                Self::SpanStatusError => f.write_str("SPAN_STATUS_ERROR"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitPublicapiObservabilityV1SpanStatus {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "SPAN_STATUS_UNSPECIFIED" => Ok(Self::SpanStatusUnspecified),
                "SPAN_STATUS_OK" => Ok(Self::SpanStatusOk),
                "SPAN_STATUS_ERROR" => Ok(Self::SpanStatusError),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitPublicapiObservabilityV1SpanStatus {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitPublicapiObservabilityV1SpanStatus {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitPublicapiObservabilityV1TracesGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1TracesGetRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        //The session's RM_ id.
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiObservabilityV1TracesGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1TracesGetResponse {
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
        /*By start time, oldest first. Spans that start together are ordered by
        span id as the aggregator stores it: the id's 8 bytes read as a
        little-endian unsigned integer, which isn't the order of its hex
        string. The pages read the spans the first page found, so a span
        exported later waits for a new read. On an ACTIVE session, a span
        exported mid-read can still shift the later pages, which are read by
        offset, so a span can repeat or be skipped: dedupe by span_id, and
        read again from the first page to pick up a skipped span.*/
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub spans: ::std::vec::Vec<LivekitPublicapiObservabilityV1Span>,
    }
    //`LivekitPublicapiObservabilityV1TranscriptGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1TranscriptGetRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        //The session's RM_ id.
        #[serde(rename = "sessionId", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiObservabilityV1TranscriptGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1TranscriptGetResponse {
        //Oldest first, in the order the agent recorded them.
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiObservabilityV1TranscriptItem>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
        /*How many of this page's records couldn't be read as transcript items
        and were left out, such as an item kind newer than this server. Zero
        when the page is complete.*/
        #[serde(rename = "skippedRecords", skip_serializing_if = "::std::option::Option::is_none")]
        pub skipped_records: ::std::option::Option<i64>,
    }
    /*TranscriptItem is one ordered entry in a session's conversation. Exactly one
    of the `item` variants is set.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitPublicapiObservabilityV1TranscriptItem {
        Variant0 {
            #[serde(rename = "agentHandoff")]
            agent_handoff: LivekitPublicapiObservabilityV1TranscriptItemAgentHandoff,
            //The item's id, as the agent assigned it (item_...).
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            id: ::std::option::Option<::std::string::String>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            timestamp: ::std::option::Option<::pbjson_types::Timestamp>,
        },
        Variant1 {
            #[serde(rename = "configUpdate")]
            config_update: LivekitPublicapiObservabilityV1TranscriptItemConfigUpdate,
            //The item's id, as the agent assigned it (item_...).
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            id: ::std::option::Option<::std::string::String>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            timestamp: ::std::option::Option<::pbjson_types::Timestamp>,
        },
        Variant2 {
            //The item's id, as the agent assigned it (item_...).
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            id: ::std::option::Option<::std::string::String>,
            message: LivekitPublicapiObservabilityV1TranscriptItemMessage,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            timestamp: ::std::option::Option<::pbjson_types::Timestamp>,
        },
        Variant3 {
            //The item's id, as the agent assigned it (item_...).
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            id: ::std::option::Option<::std::string::String>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            timestamp: ::std::option::Option<::pbjson_types::Timestamp>,
            #[serde(rename = "toolCall")]
            tool_call: LivekitPublicapiObservabilityV1TranscriptItemToolCall,
        },
        Variant4 {
            //The item's id, as the agent assigned it (item_...).
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            id: ::std::option::Option<::std::string::String>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            timestamp: ::std::option::Option<::pbjson_types::Timestamp>,
            #[serde(rename = "toolResult")]
            tool_result: LivekitPublicapiObservabilityV1TranscriptItemToolResult,
        },
    }
    //AgentHandoff is the session passing from one agent to another.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1TranscriptItemAgentHandoff {
        //Unset for the session's first agent.
        #[serde(rename = "fromAgentId", skip_serializing_if = "::std::option::Option::is_none")]
        pub from_agent_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "toAgentId", skip_serializing_if = "::std::option::Option::is_none")]
        pub to_agent_id: ::std::option::Option<::std::string::String>,
    }
    /*ConfigUpdate is a change to the agent's instructions or tools during the
    session.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1TranscriptItemConfigUpdate {
        //The agent's new instructions; empty when they didn't change.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub instructions: ::std::option::Option<::std::string::String>,
        #[serde(rename = "toolsAdded", default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub tools_added: ::std::vec::Vec<::std::string::String>,
        #[serde(
            rename = "toolsRemoved",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub tools_removed: ::std::vec::Vec<::std::string::String>,
    }
    //Message is something said, or added to the conversation as text.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1TranscriptItemMessage {
        /*The turn's latencies in milliseconds, converted from the seconds the
        agent recorded; unset when the agent didn't record one. An agent message
        carries the first three, a user message the last three.

        End-to-end latency: from when the user finished speaking to when the
        agent began responding (the agent's e2e_latency).*/
        #[serde(rename = "e2eLatencyMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub e2e_latency_ms: ::std::option::Option<f64>,
        /*From the end of the user's speech to the agent deciding the turn ended
        (end_of_turn_delay).*/
        #[serde(
            rename = "endOfTurnDelayMs",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_of_turn_delay_ms: ::std::option::Option<f64>,
        //Set on an agent message the user talked over before it finished.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub interrupted: ::std::option::Option<bool>,
        //LLM time to first token (llm_node_ttft).
        #[serde(rename = "llmTtftMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub llm_ttft_ms: ::std::option::Option<f64>,
        /*Time spent in the agent's on_user_turn_completed callback
        (on_user_turn_completed_delay).*/
        #[serde(
            rename = "onUserTurnCompletedDelayMs",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub on_user_turn_completed_delay_ms: ::std::option::Option<f64>,
        //Set when the project's PII redaction rewrote the text.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub redacted: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<LivekitPublicapiObservabilityV1Role>,
        #[serde(
            rename = "startedSpeakingAt",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub started_speaking_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(
            rename = "stoppedSpeakingAt",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub stopped_speaking_at: ::std::option::Option<::pbjson_types::Timestamp>,
        /*The message's text. Text the agent recorded in several parts is joined
        with newlines. When redacted is set, PII in it is replaced with
        <redaction type="..."/> markers.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub text: ::std::option::Option<::std::string::String>,
        //The speech-to-text confidence of a spoken user message, from 0 to 1.
        #[serde(
            rename = "transcriptConfidence",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transcript_confidence: ::std::option::Option<f64>,
        /*From the end of the user's speech to its final transcript
        (transcription_delay).*/
        #[serde(
            rename = "transcriptionDelayMs",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transcription_delay_ms: ::std::option::Option<f64>,
        //TTS time to first byte of audio (tts_node_ttfb).
        #[serde(rename = "ttsTtfbMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub tts_ttfb_ms: ::std::option::Option<f64>,
    }
    //ToolCall is the agent calling a tool.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1TranscriptItemToolCall {
        //The call's arguments as a JSON string.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub arguments: ::std::option::Option<::std::string::String>,
        //Pairs the call with its ToolResult.
        #[serde(rename = "callId", skip_serializing_if = "::std::option::Option::is_none")]
        pub call_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
    }
    //ToolResult is the output a tool returned for a ToolCall.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiObservabilityV1TranscriptItemToolResult {
        //The call_id of the ToolCall it answers.
        #[serde(rename = "callId", skip_serializing_if = "::std::option::Option::is_none")]
        pub call_id: ::std::option::Option<::std::string::String>,
        //Set when the tool failed; output then describes the error.
        #[serde(rename = "isError", skip_serializing_if = "::std::option::Option::is_none")]
        pub is_error: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub output: ::std::option::Option<::std::string::String>,
    }
    /*AccessKey is project API-key metadata. The secret is never included on list
    RPCs; it is returned only from GenerateKey.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1AccessKey {
        //Set for programmatically-created cloud agent keys.
        #[serde(rename = "agentId", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "apiKey", skip_serializing_if = "::std::option::Option::is_none")]
        pub api_key: ::std::option::Option<::std::string::String>,
        #[serde(rename = "createdAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub created_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        #[serde(rename = "ownerEmail", skip_serializing_if = "::std::option::Option::is_none")]
        pub owner_email: ::std::option::Option<::std::string::String>,
        //Empty for service-account / legacy unowned keys.
        #[serde(rename = "ownerId", skip_serializing_if = "::std::option::Option::is_none")]
        pub owner_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "updatedAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub updated_at: ::std::option::Option<::pbjson_types::Timestamp>,
    }
    //`LivekitPublicapiProjectsV1AddWorkspaceMembersToProjectRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1AddWorkspaceMembersToProjectRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
        #[serde(rename = "userIds", default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub user_ids: ::std::vec::Vec<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1AddWorkspaceMembersToProjectResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1AddWorkspaceMembersToProjectResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiProjectsV1ProjectMember>,
    }
    //`LivekitPublicapiProjectsV1AnswerInvitationRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1AnswerInvitationRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub accept: ::std::option::Option<bool>,
        #[serde(rename = "inviteToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub invite_token: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1AnswerInvitationResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1AnswerInvitationResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub member: ::std::option::Option<LivekitPublicapiProjectsV1ProjectMember>,
    }
    //TODO: Add more parts that allow for a full project creation, not just the name
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1CreateProjectMember {
        //Matches cloud_protocol.ProjectMemberRole: INVITED=0, READ=1, WRITE=2, ADMIN=3.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
        #[serde(rename = "userId", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1CreateProjectRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1CreateProjectRequest {
        #[serde(rename = "isPrivate", skip_serializing_if = "::std::option::Option::is_none")]
        pub is_private: ::std::option::Option<bool>,
        //private projects only
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub members: ::std::vec::Vec<LivekitPublicapiProjectsV1CreateProjectMember>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        //optional; generated from name when empty
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub subdomain: ::std::option::Option<::std::string::String>,
        //create-only; empty keeps the deployment default
        #[serde(rename = "userDataRegion", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_data_region: ::std::option::Option<::std::string::String>,
        //optional; when empty a new workspace is created
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1CreateProjectResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1CreateProjectResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub project: ::std::option::Option<LivekitPublicapiProjectsV1Project>,
    }
    //`LivekitPublicapiProjectsV1CreateTokenRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1CreateTokenRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub grants: ::std::option::Option<LivekitPublicapiProjectsV1TokenGrants>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        /*Requested lifetime in seconds. 0 means the default (10 minutes); at most
        86400 (24 hours).*/
        #[serde(rename = "ttlSeconds", skip_serializing_if = "::std::option::Option::is_none")]
        pub ttl_seconds: ::std::option::Option<i64>,
    }
    //`LivekitPublicapiProjectsV1CreateTokenResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1CreateTokenResponse {
        #[serde(rename = "expiresAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub expires_at: ::std::option::Option<::pbjson_types::Timestamp>,
        /*Signed JWT, sent as `Authorization: Bearer` to the project's server APIs
        or used to join a room, depending on the grants.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub token: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1DeleteInviteRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1DeleteInviteRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1DeleteInviteResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiProjectsV1DeleteInviteResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiProjectsV1DeleteInviteResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiProjectsV1DeleteInviteResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiProjectsV1DeleteInviteResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiProjectsV1DeleteInviteResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiProjectsV1DeleteKeyRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1DeleteKeyRequest {
        #[serde(rename = "apiKey", skip_serializing_if = "::std::option::Option::is_none")]
        pub api_key: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1DeleteKeyResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiProjectsV1DeleteKeyResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiProjectsV1DeleteKeyResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiProjectsV1DeleteKeyResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiProjectsV1DeleteKeyResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiProjectsV1DeleteKeyResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiProjectsV1DeleteProjectRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1DeleteProjectRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1DeleteProjectResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiProjectsV1DeleteProjectResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiProjectsV1DeleteProjectResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiProjectsV1DeleteProjectResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiProjectsV1DeleteProjectResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiProjectsV1DeleteProjectResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiProjectsV1GenerateKeyRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1GenerateKeyRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        /*When true, the key is created without an owner (project-owned). It is not
        listed as anyone's personal key and survives the generating user leaving.*/
        #[serde(
            rename = "isServiceAccount",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_service_account: ::std::option::Option<bool>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1GenerateKeyResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1GenerateKeyResponse {
        #[serde(rename = "apiKey", skip_serializing_if = "::std::option::Option::is_none")]
        pub api_key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub secret: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1GetInviteRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1GetInviteRequest {
        #[serde(rename = "inviteToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub invite_token: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1GetInviteResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1GetInviteResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub invite: ::std::option::Option<LivekitPublicapiProjectsV1ProjectInvite>,
    }
    //`LivekitPublicapiProjectsV1GetMemberRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1GetMemberRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "userId", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1GetMemberResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1GetMemberResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub member: ::std::option::Option<LivekitPublicapiProjectsV1ProjectMember>,
    }
    //`LivekitPublicapiProjectsV1GetProjectRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1GetProjectRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1GetProjectResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1GetProjectResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub project: ::std::option::Option<LivekitPublicapiProjectsV1Project>,
    }
    //InviteMember creates or refreshes a token invite (cloud InviteMember2).
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1InviteMemberRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
    }
    //`LivekitPublicapiProjectsV1InviteMemberResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1InviteMemberResponse {
        #[serde(rename = "inviteToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub invite_token: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1ListInvitesRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ListInvitesRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1ListInvitesResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ListInvitesResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiProjectsV1ProjectInvite>,
    }
    //`LivekitPublicapiProjectsV1ListKeysRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ListKeysRequest {
        //Agent keys are hidden by default, matching cloud-api-server.
        #[serde(
            rename = "includeAgentKeys",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub include_agent_keys: ::std::option::Option<bool>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1ListKeysResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ListKeysResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub keys: ::std::vec::Vec<LivekitPublicapiProjectsV1AccessKey>,
    }
    //`LivekitPublicapiProjectsV1ListMembersRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ListMembersRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1ListMembersResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ListMembersResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiProjectsV1ProjectMember>,
    }
    //`LivekitPublicapiProjectsV1ListProjectsRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ListProjectsRequest {
        //if member_id is set, list projects for the member
        #[serde(rename = "memberId", skip_serializing_if = "::std::option::Option::is_none")]
        pub member_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        /*Mutually exclusive: only one of workspace_id or member_id can be set
        if workspace_id is set, list projects for the workspace*/
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1ListProjectsResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ListProjectsResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiProjectsV1Project>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    //`LivekitPublicapiProjectsV1ListScopedKeysRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ListScopedKeysRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1ListScopedKeysResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ListScopedKeysResponse {
        #[serde(rename = "otherKeys", default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub other_keys: ::std::vec::Vec<LivekitPublicapiProjectsV1AccessKey>,
        #[serde(
            rename = "personalKeys",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub personal_keys: ::std::vec::Vec<LivekitPublicapiProjectsV1AccessKey>,
    }
    /*PinnedRegions wraps the region pin set so an explicit empty list can clear
    the pins, which a bare repeated field cannot express (mirrors cloud
    AdminSetProjectSettingsRequest.pinned_regions).*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1PinnedRegions {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub regions: ::std::vec::Vec<::std::string::String>,
    }
    /*Project is a LiveKit Cloud project (owned by cloud-api-server).
    Field set mirrors backend-common model.Project (most config fields);
    members/domains are separate list resources and are not embedded here.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1Project {
        #[serde(
            rename = "analyticsAccessKey",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub analytics_access_key: ::std::option::Option<::std::string::String>,
        #[serde(rename = "createdAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub created_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(rename = "creatorId", skip_serializing_if = "::std::option::Option::is_none")]
        pub creator_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "egressClusterId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub egress_cluster_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "enableAnalytics",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_analytics: ::std::option::Option<bool>,
        #[serde(
            rename = "enableAutoCreate",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_auto_create: ::std::option::Option<bool>,
        #[serde(
            rename = "enableEnhancedNoiseCancellation",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_enhanced_noise_cancellation: ::std::option::Option<bool>,
        #[serde(
            rename = "enableHostedAgents",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_hosted_agents: ::std::option::Option<bool>,
        #[serde(
            rename = "enableInferenceRegionRestriction",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_inference_region_restriction: ::std::option::Option<bool>,
        #[serde(
            rename = "enablePiiRedaction",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_pii_redaction: ::std::option::Option<bool>,
        #[serde(
            rename = "enableRemoteUnmute",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_remote_unmute: ::std::option::Option<bool>,
        #[serde(rename = "enableSafeMode", skip_serializing_if = "::std::option::Option::is_none")]
        pub enable_safe_mode: ::std::option::Option<bool>,
        #[serde(
            rename = "enableSipCustomDomain",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_sip_custom_domain: ::std::option::Option<bool>,
        #[serde(
            rename = "enableUserDataRecording",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_user_data_recording: ::std::option::Option<bool>,
        #[serde(
            rename = "enableUserDataTraining",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_user_data_training: ::std::option::Option<bool>,
        #[serde(
            rename = "enabledCodecs",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub enabled_codecs: ::std::vec::Vec<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "isPrivate", skip_serializing_if = "::std::option::Option::is_none")]
        pub is_private: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        /*Categories to redact when enable_pii_redaction is on. Empty on read means
        the stored set (or defaults applied at enable time) — never "redact nothing".
        Same taxonomy as cloud-api UpdateProject (cloud_protocol.PIIRedactionCategory).*/
        #[serde(
            rename = "piiRedactionCategories",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub pii_redaction_categories: ::std::vec::Vec<CloudProtocolPiiRedactionCategory>,
        #[serde(
            rename = "pinnedRegions",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub pinned_regions: ::std::vec::Vec<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub preferences: ::std::option::Option<LivekitPublicapiProjectsV1ProjectPreferences>,
        #[serde(
            rename = "requireExplicitDispatch",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub require_explicit_dispatch: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub subdomain: ::std::option::Option<::std::string::String>,
        //The project's LiveKit server URL (wss://), derived from its subdomain.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "userDataLifetimeDays",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub user_data_lifetime_days: ::std::option::Option<i32>,
        #[serde(rename = "userDataRegion", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_data_region: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub webhooks: ::std::vec::Vec<LivekitPublicapiProjectsV1Webhook>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //ProjectInvite is a pending email invite to a project (token-based, cloud InviteMember2).
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ProjectInvite {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(rename = "expiresAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub expires_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(rename = "inviteToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub invite_token: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
    }
    //ProjectMember is a user's membership on a project.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ProjectMember {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        //Matches cloud_protocol.ProjectMemberRole: INVITED=0, READ=1, WRITE=2, ADMIN=3.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
        #[serde(rename = "userId", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_id: ::std::option::Option<::std::string::String>,
    }
    /*ProjectPreferences holds per-project UI/feature settings (mirrors
    backend-common ProjectPreferences).*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ProjectPreferences {
        #[serde(
            rename = "disableTokenEndpoint",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub disable_token_endpoint: ::std::option::Option<bool>,
        #[serde(
            rename = "discoverableByDomain",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub discoverable_by_domain: ::std::option::Option<bool>,
        #[serde(
            rename = "enableEgressAutoRetry",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_egress_auto_retry: ::std::option::Option<bool>,
        #[serde(
            rename = "enableEgressBackupStorage",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_egress_backup_storage: ::std::option::Option<bool>,
        #[serde(
            rename = "featureFlags",
            default,
            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
        )]
        pub feature_flags:
            ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        #[serde(rename = "hideOnboarding", skip_serializing_if = "::std::option::Option::is_none")]
        pub hide_onboarding: ::std::option::Option<bool>,
        #[serde(
            rename = "hideSampleAppGallery",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub hide_sample_app_gallery: ::std::option::Option<bool>,
        #[serde(rename = "hipaaCompliant", skip_serializing_if = "::std::option::Option::is_none")]
        pub hipaa_compliant: ::std::option::Option<bool>,
        #[serde(
            rename = "joinableByDomain",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub joinable_by_domain: ::std::option::Option<bool>,
        #[serde(
            rename = "roomConfigurations",
            default,
            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
        )]
        pub room_configurations:
            ::std::collections::HashMap<::std::string::String, LivekitRoomConfiguration>,
        #[serde(rename = "sfuAllowPause", skip_serializing_if = "::std::option::Option::is_none")]
        pub sfu_allow_pause: ::std::option::Option<bool>,
        #[serde(
            rename = "tokenEndpointKey",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_endpoint_key: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1ProjectPreferencesFeatureFlagsEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ProjectPreferencesFeatureFlagsEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1ProjectPreferencesRoomConfigurationsEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1ProjectPreferencesRoomConfigurationsEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<LivekitRoomConfiguration>,
    }
    //`LivekitPublicapiProjectsV1RemoveMemberRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1RemoveMemberRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "userId", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1RemoveMemberResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiProjectsV1RemoveMemberResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiProjectsV1RemoveMemberResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiProjectsV1RemoveMemberResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiProjectsV1RemoveMemberResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiProjectsV1RemoveMemberResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    /*TokenGrants are the claims of a LiveKit access token. Field names match the
    token's JSON claims (protocol auth.ClaimGrants), so a token's claims JSON is
    a valid TokenGrants in JSON form.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1TokenGrants {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub agent: ::std::option::Option<LivekitPublicapiProjectsV1TokenGrantsAgent>,
        #[serde(rename = "agentEndpoint", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_endpoint:
            ::std::option::Option<LivekitPublicapiProjectsV1TokenGrantsAgentEndpoint>,
        #[serde(rename = "agentThread", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_thread: ::std::option::Option<LivekitPublicapiProjectsV1TokenGrantsAgentThread>,
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        //Participant identity (the token's subject).
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub identity: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub inference: ::std::option::Option<LivekitPublicapiProjectsV1TokenGrantsInference>,
        //Participant kind: "standard", "ingress", "egress", "sip", or "agent".
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub kind: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "kindDetails",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub kind_details: ::std::vec::Vec<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub metadata: ::std::option::Option<::std::string::String>,
        //Participant display name.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub observability:
            ::std::option::Option<LivekitPublicapiProjectsV1TokenGrantsObservability>,
        #[serde(rename = "roomConfig", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_config: ::std::option::Option<LivekitRoomConfiguration>,
        //Cloud room configuration preset; fields in room_config override it.
        #[serde(rename = "roomPreset", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_preset: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub sip: ::std::option::Option<LivekitPublicapiProjectsV1TokenGrantsSip>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub video: ::std::option::Option<LivekitPublicapiProjectsV1TokenGrantsVideo>,
    }
    //Agent server API permissions.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1TokenGrantsAgent {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub admin: ::std::option::Option<bool>,
        #[serde(rename = "databaseAdmin", skip_serializing_if = "::std::option::Option::is_none")]
        pub database_admin: ::std::option::Option<bool>,
        #[serde(rename = "dispatchAdmin", skip_serializing_if = "::std::option::Option::is_none")]
        pub dispatch_admin: ::std::option::Option<bool>,
        #[serde(
            rename = "simulationAdmin",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub simulation_admin: ::std::option::Option<bool>,
    }
    //Calling an agent's non-public HTTP endpoints.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1TokenGrantsAgentEndpoint {
        //One agent; empty for every agent of the project.
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub call: ::std::option::Option<bool>,
        //One deployment; empty for every deployment.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub deployment: ::std::option::Option<::std::string::String>,
    }
    /*A thread token: list and create in scope; read, write and delete the
    threads in thread_ids, e.g. for a frontend rendering one conversation.
    all extends it to every thread of the project; the action flags still
    apply.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1TokenGrantsAgentThread {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub all: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub create: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub delete: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub list: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub read: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub scope: ::std::option::Option<::std::string::String>,
        #[serde(rename = "threadIds", default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub thread_ids: ::std::vec::Vec<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub write: ::std::option::Option<bool>,
    }
    //`LivekitPublicapiProjectsV1TokenGrantsAttributesEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1TokenGrantsAttributesEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1TokenGrantsInference`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1TokenGrantsInference {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub perform: ::std::option::Option<bool>,
    }
    //`LivekitPublicapiProjectsV1TokenGrantsObservability`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1TokenGrantsObservability {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub write: ::std::option::Option<bool>,
    }
    //SIP server API permissions.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1TokenGrantsSip {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub admin: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub call: ::std::option::Option<bool>,
    }
    //Room and participant permissions.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1TokenGrantsVideo {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub agent: ::std::option::Option<bool>,
        #[serde(
            rename = "canManageAgentSession",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub can_manage_agent_session: ::std::option::Option<bool>,
        //Unset means allowed.
        #[serde(rename = "canPublish", skip_serializing_if = "::std::option::Option::is_none")]
        pub can_publish: ::std::option::Option<bool>,
        #[serde(rename = "canPublishData", skip_serializing_if = "::std::option::Option::is_none")]
        pub can_publish_data: ::std::option::Option<bool>,
        //Restrict publishing to these sources ("camera", "microphone", …).
        #[serde(
            rename = "canPublishSources",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub can_publish_sources: ::std::vec::Vec<::std::string::String>,
        #[serde(rename = "canSubscribe", skip_serializing_if = "::std::option::Option::is_none")]
        pub can_subscribe: ::std::option::Option<bool>,
        #[serde(
            rename = "canSubscribeMetrics",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub can_subscribe_metrics: ::std::option::Option<bool>,
        #[serde(
            rename = "canUpdateOwnMetadata",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub can_update_own_metadata: ::std::option::Option<bool>,
        //Room to move or forward participants to.
        #[serde(
            rename = "destinationRoom",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub destination_room: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub hidden: ::std::option::Option<bool>,
        //Server API: manage ingress.
        #[serde(rename = "ingressAdmin", skip_serializing_if = "::std::option::Option::is_none")]
        pub ingress_admin: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub recorder: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub room: ::std::option::Option<::std::string::String>,
        //Server API: manage `room` (or any room when unset).
        #[serde(rename = "roomAdmin", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_admin: ::std::option::Option<bool>,
        //Server API: create rooms.
        #[serde(rename = "roomCreate", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_create: ::std::option::Option<bool>,
        //Join `room`.
        #[serde(rename = "roomJoin", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_join: ::std::option::Option<bool>,
        //Server API: list rooms.
        #[serde(rename = "roomList", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_list: ::std::option::Option<bool>,
        //Server API: start and manage egress.
        #[serde(rename = "roomRecord", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_record: ::std::option::Option<bool>,
    }
    //`LivekitPublicapiProjectsV1UpdateInviteRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1UpdateInviteRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
    }
    //`LivekitPublicapiProjectsV1UpdateInviteResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1UpdateInviteResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub invite: ::std::option::Option<LivekitPublicapiProjectsV1ProjectInvite>,
    }
    //`LivekitPublicapiProjectsV1UpdateMemberRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1UpdateMemberRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
        #[serde(rename = "userId", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1UpdateMemberResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1UpdateMemberResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub member: ::std::option::Option<LivekitPublicapiProjectsV1ProjectMember>,
    }
    /*UpdateProjectRequest patches a project. Unset optional fields are left
    unchanged (proto3 optional). Mirrors cloud-api UpdateProject for local mode;
    webhooks are separate RPCs (not included here).*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1UpdateProjectRequest {
        #[serde(rename = "customDomain", skip_serializing_if = "::std::option::Option::is_none")]
        pub custom_domain: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "disableTokenEndpoint",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub disable_token_endpoint: ::std::option::Option<bool>,
        #[serde(
            rename = "discoverableByDomain",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub discoverable_by_domain: ::std::option::Option<bool>,
        //LK-admin only
        #[serde(
            rename = "egressClusterId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub egress_cluster_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "enableAnalytics",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_analytics: ::std::option::Option<bool>,
        #[serde(
            rename = "enableAutoCreate",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_auto_create: ::std::option::Option<bool>,
        #[serde(
            rename = "enableEgressAutoRetry",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_egress_auto_retry: ::std::option::Option<bool>,
        #[serde(
            rename = "enableEgressBackupStorage",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_egress_backup_storage: ::std::option::Option<bool>,
        //LK-admin only
        #[serde(
            rename = "enableHostedAgents",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_hosted_agents: ::std::option::Option<bool>,
        #[serde(
            rename = "enableInferenceRegionRestriction",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_inference_region_restriction: ::std::option::Option<bool>,
        #[serde(
            rename = "enablePiiRedaction",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_pii_redaction: ::std::option::Option<bool>,
        #[serde(
            rename = "enableRemoteUnmute",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_remote_unmute: ::std::option::Option<bool>,
        #[serde(
            rename = "enableUserDataRecording",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_user_data_recording: ::std::option::Option<bool>,
        #[serde(
            rename = "enabledCodecs",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub enabled_codecs: ::std::vec::Vec<::std::string::String>,
        #[serde(
            rename = "featureFlags",
            default,
            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
        )]
        pub feature_flags:
            ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        //Preferences (flat, matching cloud-api UpdateProjectRequest).
        #[serde(rename = "hideOnboarding", skip_serializing_if = "::std::option::Option::is_none")]
        pub hide_onboarding: ::std::option::Option<bool>,
        #[serde(
            rename = "hideSampleAppGallery",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub hide_sample_app_gallery: ::std::option::Option<bool>,
        #[serde(rename = "isPrivate", skip_serializing_if = "::std::option::Option::is_none")]
        pub is_private: ::std::option::Option<bool>,
        #[serde(
            rename = "joinableByDomain",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub joinable_by_domain: ::std::option::Option<bool>,
        //Used when becoming private: explicit member set (actor kept as ADMIN).
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub members: ::std::vec::Vec<LivekitPublicapiProjectsV1CreateProjectMember>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        /*Non-empty list replaces the stored set (validated via Canonical).
        Empty is ignored (cannot clear). When enabling with nothing stored,
        defaults are applied server-side — same as cloud-api UpdateProject.*/
        #[serde(
            rename = "piiRedactionCategories",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub pii_redaction_categories: ::std::vec::Vec<CloudProtocolPiiRedactionCategory>,
        #[serde(rename = "pinnedRegions", skip_serializing_if = "::std::option::Option::is_none")]
        pub pinned_regions: ::std::option::Option<LivekitPublicapiProjectsV1PinnedRegions>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "requireExplicitDispatch",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub require_explicit_dispatch: ::std::option::Option<bool>,
        #[serde(
            rename = "roomConfigsToDelete",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub room_configs_to_delete: ::std::vec::Vec<::std::string::String>,
        //RoomConfiguration management (stored on project preferences).
        #[serde(
            rename = "roomConfigsToUpsert",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub room_configs_to_upsert: ::std::vec::Vec<LivekitRoomConfiguration>,
        #[serde(rename = "sfuAllowPause", skip_serializing_if = "::std::option::Option::is_none")]
        pub sfu_allow_pause: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub subdomain: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "tokenEndpointKey",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_endpoint_key: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1UpdateProjectRequestFeatureFlagsEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1UpdateProjectRequestFeatureFlagsEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiProjectsV1UpdateProjectResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1UpdateProjectResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub project: ::std::option::Option<LivekitPublicapiProjectsV1Project>,
    }
    //Webhook is a project webhook destination (mirrors backend-common Webhook).
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiProjectsV1Webhook {
        #[serde(rename = "filterParams", skip_serializing_if = "::std::option::Option::is_none")]
        pub filter_params: ::std::option::Option<LivekitFilterParams>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        #[serde(rename = "signingKey", skip_serializing_if = "::std::option::Option::is_none")]
        pub signing_key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiSimulationsV1ScenariosGenerateFromSessionRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1ScenariosGenerateFromSessionRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        //Unused today: the session's recording is found by project and room.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        //Room session (RM_...) to derive the scenario from.
        #[serde(rename = "roomId", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiSimulationsV1ScenariosGenerateFromSessionResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1ScenariosGenerateFromSessionResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub scenario: ::std::option::Option<LivekitScenario>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsCancelRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsCancelRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "simulationRunId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub simulation_run_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsCancelResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsCancelResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiSimulationsV1SimulationRunsCancelResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiSimulationsV1SimulationRunsCancelResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiSimulationsV1SimulationRunsCancelResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiSimulationsV1SimulationRunsCancelResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsConfirmSourceUploadRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsConfirmSourceUploadRequest {
        //Entrypoint of the uploaded source, for example "agent.py".
        #[serde(rename = "codeEntrypoint", skip_serializing_if = "::std::option::Option::is_none")]
        pub code_entrypoint: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "simulationRunId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub simulation_run_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsConfirmSourceUploadResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsConfirmSourceUploadResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiSimulationsV1SimulationRunsConfirmSourceUploadResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl
        ::std::convert::From<LivekitPublicapiSimulationsV1SimulationRunsConfirmSourceUploadResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(
            value: LivekitPublicapiSimulationsV1SimulationRunsConfirmSourceUploadResponse,
        ) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiSimulationsV1SimulationRunsConfirmSourceUploadResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsCountsRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsCountsRequest {
        //Only runs of this agent (exact name).
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        #[serde(rename = "endTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub end_time: ::std::option::Option<::pbjson_types::Timestamp>,
        //Only runs in this conversation mode.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub mode: ::std::option::Option<LivekitSimulationMode>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "startTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub start_time: ::std::option::Option<::pbjson_types::Timestamp>,
        //Only runs in this status.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<LivekitSimulationRunStatus>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsCountsResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsCountsResponse {
        /*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.*/
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub buckets: ::std::vec::Vec<LivekitSimulationRunCountsBucket>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub interval: ::std::option::Option<::pbjson_types::Duration>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsCreateRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsCreateRequest {
        /*Name the agent under test is registered under; every job dispatches it
        into the simulation room, so it must already be deployed or running as
        a worker. Empty uses the project's default agent. Recorded on the run
        and usable as a ListSimulationRuns filter.*/
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        //Audio impairments applied to the simulated user; AUDIO mode only.
        #[serde(
            rename = "backgroundNoise",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub background_noise: ::std::option::Option<bool>,
        /*The CI pipeline this run came from, so runs can be linked back to
        commits.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub ci: ::std::option::Option<LivekitSimulationRunCi>,
        /*Maximum jobs running in parallel, at most 20; above that the request is
        InvalidArgument. The project's concurrency quota can run fewer at once.
        Unset uses the server default.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub concurrency: ::std::option::Option<i32>,
        #[serde(
            rename = "lowQualityMicrophone",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub low_quality_microphone: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub mode: ::std::option::Option<LivekitSimulationMode>,
        /*Number of scenarios to generate from the agent source when
        scenario_group is unset.*/
        #[serde(rename = "numSimulations", skip_serializing_if = "::std::option::Option::is_none")]
        pub num_simulations: ::std::option::Option<i32>,
        #[serde(rename = "packetLoss", skip_serializing_if = "::std::option::Option::is_none")]
        pub packet_loss: ::std::option::Option<bool>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        //Reserved: must be empty, and the service chooses where the run happens.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        /*Run exactly these scenarios (the contents of a scenarios.yaml) instead
        of generating num_simulations of them; the run then needs no source
        upload and starts immediately.*/
        #[serde(rename = "scenarioGroup", skip_serializing_if = "::std::option::Option::is_none")]
        pub scenario_group: ::std::option::Option<LivekitScenarioGroup>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsCreateResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsCreateResponse {
        #[serde(
            rename = "presignedPostRequest",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub presigned_post_request: ::std::option::Option<LivekitPresignedPostRequest>,
        #[serde(
            rename = "simulationRunId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub simulation_run_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsGetRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "simulationRunId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub simulation_run_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsGetResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub run: ::std::option::Option<LivekitSimulationRun>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsGetSummaryRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsGetSummaryRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "simulationRunId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub simulation_run_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsGetSummaryResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsGetSummaryResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub summary: ::std::option::Option<LivekitSimulationRunSummary>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsListRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsListRequest {
        //Only runs of this agent (exact name).
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        #[serde(rename = "endTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub end_time: ::std::option::Option<::pbjson_types::Timestamp>,
        //Only runs in this conversation mode.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub mode: ::std::option::Option<LivekitSimulationMode>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "startTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub start_time: ::std::option::Option<::pbjson_types::Timestamp>,
        //Only runs in this status.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<LivekitSimulationRunStatus>,
    }
    //`LivekitPublicapiSimulationsV1SimulationRunsListResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiSimulationsV1SimulationRunsListResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitSimulationRun>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    //`LivekitPublicapiThreadsV1ThreadsCreateRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsCreateRequest {
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        #[serde(rename = "idleTtl", skip_serializing_if = "::std::option::Option::is_none")]
        pub idle_ttl: ::std::option::Option<::pbjson_types::Duration>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        /*Optional scope grouping the thread (typically the user's identity),
        at most 256 bytes.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub scope: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiThreadsV1ThreadsCreateRequestAttributesEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsCreateRequestAttributesEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiThreadsV1ThreadsCreateResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsCreateResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub thread: ::std::option::Option<::livekit_protocol::agent::agent_thread::Thread>,
    }
    //`LivekitPublicapiThreadsV1ThreadsDeleteRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsDeleteRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "threadId", skip_serializing_if = "::std::option::Option::is_none")]
        pub thread_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiThreadsV1ThreadsDeleteResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiThreadsV1ThreadsDeleteResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiThreadsV1ThreadsDeleteResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiThreadsV1ThreadsDeleteResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiThreadsV1ThreadsDeleteResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiThreadsV1ThreadsDeleteResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiThreadsV1ThreadsGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsGetRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "threadId", skip_serializing_if = "::std::option::Option::is_none")]
        pub thread_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiThreadsV1ThreadsGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsGetResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub thread: ::std::option::Option<::livekit_protocol::agent::agent_thread::Thread>,
    }
    //`LivekitPublicapiThreadsV1ThreadsItemsRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsItemsRequest {
        //One agent's items; empty for every agent's.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub agent: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sortOrder", skip_serializing_if = "::std::option::Option::is_none")]
        pub sort_order: ::std::option::Option<LivekitPublicapiCommonV1SortOrder>,
        #[serde(rename = "threadId", skip_serializing_if = "::std::option::Option::is_none")]
        pub thread_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiThreadsV1ThreadsItemsResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsItemsResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<::livekit_protocol::agent::agent_thread::Item>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    //`LivekitPublicapiThreadsV1ThreadsListRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsListRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub scope: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiThreadsV1ThreadsListResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsListResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<::livekit_protocol::agent::agent_thread::Thread>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    //`LivekitPublicapiThreadsV1ThreadsTasksRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsTasksRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        //Only tasks in this status; unset for every status.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<::livekit_protocol::agent::agent_task::Status>,
        #[serde(rename = "threadId", skip_serializing_if = "::std::option::Option::is_none")]
        pub thread_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiThreadsV1ThreadsTasksResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsTasksResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<::livekit_protocol::agent::agent_task::Task>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    //`LivekitPublicapiThreadsV1ThreadsUpdateRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsUpdateRequest {
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        #[serde(rename = "idleTtl", skip_serializing_if = "::std::option::Option::is_none")]
        pub idle_ttl: ::std::option::Option<::pbjson_types::Duration>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "threadId", skip_serializing_if = "::std::option::Option::is_none")]
        pub thread_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiThreadsV1ThreadsUpdateRequestAttributesEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsUpdateRequestAttributesEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiThreadsV1ThreadsUpdateResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiThreadsV1ThreadsUpdateResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub thread: ::std::option::Option<::livekit_protocol::agent::agent_thread::Thread>,
    }
    //`LivekitPublicapiUsersV1GetCurrentUserRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiUsersV1GetCurrentUserRequest(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiUsersV1GetCurrentUserRequest {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiUsersV1GetCurrentUserRequest>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiUsersV1GetCurrentUserRequest) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiUsersV1GetCurrentUserRequest
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiUsersV1GetCurrentUserResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiUsersV1GetCurrentUserResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub user: ::std::option::Option<LivekitPublicapiUsersV1User>,
    }
    //`LivekitPublicapiUsersV1GetUserRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiUsersV1GetUserRequest {
        #[serde(rename = "userId", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiUsersV1GetUserResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiUsersV1GetUserResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub user: ::std::option::Option<LivekitPublicapiUsersV1User>,
    }
    //`LivekitPublicapiUsersV1ListUsersRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiUsersV1ListUsersRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        /*At least one of project_id or workspace_id is required.
        If both are set, project_id must belong to workspace_id; members are
        the project's members.*/
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiUsersV1ListUsersResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiUsersV1ListUsersResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiUsersV1User>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    //User is a LiveKit Cloud user (owned by cloud-api-server).
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiUsersV1User {
        #[serde(rename = "createdAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub created_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1AnswerInviteRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1AnswerInviteRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub accept: ::std::option::Option<bool>,
        #[serde(rename = "inviteToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub invite_token: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1AnswerInviteResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1AnswerInviteResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub member: ::std::option::Option<LivekitPublicapiWorkspacesV1WorkspaceMember>,
    }
    //`LivekitPublicapiWorkspacesV1CreateInviteRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1CreateInviteRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1CreateInviteResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1CreateInviteResponse {
        #[serde(rename = "inviteToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub invite_token: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1CreateProjectRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1CreateProjectRequest {
        #[serde(rename = "isPrivate", skip_serializing_if = "::std::option::Option::is_none")]
        pub is_private: ::std::option::Option<bool>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub members: ::std::vec::Vec<LivekitPublicapiProjectsV1CreateProjectMember>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        //optional; generated from name when empty
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub subdomain: ::std::option::Option<::std::string::String>,
        //create-only; empty keeps the deployment default
        #[serde(rename = "userDataRegion", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_data_region: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1CreateWorkspaceRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1CreateWorkspaceRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        /*Optional organization association. from_project_id and preferences are intentionally omitted: cloud treats
        from_project_id as admin-only, and hipaa_compliant preferences cascade to
        every project (AdminService.UpdateWorkspace only).*/
        #[serde(rename = "organizationId", skip_serializing_if = "::std::option::Option::is_none")]
        pub organization_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1CreateWorkspaceResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1CreateWorkspaceResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace: ::std::option::Option<LivekitPublicapiWorkspacesV1Workspace>,
    }
    //`LivekitPublicapiWorkspacesV1DeleteInviteRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1DeleteInviteRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1DeleteInviteResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiWorkspacesV1DeleteInviteResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiWorkspacesV1DeleteInviteResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiWorkspacesV1DeleteInviteResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiWorkspacesV1DeleteInviteResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiWorkspacesV1DeleteInviteResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiWorkspacesV1DeleteMemberRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1DeleteMemberRequest {
        #[serde(rename = "userId", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1DeleteMemberResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiWorkspacesV1DeleteMemberResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiWorkspacesV1DeleteMemberResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiWorkspacesV1DeleteMemberResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiWorkspacesV1DeleteMemberResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiWorkspacesV1DeleteMemberResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiWorkspacesV1DeleteProjectRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1DeleteProjectRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1DeleteWorkspaceRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1DeleteWorkspaceRequest {
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1DeleteWorkspaceResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitPublicapiWorkspacesV1DeleteWorkspaceResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitPublicapiWorkspacesV1DeleteWorkspaceResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitPublicapiWorkspacesV1DeleteWorkspaceResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitPublicapiWorkspacesV1DeleteWorkspaceResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitPublicapiWorkspacesV1DeleteWorkspaceResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitPublicapiWorkspacesV1GetInviteRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1GetInviteRequest {
        #[serde(rename = "inviteToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub invite_token: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1GetInviteResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1GetInviteResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub invite: ::std::option::Option<LivekitPublicapiWorkspacesV1WorkspaceInvite>,
    }
    //`LivekitPublicapiWorkspacesV1GetMemberRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1GetMemberRequest {
        #[serde(rename = "userId", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1GetMemberResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1GetMemberResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub member: ::std::option::Option<LivekitPublicapiWorkspacesV1WorkspaceMember>,
    }
    //`LivekitPublicapiWorkspacesV1GetProjectRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1GetProjectRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1GetWorkspaceRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1GetWorkspaceRequest {
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1GetWorkspaceResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1GetWorkspaceResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace: ::std::option::Option<LivekitPublicapiWorkspacesV1Workspace>,
    }
    //`LivekitPublicapiWorkspacesV1ListInvitesRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1ListInvitesRequest {
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1ListInvitesResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1ListInvitesResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiWorkspacesV1WorkspaceInvite>,
    }
    //`LivekitPublicapiWorkspacesV1ListMembersRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1ListMembersRequest {
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1ListMembersResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1ListMembersResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiWorkspacesV1WorkspaceMember>,
    }
    /*Workspace-scoped project RPCs: requests are owned here (required
    workspace_id); responses reuse projects.v1.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1ListProjectsRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1ListWorkspacesRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1ListWorkspacesRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub page: ::std::option::Option<LivekitPublicapiCommonV1PageRequest>,
    }
    //`LivekitPublicapiWorkspacesV1ListWorkspacesResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1ListWorkspacesResponse {
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub items: ::std::vec::Vec<LivekitPublicapiWorkspacesV1Workspace>,
        #[serde(rename = "pageInfo", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_info: ::std::option::Option<LivekitPublicapiCommonV1PageInfo>,
    }
    //`LivekitPublicapiWorkspacesV1UpdateMemberRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1UpdateMemberRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
        #[serde(rename = "userId", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1UpdateMemberResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1UpdateMemberResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub member: ::std::option::Option<LivekitPublicapiWorkspacesV1WorkspaceMember>,
    }
    //`LivekitPublicapiWorkspacesV1UpdateProjectRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1UpdateProjectRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub update: ::std::option::Option<LivekitPublicapiProjectsV1UpdateProjectRequest>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    /*Mirrors cloud-api WorkspaceService.UpdateWorkspace, which only accepts a
    name: workspace preferences (hipaa_compliant) cascade to every project in the
    workspace and are LK-admin-only there (AdminService.UpdateWorkspace), so they
    are deliberately not settable on this path.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1UpdateWorkspaceRequest {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitPublicapiWorkspacesV1UpdateWorkspaceResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1UpdateWorkspaceResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace: ::std::option::Option<LivekitPublicapiWorkspacesV1Workspace>,
    }
    /*Workspace is a LiveKit Cloud workspace (owned by cloud-api-server).
    Field set mirrors backend-common model.Workspace.ToProto(); members/invites
    are separate list resources and are not embedded here.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1Workspace {
        #[serde(rename = "createdAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub created_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(rename = "creatorId", skip_serializing_if = "::std::option::Option::is_none")]
        pub creator_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        #[serde(rename = "organizationId", skip_serializing_if = "::std::option::Option::is_none")]
        pub organization_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub preferences: ::std::option::Option<LivekitPublicapiWorkspacesV1WorkspacePreferences>,
    }
    //WorkspaceInvite is a pending email invite to a workspace.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1WorkspaceInvite {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(rename = "expiresAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub expires_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(rename = "inviteToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub invite_token: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    //WorkspaceMember is a user's membership on a workspace.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1WorkspaceMember {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        //Matches cloud_protocol.ProjectMemberRole: INVITED=0, READ=1, WRITE=2, ADMIN=3.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
        #[serde(rename = "userId", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "workspaceId", skip_serializing_if = "::std::option::Option::is_none")]
        pub workspace_id: ::std::option::Option<::std::string::String>,
    }
    /*WorkspacePreferences holds per-workspace settings (mirrors backend-common
    WorkspacePreferences).*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitPublicapiWorkspacesV1WorkspacePreferences {
        #[serde(rename = "hipaaCompliant", skip_serializing_if = "::std::option::Option::is_none")]
        pub hipaa_compliant: ::std::option::Option<bool>,
    }
    //`LivekitRoomAgentDispatch`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitRoomAgentDispatch {
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub deployment: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub metadata: ::std::option::Option<::std::string::String>,
        #[serde(rename = "restartPolicy", skip_serializing_if = "::std::option::Option::is_none")]
        pub restart_policy: ::std::option::Option<LivekitJobRestartPolicy>,
    }
    //`LivekitRoomAgentDispatchAttributesEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitRoomAgentDispatchAttributesEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //`LivekitRoomCompositeEgressRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitRoomCompositeEgressRequest {
        Variant0(LivekitRoomCompositeEgressRequestVariant0),
        Variant1(LivekitRoomCompositeEgressRequestVariant1),
        Variant2(LivekitRoomCompositeEgressRequestVariant2),
    }
    impl ::std::convert::From<LivekitRoomCompositeEgressRequestVariant0>
        for LivekitRoomCompositeEgressRequest
    {
        fn from(value: LivekitRoomCompositeEgressRequestVariant0) -> Self {
            Self::Variant0(value)
        }
    }
    impl ::std::convert::From<LivekitRoomCompositeEgressRequestVariant1>
        for LivekitRoomCompositeEgressRequest
    {
        fn from(value: LivekitRoomCompositeEgressRequestVariant1) -> Self {
            Self::Variant1(value)
        }
    }
    impl ::std::convert::From<LivekitRoomCompositeEgressRequestVariant2>
        for LivekitRoomCompositeEgressRequest
    {
        fn from(value: LivekitRoomCompositeEgressRequestVariant2) -> Self {
            Self::Variant2(value)
        }
    }
    //`LivekitRoomCompositeEgressRequestVariant0`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitRoomCompositeEgressRequestVariant0 {
        Variant0 {
            advanced: LivekitEncodingOptions,
            #[serde(
                rename = "audioMixing",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            audio_mixing: ::std::option::Option<LivekitAudioMixing>,
            #[serde(rename = "audioOnly", skip_serializing_if = "::std::option::Option::is_none")]
            audio_only: ::std::option::Option<bool>,
            #[serde(
                rename = "customBaseUrl",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            custom_base_url: ::std::option::Option<::std::string::String>,
            file: LivekitEncodedFileOutput,
            #[serde(
                rename = "fileOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            file_outputs: ::std::vec::Vec<LivekitEncodedFileOutput>,
            #[serde(
                rename = "imageOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            image_outputs: ::std::vec::Vec<LivekitImageOutput>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            layout: ::std::option::Option<::std::string::String>,
            #[serde(rename = "roomName", skip_serializing_if = "::std::option::Option::is_none")]
            room_name: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "segmentOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            segment_outputs: ::std::vec::Vec<LivekitSegmentedFileOutput>,
            #[serde(
                rename = "streamOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            stream_outputs: ::std::vec::Vec<LivekitStreamOutput>,
            #[serde(rename = "videoOnly", skip_serializing_if = "::std::option::Option::is_none")]
            video_only: ::std::option::Option<bool>,
            #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
            webhooks: ::std::vec::Vec<LivekitWebhookConfig>,
        },
        Variant1 {
            #[serde(
                rename = "audioMixing",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            audio_mixing: ::std::option::Option<LivekitAudioMixing>,
            #[serde(rename = "audioOnly", skip_serializing_if = "::std::option::Option::is_none")]
            audio_only: ::std::option::Option<bool>,
            #[serde(
                rename = "customBaseUrl",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            custom_base_url: ::std::option::Option<::std::string::String>,
            file: LivekitEncodedFileOutput,
            #[serde(
                rename = "fileOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            file_outputs: ::std::vec::Vec<LivekitEncodedFileOutput>,
            #[serde(
                rename = "imageOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            image_outputs: ::std::vec::Vec<LivekitImageOutput>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            layout: ::std::option::Option<::std::string::String>,
            preset: LivekitEncodingOptionsPreset,
            #[serde(rename = "roomName", skip_serializing_if = "::std::option::Option::is_none")]
            room_name: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "segmentOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            segment_outputs: ::std::vec::Vec<LivekitSegmentedFileOutput>,
            #[serde(
                rename = "streamOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            stream_outputs: ::std::vec::Vec<LivekitStreamOutput>,
            #[serde(rename = "videoOnly", skip_serializing_if = "::std::option::Option::is_none")]
            video_only: ::std::option::Option<bool>,
            #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
            webhooks: ::std::vec::Vec<LivekitWebhookConfig>,
        },
    }
    //`LivekitRoomCompositeEgressRequestVariant1`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitRoomCompositeEgressRequestVariant1 {
        Variant0 {
            advanced: LivekitEncodingOptions,
            #[serde(
                rename = "audioMixing",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            audio_mixing: ::std::option::Option<LivekitAudioMixing>,
            #[serde(rename = "audioOnly", skip_serializing_if = "::std::option::Option::is_none")]
            audio_only: ::std::option::Option<bool>,
            #[serde(
                rename = "customBaseUrl",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            custom_base_url: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "fileOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            file_outputs: ::std::vec::Vec<LivekitEncodedFileOutput>,
            #[serde(
                rename = "imageOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            image_outputs: ::std::vec::Vec<LivekitImageOutput>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            layout: ::std::option::Option<::std::string::String>,
            #[serde(rename = "roomName", skip_serializing_if = "::std::option::Option::is_none")]
            room_name: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "segmentOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            segment_outputs: ::std::vec::Vec<LivekitSegmentedFileOutput>,
            segments: LivekitSegmentedFileOutput,
            #[serde(
                rename = "streamOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            stream_outputs: ::std::vec::Vec<LivekitStreamOutput>,
            #[serde(rename = "videoOnly", skip_serializing_if = "::std::option::Option::is_none")]
            video_only: ::std::option::Option<bool>,
            #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
            webhooks: ::std::vec::Vec<LivekitWebhookConfig>,
        },
        Variant1 {
            #[serde(
                rename = "audioMixing",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            audio_mixing: ::std::option::Option<LivekitAudioMixing>,
            #[serde(rename = "audioOnly", skip_serializing_if = "::std::option::Option::is_none")]
            audio_only: ::std::option::Option<bool>,
            #[serde(
                rename = "customBaseUrl",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            custom_base_url: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "fileOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            file_outputs: ::std::vec::Vec<LivekitEncodedFileOutput>,
            #[serde(
                rename = "imageOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            image_outputs: ::std::vec::Vec<LivekitImageOutput>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            layout: ::std::option::Option<::std::string::String>,
            preset: LivekitEncodingOptionsPreset,
            #[serde(rename = "roomName", skip_serializing_if = "::std::option::Option::is_none")]
            room_name: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "segmentOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            segment_outputs: ::std::vec::Vec<LivekitSegmentedFileOutput>,
            segments: LivekitSegmentedFileOutput,
            #[serde(
                rename = "streamOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            stream_outputs: ::std::vec::Vec<LivekitStreamOutput>,
            #[serde(rename = "videoOnly", skip_serializing_if = "::std::option::Option::is_none")]
            video_only: ::std::option::Option<bool>,
            #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
            webhooks: ::std::vec::Vec<LivekitWebhookConfig>,
        },
    }
    //`LivekitRoomCompositeEgressRequestVariant2`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitRoomCompositeEgressRequestVariant2 {
        Variant0 {
            advanced: LivekitEncodingOptions,
            #[serde(
                rename = "audioMixing",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            audio_mixing: ::std::option::Option<LivekitAudioMixing>,
            #[serde(rename = "audioOnly", skip_serializing_if = "::std::option::Option::is_none")]
            audio_only: ::std::option::Option<bool>,
            #[serde(
                rename = "customBaseUrl",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            custom_base_url: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "fileOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            file_outputs: ::std::vec::Vec<LivekitEncodedFileOutput>,
            #[serde(
                rename = "imageOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            image_outputs: ::std::vec::Vec<LivekitImageOutput>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            layout: ::std::option::Option<::std::string::String>,
            #[serde(rename = "roomName", skip_serializing_if = "::std::option::Option::is_none")]
            room_name: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "segmentOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            segment_outputs: ::std::vec::Vec<LivekitSegmentedFileOutput>,
            stream: LivekitStreamOutput,
            #[serde(
                rename = "streamOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            stream_outputs: ::std::vec::Vec<LivekitStreamOutput>,
            #[serde(rename = "videoOnly", skip_serializing_if = "::std::option::Option::is_none")]
            video_only: ::std::option::Option<bool>,
            #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
            webhooks: ::std::vec::Vec<LivekitWebhookConfig>,
        },
        Variant1 {
            #[serde(
                rename = "audioMixing",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            audio_mixing: ::std::option::Option<LivekitAudioMixing>,
            #[serde(rename = "audioOnly", skip_serializing_if = "::std::option::Option::is_none")]
            audio_only: ::std::option::Option<bool>,
            #[serde(
                rename = "customBaseUrl",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            custom_base_url: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "fileOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            file_outputs: ::std::vec::Vec<LivekitEncodedFileOutput>,
            #[serde(
                rename = "imageOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            image_outputs: ::std::vec::Vec<LivekitImageOutput>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            layout: ::std::option::Option<::std::string::String>,
            preset: LivekitEncodingOptionsPreset,
            #[serde(rename = "roomName", skip_serializing_if = "::std::option::Option::is_none")]
            room_name: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "segmentOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            segment_outputs: ::std::vec::Vec<LivekitSegmentedFileOutput>,
            stream: LivekitStreamOutput,
            #[serde(
                rename = "streamOutputs",
                default,
                skip_serializing_if = "::std::vec::Vec::is_empty"
            )]
            stream_outputs: ::std::vec::Vec<LivekitStreamOutput>,
            #[serde(rename = "videoOnly", skip_serializing_if = "::std::option::Option::is_none")]
            video_only: ::std::option::Option<bool>,
            #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
            webhooks: ::std::vec::Vec<LivekitWebhookConfig>,
        },
    }
    //`LivekitRoomConfiguration`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitRoomConfiguration {
        //Define agents that should be dispatched to this room
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub agents: ::std::vec::Vec<LivekitRoomAgentDispatch>,
        //number of seconds to keep the room open after everyone leaves
        #[serde(
            rename = "departureTimeout",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub departure_timeout: ::std::option::Option<i64>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub egress: ::std::option::Option<LivekitRoomEgress>,
        //number of seconds to keep the room open if no one joins
        #[serde(rename = "emptyTimeout", skip_serializing_if = "::std::option::Option::is_none")]
        pub empty_timeout: ::std::option::Option<i64>,
        //limit number of participants that can be in a room, excluding Egress and Agent participants
        #[serde(
            rename = "maxParticipants",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub max_participants: ::std::option::Option<i64>,
        #[serde(
            rename = "maxPlayoutDelay",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub max_playout_delay: ::std::option::Option<i64>,
        //metadata of room
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub metadata: ::std::option::Option<::std::string::String>,
        //playout delay of subscriber
        #[serde(
            rename = "minPlayoutDelay",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub min_playout_delay: ::std::option::Option<i64>,
        //Used as ID, must be unique
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        /*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*/
        #[serde(rename = "syncStreams", skip_serializing_if = "::std::option::Option::is_none")]
        pub sync_streams: ::std::option::Option<bool>,
        //Tags to attach to the room
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub tags: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    }
    //`LivekitRoomConfigurationTagsEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitRoomConfigurationTagsEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //`LivekitRoomEgress`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitRoomEgress {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub participant: ::std::option::Option<LivekitAutoParticipantEgress>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub room: ::std::option::Option<LivekitRoomCompositeEgressRequest>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub tracks: ::std::option::Option<LivekitAutoTrackEgress>,
    }
    //`LivekitS3Upload`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitS3Upload {
        #[serde(rename = "accessKey", skip_serializing_if = "::std::option::Option::is_none")]
        pub access_key: ::std::option::Option<::std::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
        #[serde(rename = "assumeRoleArn", skip_serializing_if = "::std::option::Option::is_none")]
        pub assume_role_arn: ::std::option::Option<::std::string::String>,
        //ExternalID to use when assuming role for upload
        #[serde(
            rename = "assumeRoleExternalId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub assume_role_external_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub bucket: ::std::option::Option<::std::string::String>,
        //Content-Disposition header
        #[serde(
            rename = "contentDisposition",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub content_disposition: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub endpoint: ::std::option::Option<::std::string::String>,
        #[serde(rename = "forcePathStyle", skip_serializing_if = "::std::option::Option::is_none")]
        pub force_path_style: ::std::option::Option<bool>,
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub metadata: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub proxy: ::std::option::Option<LivekitProxyConfig>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub secret: ::std::option::Option<::std::string::String>,
        #[serde(rename = "sessionToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub session_token: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub tagging: ::std::option::Option<::std::string::String>,
    }
    //`LivekitS3UploadMetadataEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitS3UploadMetadataEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    /*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(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitScenario {
        #[serde(
            rename = "agentExpectations",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub agent_expectations: ::std::option::Option<::std::string::String>,
        /*SCN_-prefixed guid. Stable across edits to label, instructions, or
        expectations, so runs of the same scenario can be correlated over time.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub instructions: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub label: ::std::option::Option<::std::string::String>,
        //Set as participant attributes on the simulation participant's access token.
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub tags: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        /*Arbitrary JSON-encoded object, surfaced to the agent under test as
        SimulationContext userdata (e.g. inputs and benchmark target state).*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub userdata: ::std::option::Option<::std::string::String>,
    }
    //`LivekitScenarioCreateFromSession`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitScenarioCreateFromSession(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitScenarioCreateFromSession {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitScenarioCreateFromSession>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitScenarioCreateFromSession) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitScenarioCreateFromSession
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitScenarioCreateFromSessionRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitScenarioCreateFromSessionRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        #[serde(rename = "roomId", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitScenarioCreateFromSessionResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitScenarioCreateFromSessionResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub scenario: ::std::option::Option<LivekitScenario>,
    }
    //A named group of scenarios, mirroring a whole scenarios.yaml file.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitScenarioGroup {
        /*SCNG_-prefixed guid. Stable identity of the scenarios file, independent
        of its name.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub scenarios: ::std::vec::Vec<LivekitScenario>,
    }
    //`LivekitScenarioTagsEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitScenarioTagsEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    //Used to generate HLS segments or other kind of segmented output
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(untagged)]
    pub enum LivekitSegmentedFileOutput {
        Variant0 {
            #[serde(rename = "aliOSS")]
            ali_oss: LivekitAliOssUpload,
            //disable upload of manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //(optional)
            #[serde(
                rename = "filenamePrefix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_prefix: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "filenameSuffix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_suffix: ::std::option::Option<LivekitSegmentedFileSuffix>,
            //(optional, disabled if not provided). Path of a live playlist
            #[serde(
                rename = "livePlaylistName",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            live_playlist_name: ::std::option::Option<::std::string::String>,
            //(optional)
            #[serde(
                rename = "playlistName",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            playlist_name: ::std::option::Option<::std::string::String>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            protocol: ::std::option::Option<LivekitSegmentedFileProtocol>,
            //in seconds (optional)
            #[serde(
                rename = "segmentDuration",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            segment_duration: ::std::option::Option<i64>,
        },
        Variant1 {
            azure: LivekitAzureBlobUpload,
            //disable upload of manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //(optional)
            #[serde(
                rename = "filenamePrefix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_prefix: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "filenameSuffix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_suffix: ::std::option::Option<LivekitSegmentedFileSuffix>,
            //(optional, disabled if not provided). Path of a live playlist
            #[serde(
                rename = "livePlaylistName",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            live_playlist_name: ::std::option::Option<::std::string::String>,
            //(optional)
            #[serde(
                rename = "playlistName",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            playlist_name: ::std::option::Option<::std::string::String>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            protocol: ::std::option::Option<LivekitSegmentedFileProtocol>,
            //in seconds (optional)
            #[serde(
                rename = "segmentDuration",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            segment_duration: ::std::option::Option<i64>,
        },
        Variant2 {
            //disable upload of manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //(optional)
            #[serde(
                rename = "filenamePrefix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_prefix: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "filenameSuffix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_suffix: ::std::option::Option<LivekitSegmentedFileSuffix>,
            gcp: LivekitGcpUpload,
            //(optional, disabled if not provided). Path of a live playlist
            #[serde(
                rename = "livePlaylistName",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            live_playlist_name: ::std::option::Option<::std::string::String>,
            //(optional)
            #[serde(
                rename = "playlistName",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            playlist_name: ::std::option::Option<::std::string::String>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            protocol: ::std::option::Option<LivekitSegmentedFileProtocol>,
            //in seconds (optional)
            #[serde(
                rename = "segmentDuration",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            segment_duration: ::std::option::Option<i64>,
        },
        Variant3 {
            //disable upload of manifest file (default false)
            #[serde(
                rename = "disableManifest",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            disable_manifest: ::std::option::Option<bool>,
            //(optional)
            #[serde(
                rename = "filenamePrefix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_prefix: ::std::option::Option<::std::string::String>,
            #[serde(
                rename = "filenameSuffix",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            filename_suffix: ::std::option::Option<LivekitSegmentedFileSuffix>,
            //(optional, disabled if not provided). Path of a live playlist
            #[serde(
                rename = "livePlaylistName",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            live_playlist_name: ::std::option::Option<::std::string::String>,
            //(optional)
            #[serde(
                rename = "playlistName",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            playlist_name: ::std::option::Option<::std::string::String>,
            #[serde(skip_serializing_if = "::std::option::Option::is_none")]
            protocol: ::std::option::Option<LivekitSegmentedFileProtocol>,
            s3: LivekitS3Upload,
            //in seconds (optional)
            #[serde(
                rename = "segmentDuration",
                skip_serializing_if = "::std::option::Option::is_none"
            )]
            segment_duration: ::std::option::Option<i64>,
        },
    }
    //`LivekitSegmentedFileProtocol`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitSegmentedFileProtocol {
        #[serde(rename = "DEFAULT_SEGMENTED_FILE_PROTOCOL")]
        DefaultSegmentedFileProtocol,
        #[serde(rename = "HLS_PROTOCOL")]
        HlsProtocol,
    }
    impl ::std::fmt::Display for LivekitSegmentedFileProtocol {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::DefaultSegmentedFileProtocol => {
                    f.write_str("DEFAULT_SEGMENTED_FILE_PROTOCOL")
                }
                Self::HlsProtocol => f.write_str("HLS_PROTOCOL"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitSegmentedFileProtocol {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "DEFAULT_SEGMENTED_FILE_PROTOCOL" => Ok(Self::DefaultSegmentedFileProtocol),
                "HLS_PROTOCOL" => Ok(Self::HlsProtocol),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitSegmentedFileProtocol {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitSegmentedFileProtocol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitSegmentedFileSuffix`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitSegmentedFileSuffix {
        #[serde(rename = "INDEX")]
        Index,
        #[serde(rename = "TIMESTAMP")]
        Timestamp,
    }
    impl ::std::fmt::Display for LivekitSegmentedFileSuffix {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Index => f.write_str("INDEX"),
                Self::Timestamp => f.write_str("TIMESTAMP"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitSegmentedFileSuffix {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "INDEX" => Ok(Self::Index),
                "TIMESTAMP" => Ok(Self::Timestamp),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitSegmentedFileSuffix {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitSegmentedFileSuffix {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //How the simulated user interacts with the agent under test.
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitSimulationMode {
        #[serde(rename = "SIMULATION_MODE_UNSPECIFIED")]
        SimulationModeUnspecified,
        #[serde(rename = "SIMULATION_MODE_TEXT")]
        SimulationModeText,
        #[serde(rename = "SIMULATION_MODE_AUDIO")]
        SimulationModeAudio,
    }
    impl ::std::fmt::Display for LivekitSimulationMode {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::SimulationModeUnspecified => f.write_str("SIMULATION_MODE_UNSPECIFIED"),
                Self::SimulationModeText => f.write_str("SIMULATION_MODE_TEXT"),
                Self::SimulationModeAudio => f.write_str("SIMULATION_MODE_AUDIO"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitSimulationMode {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "SIMULATION_MODE_UNSPECIFIED" => Ok(Self::SimulationModeUnspecified),
                "SIMULATION_MODE_TEXT" => Ok(Self::SimulationModeText),
                "SIMULATION_MODE_AUDIO" => Ok(Self::SimulationModeAudio),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitSimulationMode {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitSimulationMode {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitSimulationRun`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRun {
        #[serde(
            rename = "agentDescription",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub agent_description: ::std::option::Option<::std::string::String>,
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        //The pipeline this run came from; unset when it did not come from one.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub ci: ::std::option::Option<LivekitSimulationRunCi>,
        //Maximum simulate jobs running in parallel for this run (0 = server default).
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub concurrency: ::std::option::Option<i32>,
        #[serde(rename = "createdAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub created_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(rename = "endedAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub ended_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub error: ::std::option::Option<::std::string::String>,
        #[serde(rename = "failedCount", skip_serializing_if = "::std::option::Option::is_none")]
        pub failed_count: ::std::option::Option<i32>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        /*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.*/
        #[serde(rename = "issueCount", skip_serializing_if = "::std::option::Option::is_none")]
        pub issue_count: ::std::option::Option<i32>,
        #[serde(rename = "jobCount", skip_serializing_if = "::std::option::Option::is_none")]
        pub job_count: ::std::option::Option<i32>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub jobs: ::std::vec::Vec<LivekitSimulationRunJob>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub metrics: ::std::option::Option<LivekitSimulationRunRunMetrics>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub mode: ::std::option::Option<LivekitSimulationMode>,
        #[serde(rename = "numSimulations", skip_serializing_if = "::std::option::Option::is_none")]
        pub num_simulations: ::std::option::Option<i32>,
        #[serde(rename = "passedCount", skip_serializing_if = "::std::option::Option::is_none")]
        pub passed_count: ::std::option::Option<i32>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        //Absent when the run ran each scenario once and required it to pass.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub sampling: ::std::option::Option<LivekitSimulationRunSamplingOptions>,
        #[serde(rename = "scenarioGroup", skip_serializing_if = "::std::option::Option::is_none")]
        pub scenario_group: ::std::option::Option<LivekitScenarioGroup>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<LivekitSimulationRunStatus>,
        /*zstd-compressed SimulationRunSummary: decompress, then proto.Unmarshal.
        Compressed by default so the blob ships as-is on every hop.*/
        #[serde(rename = "summaryZstd", skip_serializing_if = "::std::option::Option::is_none")]
        pub summary_zstd: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub usage: ::std::option::Option<LivekitSimulationRunUsage>,
    }
    //`LivekitSimulationRunCancel`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitSimulationRunCancel(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitSimulationRunCancel {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitSimulationRunCancel>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitSimulationRunCancel) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitSimulationRunCancel
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitSimulationRunCancelRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunCancelRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "simulationRunId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub simulation_run_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitSimulationRunCancelResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitSimulationRunCancelResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitSimulationRunCancelResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitSimulationRunCancelResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitSimulationRunCancelResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitSimulationRunCancelResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    /*The pipeline this run came from. Set by the client from its CI
    environment; absent for runs not started by a pipeline.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunCi {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub actor: ::std::option::Option<::std::string::String>,
        #[serde(rename = "commitSha", skip_serializing_if = "::std::option::Option::is_none")]
        pub commit_sha: ::std::option::Option<::std::string::String>,
        //e.g. "github_actions"
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub provider: ::std::option::Option<::std::string::String>,
        #[serde(rename = "pullRequest", skip_serializing_if = "::std::option::Option::is_none")]
        pub pull_request: ::std::option::Option<::std::string::String>,
        //branch or tag
        #[serde(rename = "ref", skip_serializing_if = "::std::option::Option::is_none")]
        pub ref_: ::std::option::Option<::std::string::String>,
        //link back to the CI job
        #[serde(rename = "runUrl", skip_serializing_if = "::std::option::Option::is_none")]
        pub run_url: ::std::option::Option<::std::string::String>,
    }
    //`LivekitSimulationRunConfirmSourceUpload`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitSimulationRunConfirmSourceUpload(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitSimulationRunConfirmSourceUpload {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitSimulationRunConfirmSourceUpload>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitSimulationRunConfirmSourceUpload) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitSimulationRunConfirmSourceUpload
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitSimulationRunConfirmSourceUploadRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunConfirmSourceUploadRequest {
        #[serde(rename = "codeEntrypoint", skip_serializing_if = "::std::option::Option::is_none")]
        pub code_entrypoint: ::std::option::Option<::std::string::String>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "simulationRunId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub simulation_run_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitSimulationRunConfirmSourceUploadResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitSimulationRunConfirmSourceUploadResponse(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitSimulationRunConfirmSourceUploadResponse {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitSimulationRunConfirmSourceUploadResponse>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitSimulationRunConfirmSourceUploadResponse) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitSimulationRunConfirmSourceUploadResponse
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    /*Counts of the runs `List` would return over the same window, bucketed by
    created_at instead of paginated.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitSimulationRunCounts(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitSimulationRunCounts {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitSimulationRunCounts>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitSimulationRunCounts) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitSimulationRunCounts
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitSimulationRunCountsBucket`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunCountsBucket {
        #[serde(rename = "bucketStart", skip_serializing_if = "::std::option::Option::is_none")]
        pub bucket_start: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub count: ::std::option::Option<::std::string::String>,
    }
    //`LivekitSimulationRunCountsRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunCountsRequest {
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        #[serde(rename = "endTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub end_time: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub mode: ::std::option::Option<LivekitSimulationMode>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "startTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub start_time: ::std::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.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<LivekitSimulationRunStatus>,
    }
    //`LivekitSimulationRunCountsResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunCountsResponse {
        /*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.*/
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub buckets: ::std::vec::Vec<LivekitSimulationRunCountsBucket>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub interval: ::std::option::Option<::pbjson_types::Duration>,
    }
    //`LivekitSimulationRunCreate`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitSimulationRunCreate(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitSimulationRunCreate {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitSimulationRunCreate>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitSimulationRunCreate) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitSimulationRunCreate
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitSimulationRunCreateRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunCreateRequest {
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        //Impairments applied to the simulated user's audio; AUDIO mode only.
        #[serde(
            rename = "backgroundNoise",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub background_noise: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub ci: ::std::option::Option<LivekitSimulationRunCi>,
        /*Maximum simulate jobs running in parallel for this run. Clamped to the
        project's concurrency quota; 0/unset uses the server default.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub concurrency: ::std::option::Option<i32>,
        #[serde(
            rename = "lowQualityMicrophone",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub low_quality_microphone: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub mode: ::std::option::Option<LivekitSimulationMode>,
        #[serde(rename = "numSimulations", skip_serializing_if = "::std::option::Option::is_none")]
        pub num_simulations: ::std::option::Option<i32>,
        #[serde(rename = "packetLoss", skip_serializing_if = "::std::option::Option::is_none")]
        pub packet_loss: ::std::option::Option<bool>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        /*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.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub sampling: ::std::option::Option<LivekitSimulationRunSamplingOptions>,
        /*When set, run these scenarios (loaded from a scenarios.yaml).
        When unset, generate num_simulations scenarios from the uploaded agent source.*/
        #[serde(rename = "scenarioGroup", skip_serializing_if = "::std::option::Option::is_none")]
        pub scenario_group: ::std::option::Option<LivekitScenarioGroup>,
    }
    //`LivekitSimulationRunCreateResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunCreateResponse {
        #[serde(
            rename = "presignedPostRequest",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub presigned_post_request: ::std::option::Option<LivekitPresignedPostRequest>,
        #[serde(
            rename = "simulationRunId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub simulation_run_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitSimulationRunGet`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitSimulationRunGet(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitSimulationRunGet {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitSimulationRunGet>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitSimulationRunGet) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitSimulationRunGet
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitSimulationRunGetRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunGetRequest {
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "simulationRunId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub simulation_run_id: ::std::option::Option<::std::string::String>,
    }
    //`LivekitSimulationRunGetResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunGetResponse {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub run: ::std::option::Option<LivekitSimulationRun>,
    }
    //`LivekitSimulationRunJob`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunJob {
        #[serde(
            rename = "agentExpectations",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub agent_expectations: ::std::option::Option<::std::string::String>,
        #[serde(rename = "endedAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub ended_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub error: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub instructions: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub label: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub metrics: ::std::option::Option<LivekitSimulationRunJobMetrics>,
        #[serde(rename = "roomId", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "roomName", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_name: ::std::option::Option<::std::string::String>,
        /*1-based sample of that scenario within the run; always 1 when the run's
        samples is 1.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub sample: ::std::option::Option<i32>,
        /*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.*/
        #[serde(rename = "scenarioId", skip_serializing_if = "::std::option::Option::is_none")]
        pub scenario_id: ::std::option::Option<::std::string::String>,
        #[serde(rename = "startedAt", skip_serializing_if = "::std::option::Option::is_none")]
        pub started_at: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<LivekitSimulationRunJobStatus>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub tags: ::std::vec::Vec<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub usage: ::std::option::Option<LivekitSimulationRunJobUsage>,
    }
    //`LivekitSimulationRunJobMetrics`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunJobMetrics {
        //Judged over the authored dialog (text and audio); needs the text judge. judged {0, 0.5, 1} per agent turn; job = mean
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub conciseness: ::std::option::Option<f32>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub conversation: ::std::option::Option<LivekitSimulationRunJobMetricsConversation>,
        //0-1, derived from the flags above
        #[serde(
            rename = "conversationProgression",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub conversation_progression: ::std::option::Option<f32>,
        //false = waveform-only capture (e.g. SIP)
        #[serde(
            rename = "hasRemoteSession",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_remote_session: ::std::option::Option<bool>,
        #[serde(
            rename = "informationLoss",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub information_loss: ::std::option::Option<bool>,
        //text judge for judged scores; "" if none ran
        #[serde(rename = "judgeModel", skip_serializing_if = "::std::option::Option::is_none")]
        pub judge_model: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub llm: ::std::option::Option<LivekitSimulationRunJobMetricsLlm>,
        //weighted mean of the judged and heard scores
        #[serde(rename = "overallScore", skip_serializing_if = "::std::option::Option::is_none")]
        pub overall_score: ::std::option::Option<f32>,
        #[serde(
            rename = "poorQuestionQuality",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub poor_question_quality: ::std::option::Option<bool>,
        #[serde(
            rename = "redundantStatements",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub redundant_statements: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub stt: ::std::option::Option<LivekitSimulationRunJobMetricsStt>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub t0: ::std::option::Option<::pbjson_types::Timestamp>,
        //the scenario verdict as 1/0
        #[serde(rename = "taskCompletion", skip_serializing_if = "::std::option::Option::is_none")]
        pub task_completion: ::std::option::Option<f32>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub tts: ::std::option::Option<LivekitSimulationRunJobMetricsTts>,
        //One entry per turn, both speakers.
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub turns: ::std::vec::Vec<LivekitSimulationRunJobMetricsTurn>,
        //Whole-call issue flags; true = present, absent = not judged.
        #[serde(
            rename = "unnecessaryToolCalls",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub unnecessary_tool_calls: ::std::option::Option<bool>,
    }
    //Audio only.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunJobMetricsConversation {
        //gaps past the natural-pause threshold
        #[serde(
            rename = "awkwardSilenceCount",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub awkward_silence_count: ::std::option::Option<i64>,
        //needs the RemoteSession; the agent's own claim
        #[serde(rename = "e2eLatencyMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub e2e_latency_ms: ::std::option::Option<i64>,
        //agent started before the caller's turn ended
        #[serde(
            rename = "eotMispredictionCount",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub eot_misprediction_count: ::std::option::Option<i64>,
        //needs the RemoteSession; agent paused for a non-interruption
        #[serde(
            rename = "falseInterruptionCount",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub false_interruption_count: ::std::option::Option<i64>,
        //floor-transfer offset; a gap is > 0, an overlap < 0
        #[serde(
            rename = "heardE2eLatencyP50Ms",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub heard_e2e_latency_p50_ms: ::std::option::Option<i32>,
        #[serde(
            rename = "heardE2eLatencyP95Ms",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub heard_e2e_latency_p95_ms: ::std::option::Option<i32>,
        #[serde(
            rename = "heardE2eLatencyP99Ms",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub heard_e2e_latency_p99_ms: ::std::option::Option<i32>,
        //overlapping speech / total speech
        #[serde(rename = "overlapRatio", skip_serializing_if = "::std::option::Option::is_none")]
        pub overlap_ratio: ::std::option::Option<f32>,
        //pooling stats for overlap_ratio
        #[serde(
            rename = "overlapSpeechMs",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub overlap_speech_ms: ::std::option::Option<i64>,
        //agent audio continuing past a barge-in
        #[serde(rename = "timeToYieldMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub time_to_yield_ms: ::std::option::Option<i64>,
        #[serde(rename = "totalSpeechMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub total_speech_ms: ::std::option::Option<i64>,
        //0-1
        #[serde(
            rename = "turnTakingScore",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub turn_taking_score: ::std::option::Option<f32>,
        //the simulated party spoke, the agent never responded
        #[serde(
            rename = "unansweredTurns",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub unanswered_turns: ::std::option::Option<i64>,
    }
    //`LivekitSimulationRunJobMetricsLlm`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunJobMetricsLlm {
        //needs the RemoteSession
        #[serde(
            rename = "tokensPerSecond",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tokens_per_second: ::std::option::Option<f32>,
        //needs the RemoteSession; time to first sentence, the smallest speakable unit
        #[serde(rename = "ttfsMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub ttfs_ms: ::std::option::Option<i64>,
        //needs the RemoteSession; time to first token
        #[serde(rename = "ttftMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub ttft_ms: ::std::option::Option<i64>,
    }
    //The agent's perception of the caller. Audio only.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunJobMetricsStt {
        //needs the RemoteSession; char_errors / chars
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub cer: ::std::option::Option<f32>,
        //needs the RemoteSession
        #[serde(rename = "charErrors", skip_serializing_if = "::std::option::Option::is_none")]
        pub char_errors: ::std::option::Option<i64>,
        //needs the RemoteSession
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub chars: ::std::option::Option<i64>,
        #[serde(
            rename = "entitiesAcquiredRecognized",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub entities_acquired_recognized: ::std::option::Option<i64>,
        #[serde(
            rename = "entitiesAcquiredUttered",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub entities_acquired_uttered: ::std::option::Option<i64>,
        #[serde(
            rename = "entitiesRecognized",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub entities_recognized: ::std::option::Option<i64>,
        #[serde(
            rename = "entitiesUttered",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub entities_uttered: ::std::option::Option<i64>,
        /*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*/
        #[serde(rename = "entityRecall", skip_serializing_if = "::std::option::Option::is_none")]
        pub entity_recall: ::std::option::Option<f32>,
        //Key entities (names, IDs, amounts) the caller said. Needs the text judge. recognized / uttered
        #[serde(
            rename = "entityRecognition",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub entity_recognition: ::std::option::Option<f32>,
        //needs the RemoteSession; agent-reported STT/endpointing delay
        #[serde(rename = "sttDelayMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub stt_delay_ms: ::std::option::Option<i64>,
        //needs the RemoteSession; word_errors / words
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub wer: ::std::option::Option<f32>,
        //needs the RemoteSession
        #[serde(rename = "wordErrors", skip_serializing_if = "::std::option::Option::is_none")]
        pub word_errors: ::std::option::Option<i64>,
        //needs the RemoteSession
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub words: ::std::option::Option<i64>,
    }
    //The agent's voice. Audio only.
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunJobMetricsTts {
        //needs the RemoteSession; char_errors / chars
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub cer: ::std::option::Option<f32>,
        //needs the RemoteSession
        #[serde(rename = "charErrors", skip_serializing_if = "::std::option::Option::is_none")]
        pub char_errors: ::std::option::Option<i64>,
        //needs the RemoteSession
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub chars: ::std::option::Option<i64>,
        #[serde(
            rename = "entitiesAcquiredRecognized",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub entities_acquired_recognized: ::std::option::Option<i64>,
        #[serde(
            rename = "entitiesAcquiredUttered",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub entities_acquired_uttered: ::std::option::Option<i64>,
        #[serde(
            rename = "entitiesRecognized",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub entities_recognized: ::std::option::Option<i64>,
        #[serde(
            rename = "entitiesUttered",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub entities_uttered: ::std::option::Option<i64>,
        //acquired_recognized / acquired_uttered
        #[serde(rename = "entityRecall", skip_serializing_if = "::std::option::Option::is_none")]
        pub entity_recall: ::std::option::Option<f32>,
        //Key entities the agent said, as the caller heard them. Needs the text judge. recognized / uttered
        #[serde(
            rename = "entityRecognition",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub entity_recognition: ::std::option::Option<f32>,
        //needs the RemoteSession; provider byte-level TTFB
        #[serde(rename = "ttfbMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub ttfb_ms: ::std::option::Option<i64>,
        //needs the RemoteSession; word_errors / words
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub wer: ::std::option::Option<f32>,
        //needs the RemoteSession
        #[serde(rename = "wordErrors", skip_serializing_if = "::std::option::Option::is_none")]
        pub word_errors: ::std::option::Option<i64>,
        //needs the RemoteSession
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub words: ::std::option::Option<i64>,
    }
    /*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(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunJobMetricsTurn {
        #[serde(rename = "awkwardSilence", skip_serializing_if = "::std::option::Option::is_none")]
        pub awkward_silence: ::std::option::Option<bool>,
        //needs the text judge
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub conciseness: ::std::option::Option<f32>,
        //needs the RemoteSession
        #[serde(rename = "e2eLatencyMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub e2e_latency_ms: ::std::option::Option<i64>,
        //audio only
        #[serde(rename = "endMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub end_ms: ::std::option::Option<i64>,
        #[serde(
            rename = "eotMisprediction",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub eot_misprediction: ::std::option::Option<bool>,
        #[serde(
            rename = "heardE2eLatencyMs",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub heard_e2e_latency_ms: ::std::option::Option<i32>,
        //1-based, conversation order
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub index: ::std::option::Option<i64>,
        //needs the RemoteSession
        #[serde(rename = "llmTps", skip_serializing_if = "::std::option::Option::is_none")]
        pub llm_tps: ::std::option::Option<f32>,
        //needs the RemoteSession
        #[serde(rename = "llmTtfsMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub llm_ttfs_ms: ::std::option::Option<i64>,
        //needs the RemoteSession
        #[serde(rename = "llmTtftMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub llm_ttft_ms: ::std::option::Option<i64>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<LivekitAgentChatRole>,
        //audio only; relative to t0; unset if the turn could not be aligned to the audio
        #[serde(rename = "startMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub start_ms: ::std::option::Option<i64>,
        //needs the RemoteSession
        #[serde(rename = "sttDelayMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub stt_delay_ms: ::std::option::Option<i64>,
        #[serde(rename = "timeToYieldMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub time_to_yield_ms: ::std::option::Option<i64>,
        //needs the RemoteSession
        #[serde(rename = "ttsTtfbMs", skip_serializing_if = "::std::option::Option::is_none")]
        pub tts_ttfb_ms: ::std::option::Option<i64>,
        #[serde(
            rename = "turnTakingScore",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub turn_taking_score: ::std::option::Option<f32>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub unanswered: ::std::option::Option<bool>,
    }
    //`LivekitSimulationRunJobStatus`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitSimulationRunJobStatus {
        #[serde(rename = "STATUS_PENDING")]
        StatusPending,
        #[serde(rename = "STATUS_RUNNING")]
        StatusRunning,
        #[serde(rename = "STATUS_COMPLETED")]
        StatusCompleted,
        #[serde(rename = "STATUS_FAILED")]
        StatusFailed,
        #[serde(rename = "STATUS_CANCELLED")]
        StatusCancelled,
    }
    impl ::std::fmt::Display for LivekitSimulationRunJobStatus {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::StatusPending => f.write_str("STATUS_PENDING"),
                Self::StatusRunning => f.write_str("STATUS_RUNNING"),
                Self::StatusCompleted => f.write_str("STATUS_COMPLETED"),
                Self::StatusFailed => f.write_str("STATUS_FAILED"),
                Self::StatusCancelled => f.write_str("STATUS_CANCELLED"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitSimulationRunJobStatus {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "STATUS_PENDING" => Ok(Self::StatusPending),
                "STATUS_RUNNING" => Ok(Self::StatusRunning),
                "STATUS_COMPLETED" => Ok(Self::StatusCompleted),
                "STATUS_FAILED" => Ok(Self::StatusFailed),
                "STATUS_CANCELLED" => Ok(Self::StatusCancelled),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitSimulationRunJobStatus {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitSimulationRunJobStatus {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitSimulationRunJobUsage`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunJobUsage {
        #[serde(
            rename = "audioTurnsCount",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub audio_turns_count: ::std::option::Option<i32>,
        #[serde(rename = "textTurnsCount", skip_serializing_if = "::std::option::Option::is_none")]
        pub text_turns_count: ::std::option::Option<i32>,
    }
    //`LivekitSimulationRunList`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct LivekitSimulationRunList(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for LivekitSimulationRunList {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }
    impl ::std::convert::From<LivekitSimulationRunList>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: LivekitSimulationRunList) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for LivekitSimulationRunList
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }
    //`LivekitSimulationRunListRequest`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunListRequest {
        /*Exact agent name. Unset means every agent — including the runs whose
        name is empty, which a bare string could not tell from no filter.*/
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        #[serde(rename = "endTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub end_time: ::std::option::Option<::pbjson_types::Timestamp>,
        /*Absent applies no mode filter. TEXT matches runs stored as TEXT or
        UNSPECIFIED, which `SimulationRun.mode` defines as the same mode.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub mode: ::std::option::Option<LivekitSimulationMode>,
        #[serde(rename = "pageToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub page_token: ::std::option::Option<LivekitTokenPagination>,
        #[serde(rename = "projectId", skip_serializing_if = "::std::option::Option::is_none")]
        pub project_id: ::std::option::Option<::std::string::String>,
        /*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.*/
        #[serde(rename = "startTime", skip_serializing_if = "::std::option::Option::is_none")]
        pub start_time: ::std::option::Option<::pbjson_types::Timestamp>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<LivekitSimulationRunStatus>,
    }
    //`LivekitSimulationRunListResponse`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunListResponse {
        #[serde(rename = "nextPageToken", skip_serializing_if = "::std::option::Option::is_none")]
        pub next_page_token: ::std::option::Option<LivekitTokenPagination>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub runs: ::std::vec::Vec<LivekitSimulationRun>,
    }
    /*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(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunRunMetrics {
        //Means over the jobs that report them.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub conciseness: ::std::option::Option<f32>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub conversation: ::std::option::Option<LivekitSimulationRunJobMetricsConversation>,
        #[serde(
            rename = "conversationProgression",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub conversation_progression: ::std::option::Option<f32>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub llm: ::std::option::Option<LivekitSimulationRunJobMetricsLlm>,
        //mean over scored jobs
        #[serde(rename = "overallScore", skip_serializing_if = "::std::option::Option::is_none")]
        pub overall_score: ::std::option::Option<f32>,
        //share of jobs whose scenario verdict passed
        #[serde(
            rename = "scenarioPassRate",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub scenario_pass_rate: ::std::option::Option<f32>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub stt: ::std::option::Option<LivekitSimulationRunJobMetricsStt>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub tts: ::std::option::Option<LivekitSimulationRunJobMetricsTts>,
    }
    /*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(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunSamplingOptions {
        /*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.*/
        #[serde(rename = "passRate", skip_serializing_if = "::std::option::Option::is_none")]
        pub pass_rate: ::std::option::Option<f64>,
        /*Samples per scenario, > 1. The run holds scenarios × samples jobs,
        subject to the usual job cap.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub samples: ::std::option::Option<i32>,
    }
    //`LivekitSimulationRunStatus`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitSimulationRunStatus {
        #[serde(rename = "STATUS_PENDING_UPLOAD")]
        StatusPendingUpload,
        #[serde(rename = "STATUS_GENERATING")]
        StatusGenerating,
        #[serde(rename = "STATUS_RUNNING")]
        StatusRunning,
        #[serde(rename = "STATUS_SUMMARIZING")]
        StatusSummarizing,
        #[serde(rename = "STATUS_COMPLETED")]
        StatusCompleted,
        #[serde(rename = "STATUS_FAILED")]
        StatusFailed,
        #[serde(rename = "STATUS_CANCELLED")]
        StatusCancelled,
    }
    impl ::std::fmt::Display for LivekitSimulationRunStatus {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::StatusPendingUpload => f.write_str("STATUS_PENDING_UPLOAD"),
                Self::StatusGenerating => f.write_str("STATUS_GENERATING"),
                Self::StatusRunning => f.write_str("STATUS_RUNNING"),
                Self::StatusSummarizing => f.write_str("STATUS_SUMMARIZING"),
                Self::StatusCompleted => f.write_str("STATUS_COMPLETED"),
                Self::StatusFailed => f.write_str("STATUS_FAILED"),
                Self::StatusCancelled => f.write_str("STATUS_CANCELLED"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitSimulationRunStatus {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "STATUS_PENDING_UPLOAD" => Ok(Self::StatusPendingUpload),
                "STATUS_GENERATING" => Ok(Self::StatusGenerating),
                "STATUS_RUNNING" => Ok(Self::StatusRunning),
                "STATUS_SUMMARIZING" => Ok(Self::StatusSummarizing),
                "STATUS_COMPLETED" => Ok(Self::StatusCompleted),
                "STATUS_FAILED" => Ok(Self::StatusFailed),
                "STATUS_CANCELLED" => Ok(Self::StatusCancelled),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitSimulationRunStatus {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitSimulationRunStatus {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitSimulationRunSummary`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunSummary {
        #[serde(
            rename = "chatHistory",
            default,
            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
        )]
        pub chat_history:
            ::std::collections::HashMap<::std::string::String, LivekitAgentChatContext>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub failed: ::std::option::Option<i32>,
        #[serde(rename = "goingWell", skip_serializing_if = "::std::option::Option::is_none")]
        pub going_well: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub issues: ::std::vec::Vec<LivekitSimulationRunSummaryIssue>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub passed: ::std::option::Option<i32>,
        #[serde(rename = "toImprove", skip_serializing_if = "::std::option::Option::is_none")]
        pub to_improve: ::std::option::Option<::std::string::String>,
    }
    //`LivekitSimulationRunSummaryChatHistoryEntry`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunSummaryChatHistoryEntry {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<LivekitAgentChatContext>,
    }
    //`LivekitSimulationRunSummaryIssue`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunSummaryIssue {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub label: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub suggestion: ::std::option::Option<::std::string::String>,
    }
    //`LivekitSimulationRunUsage`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitSimulationRunUsage {
        #[serde(
            rename = "audioTurnsCount",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub audio_turns_count: ::std::option::Option<i32>,
        #[serde(rename = "textTurnsCount", skip_serializing_if = "::std::option::Option::is_none")]
        pub text_turns_count: ::std::option::Option<i32>,
    }
    //`LivekitStreamOutput`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitStreamOutput {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub protocol: ::std::option::Option<LivekitStreamProtocol>,
        //required
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub urls: ::std::vec::Vec<::std::string::String>,
    }
    //`LivekitStreamProtocol`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitStreamProtocol {
        #[serde(rename = "DEFAULT_PROTOCOL")]
        DefaultProtocol,
        #[serde(rename = "RTMP")]
        Rtmp,
        #[serde(rename = "SRT")]
        Srt,
        #[serde(rename = "WEBSOCKET")]
        Websocket,
    }
    impl ::std::fmt::Display for LivekitStreamProtocol {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::DefaultProtocol => f.write_str("DEFAULT_PROTOCOL"),
                Self::Rtmp => f.write_str("RTMP"),
                Self::Srt => f.write_str("SRT"),
                Self::Websocket => f.write_str("WEBSOCKET"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitStreamProtocol {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "DEFAULT_PROTOCOL" => Ok(Self::DefaultProtocol),
                "RTMP" => Ok(Self::Rtmp),
                "SRT" => Ok(Self::Srt),
                "WEBSOCKET" => Ok(Self::Websocket),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitStreamProtocol {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitStreamProtocol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitTokenPagination`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitTokenPagination {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub token: ::std::option::Option<::std::string::String>,
    }
    //`LivekitVideoCodec`
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum LivekitVideoCodec {
        #[serde(rename = "DEFAULT_VC")]
        DefaultVc,
        #[serde(rename = "H264_BASELINE")]
        H264Baseline,
        #[serde(rename = "H264_MAIN")]
        H264Main,
        #[serde(rename = "H264_HIGH")]
        H264High,
        #[serde(rename = "VP8")]
        Vp8,
    }
    impl ::std::fmt::Display for LivekitVideoCodec {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::DefaultVc => f.write_str("DEFAULT_VC"),
                Self::H264Baseline => f.write_str("H264_BASELINE"),
                Self::H264Main => f.write_str("H264_MAIN"),
                Self::H264High => f.write_str("H264_HIGH"),
                Self::Vp8 => f.write_str("VP8"),
            }
        }
    }
    impl ::std::str::FromStr for LivekitVideoCodec {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "DEFAULT_VC" => Ok(Self::DefaultVc),
                "H264_BASELINE" => Ok(Self::H264Baseline),
                "H264_MAIN" => Ok(Self::H264Main),
                "H264_HIGH" => Ok(Self::H264High),
                "VP8" => Ok(Self::Vp8),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LivekitVideoCodec {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LivekitVideoCodec {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    //`LivekitWebhookConfig`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct LivekitWebhookConfig {
        #[serde(rename = "filterParams", skip_serializing_if = "::std::option::Option::is_none")]
        pub filter_params: ::std::option::Option<LivekitFilterParams>,
        #[serde(rename = "signingKey", skip_serializing_if = "::std::option::Option::is_none")]
        pub signing_key: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }
    //`ProjectServiceAddWorkspaceMembersToProjectBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct ProjectServiceAddWorkspaceMembersToProjectBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
        #[serde(rename = "userIds", default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub user_ids: ::std::vec::Vec<::std::string::String>,
    }
    //`ProjectServiceAnswerInvitationBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct ProjectServiceAnswerInvitationBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub accept: ::std::option::Option<bool>,
    }
    //`ProjectServiceCreateTokenBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct ProjectServiceCreateTokenBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub grants: ::std::option::Option<LivekitPublicapiProjectsV1TokenGrants>,
        /*Requested lifetime in seconds. 0 means the default (10 minutes); at most
        86400 (24 hours).*/
        #[serde(rename = "ttlSeconds", skip_serializing_if = "::std::option::Option::is_none")]
        pub ttl_seconds: ::std::option::Option<i64>,
    }
    //`ProjectServiceGenerateKeyBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct ProjectServiceGenerateKeyBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        /*When true, the key is created without an owner (project-owned). It is not
        listed as anyone's personal key and survives the generating user leaving.*/
        #[serde(
            rename = "isServiceAccount",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_service_account: ::std::option::Option<bool>,
    }
    //InviteMember creates or refreshes a token invite (cloud InviteMember2).
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct ProjectServiceInviteMemberBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
    }
    //`ProjectServiceUpdateInviteBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct ProjectServiceUpdateInviteBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
    }
    //`ProjectServiceUpdateMemberBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct ProjectServiceUpdateMemberBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
    }
    /*UpdateProjectRequest patches a project. Unset optional fields are left
    unchanged (proto3 optional). Mirrors cloud-api UpdateProject for local mode;
    webhooks are separate RPCs (not included here).*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct ProjectServiceUpdateProjectBody {
        #[serde(rename = "customDomain", skip_serializing_if = "::std::option::Option::is_none")]
        pub custom_domain: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "disableTokenEndpoint",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub disable_token_endpoint: ::std::option::Option<bool>,
        #[serde(
            rename = "discoverableByDomain",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub discoverable_by_domain: ::std::option::Option<bool>,
        //LK-admin only
        #[serde(
            rename = "egressClusterId",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub egress_cluster_id: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "enableAnalytics",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_analytics: ::std::option::Option<bool>,
        #[serde(
            rename = "enableAutoCreate",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_auto_create: ::std::option::Option<bool>,
        #[serde(
            rename = "enableEgressAutoRetry",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_egress_auto_retry: ::std::option::Option<bool>,
        #[serde(
            rename = "enableEgressBackupStorage",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_egress_backup_storage: ::std::option::Option<bool>,
        //LK-admin only
        #[serde(
            rename = "enableHostedAgents",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_hosted_agents: ::std::option::Option<bool>,
        #[serde(
            rename = "enableInferenceRegionRestriction",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_inference_region_restriction: ::std::option::Option<bool>,
        #[serde(
            rename = "enablePiiRedaction",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_pii_redaction: ::std::option::Option<bool>,
        #[serde(
            rename = "enableRemoteUnmute",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_remote_unmute: ::std::option::Option<bool>,
        #[serde(
            rename = "enableUserDataRecording",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub enable_user_data_recording: ::std::option::Option<bool>,
        #[serde(
            rename = "enabledCodecs",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub enabled_codecs: ::std::vec::Vec<::std::string::String>,
        #[serde(
            rename = "featureFlags",
            default,
            skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
        )]
        pub feature_flags:
            ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        //Preferences (flat, matching cloud-api UpdateProjectRequest).
        #[serde(rename = "hideOnboarding", skip_serializing_if = "::std::option::Option::is_none")]
        pub hide_onboarding: ::std::option::Option<bool>,
        #[serde(
            rename = "hideSampleAppGallery",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub hide_sample_app_gallery: ::std::option::Option<bool>,
        #[serde(rename = "isPrivate", skip_serializing_if = "::std::option::Option::is_none")]
        pub is_private: ::std::option::Option<bool>,
        #[serde(
            rename = "joinableByDomain",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub joinable_by_domain: ::std::option::Option<bool>,
        //Used when becoming private: explicit member set (actor kept as ADMIN).
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub members: ::std::vec::Vec<LivekitPublicapiProjectsV1CreateProjectMember>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        /*Non-empty list replaces the stored set (validated via Canonical).
        Empty is ignored (cannot clear). When enabling with nothing stored,
        defaults are applied server-side — same as cloud-api UpdateProject.*/
        #[serde(
            rename = "piiRedactionCategories",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub pii_redaction_categories: ::std::vec::Vec<CloudProtocolPiiRedactionCategory>,
        #[serde(rename = "pinnedRegions", skip_serializing_if = "::std::option::Option::is_none")]
        pub pinned_regions: ::std::option::Option<LivekitPublicapiProjectsV1PinnedRegions>,
        #[serde(
            rename = "requireExplicitDispatch",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub require_explicit_dispatch: ::std::option::Option<bool>,
        #[serde(
            rename = "roomConfigsToDelete",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub room_configs_to_delete: ::std::vec::Vec<::std::string::String>,
        //RoomConfiguration management (stored on project preferences).
        #[serde(
            rename = "roomConfigsToUpsert",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub room_configs_to_upsert: ::std::vec::Vec<LivekitRoomConfiguration>,
        #[serde(rename = "sfuAllowPause", skip_serializing_if = "::std::option::Option::is_none")]
        pub sfu_allow_pause: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub subdomain: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "tokenEndpointKey",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_endpoint_key: ::std::option::Option<::std::string::String>,
    }
    //`SimulationServiceConfirmSimulationSourceUploadBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct SimulationServiceConfirmSimulationSourceUploadBody {
        //Entrypoint of the uploaded source, for example "agent.py".
        #[serde(rename = "codeEntrypoint", skip_serializing_if = "::std::option::Option::is_none")]
        pub code_entrypoint: ::std::option::Option<::std::string::String>,
    }
    //`SimulationServiceCreateSimulationRunBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct SimulationServiceCreateSimulationRunBody {
        /*Name the agent under test is registered under; every job dispatches it
        into the simulation room, so it must already be deployed or running as
        a worker. Empty uses the project's default agent. Recorded on the run
        and usable as a ListSimulationRuns filter.*/
        #[serde(rename = "agentName", skip_serializing_if = "::std::option::Option::is_none")]
        pub agent_name: ::std::option::Option<::std::string::String>,
        //Audio impairments applied to the simulated user; AUDIO mode only.
        #[serde(
            rename = "backgroundNoise",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub background_noise: ::std::option::Option<bool>,
        /*The CI pipeline this run came from, so runs can be linked back to
        commits.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub ci: ::std::option::Option<LivekitSimulationRunCi>,
        /*Maximum jobs running in parallel, at most 20; above that the request is
        InvalidArgument. The project's concurrency quota can run fewer at once.
        Unset uses the server default.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub concurrency: ::std::option::Option<i32>,
        #[serde(
            rename = "lowQualityMicrophone",
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub low_quality_microphone: ::std::option::Option<bool>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub mode: ::std::option::Option<LivekitSimulationMode>,
        /*Number of scenarios to generate from the agent source when
        scenario_group is unset.*/
        #[serde(rename = "numSimulations", skip_serializing_if = "::std::option::Option::is_none")]
        pub num_simulations: ::std::option::Option<i32>,
        #[serde(rename = "packetLoss", skip_serializing_if = "::std::option::Option::is_none")]
        pub packet_loss: ::std::option::Option<bool>,
        //Reserved: must be empty, and the service chooses where the run happens.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        /*Run exactly these scenarios (the contents of a scenarios.yaml) instead
        of generating num_simulations of them; the run then needs no source
        upload and starts immediately.*/
        #[serde(rename = "scenarioGroup", skip_serializing_if = "::std::option::Option::is_none")]
        pub scenario_group: ::std::option::Option<LivekitScenarioGroup>,
    }
    //`SimulationServiceGenerateScenarioFromSessionBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct SimulationServiceGenerateScenarioFromSessionBody {
        //Unused today: the session's recording is found by project and room.
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub region: ::std::option::Option<::std::string::String>,
        //Room session (RM_...) to derive the scenario from.
        #[serde(rename = "roomId", skip_serializing_if = "::std::option::Option::is_none")]
        pub room_id: ::std::option::Option<::std::string::String>,
    }
    //`Text`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct Text {
        pub text: ::std::string::String,
    }
    //`ThreadServiceCreateThreadBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct ThreadServiceCreateThreadBody {
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        #[serde(rename = "idleTtl", skip_serializing_if = "::std::option::Option::is_none")]
        pub idle_ttl: ::std::option::Option<::pbjson_types::Duration>,
        /*Optional scope grouping the thread (typically the user's identity),
        at most 256 bytes.*/
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub scope: ::std::option::Option<::std::string::String>,
    }
    //`ThreadServiceUpdateThreadBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct ThreadServiceUpdateThreadBody {
        #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
        pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        #[serde(rename = "idleTtl", skip_serializing_if = "::std::option::Option::is_none")]
        pub idle_ttl: ::std::option::Option<::pbjson_types::Duration>,
    }
    //`WorkspaceServiceAnswerInviteBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct WorkspaceServiceAnswerInviteBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub accept: ::std::option::Option<bool>,
    }
    //`WorkspaceServiceCreateInviteBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct WorkspaceServiceCreateInviteBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub email: ::std::option::Option<::std::string::String>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
    }
    //`WorkspaceServiceCreateProjectBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct WorkspaceServiceCreateProjectBody {
        #[serde(rename = "isPrivate", skip_serializing_if = "::std::option::Option::is_none")]
        pub is_private: ::std::option::Option<bool>,
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub members: ::std::vec::Vec<LivekitPublicapiProjectsV1CreateProjectMember>,
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        //optional; generated from name when empty
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub subdomain: ::std::option::Option<::std::string::String>,
        //create-only; empty keeps the deployment default
        #[serde(rename = "userDataRegion", skip_serializing_if = "::std::option::Option::is_none")]
        pub user_data_region: ::std::option::Option<::std::string::String>,
    }
    //`WorkspaceServiceUpdateMemberBody`
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct WorkspaceServiceUpdateMemberBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub role: ::std::option::Option<i32>,
    }
    /*Mirrors cloud-api WorkspaceService.UpdateWorkspace, which only accepts a
    name: workspace preferences (hipaa_compliant) cascade to every project in the
    workspace and are LK-admin-only there (AdminService.UpdateWorkspace), so they
    are deliberately not settable on this path.*/
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, Default)]
    pub struct WorkspaceServiceUpdateWorkspaceBody {
        #[serde(skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
    }
    // Error types.
    pub mod error {
        // Error from a `TryFrom` or `FromStr` implementation.
        pub struct ConversionError(::std::borrow::Cow<'static, str>);
        impl ::std::error::Error for ConversionError {}
        impl ::std::fmt::Display for ConversionError {
            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
                ::std::fmt::Display::fmt(&self.0, f)
            }
        }
        impl ::std::fmt::Debug for ConversionError {
            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
                ::std::fmt::Debug::fmt(&self.0, f)
            }
        }
        impl From<&'static str> for ConversionError {
            fn from(value: &'static str) -> Self {
                Self(value.into())
            }
        }
        impl From<String> for ConversionError {
            fn from(value: String) -> Self {
                Self(value.into())
            }
        }
    }
}
#[derive(Clone, Debug)]
/*Client for LiveKit Public API

Public HTTP API for LiveKit Cloud. Generated from protobuf.

Version: v0*/
pub struct Client {
    pub(crate) baseurl: String,
    pub(crate) client: reqwest::Client,
    pub(crate) inner: crate::public_api::Credentials,
}
impl Client {
    // Create a new client.
    //
    // `baseurl` is the base URL provided to the internal
    // `reqwest::Client`, and should include a scheme and hostname,
    // as well as port and a path stem if applicable.
    pub fn new(baseurl: &str, inner: crate::public_api::Credentials) -> Self {
        #[cfg(not(target_arch = "wasm32"))]
        let client = {
            let dur = ::std::time::Duration::from_secs(15u64);
            reqwest::ClientBuilder::new().connect_timeout(dur).timeout(dur)
        };
        #[cfg(target_arch = "wasm32")]
        let client = reqwest::ClientBuilder::new();
        Self::new_with_client(baseurl, client.build().unwrap(), inner)
    }
    // Construct a new client with an existing `reqwest::Client`,
    // allowing more control over its configuration.
    //
    // `baseurl` is the base URL provided to the internal
    // `reqwest::Client`, and should include a scheme and hostname,
    // as well as port and a path stem if applicable.
    pub fn new_with_client(
        baseurl: &str,
        client: reqwest::Client,
        inner: crate::public_api::Credentials,
    ) -> Self {
        Self { baseurl: baseurl.to_string(), client, inner }
    }
}
impl ClientInfo<crate::public_api::Credentials> for Client {
    fn api_version() -> &'static str {
        "v0"
    }
    fn baseurl(&self) -> &str {
        self.baseurl.as_str()
    }
    fn client(&self) -> &reqwest::Client {
        &self.client
    }
    fn inner(&self) -> &crate::public_api::Credentials {
        &self.inner
    }
}
impl ClientHooks<crate::public_api::Credentials> for &Client {}
#[allow(clippy::all)]
impl Client {
    /*GetInvite

    Sends a `GET` request to `/v0/project-invites/{inviteToken}`

    */
    pub async fn project_service_get_invite<'a>(
        &'a self,
        invite_token: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1GetInviteResponse>, Error<()>> {
        let url = format!(
            "{}/v0/project-invites/{}",
            self.baseurl,
            encode_path(&invite_token.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_get_invite" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*AnswerInvitation

    Sends a `POST` request to `/v0/project-invites/{inviteToken}:answer`

    */
    pub async fn project_service_answer_invitation<'a>(
        &'a self,
        invite_token: &'a str,
        body: &'a types::ProjectServiceAnswerInvitationBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1AnswerInvitationResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/project-invites/{}:answer",
            self.baseurl,
            encode_path(&invite_token.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_answer_invitation" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListProjects

    Sends a `GET` request to `/v0/projects`

    Arguments:
    - `member_id`: if member_id is set, list projects for the member
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `workspace_id`: Mutually exclusive: only one of workspace_id or member_id can be set
     if workspace_id is set, list projects for the workspace
    */
    pub async fn project_service_list_projects<'a>(
        &'a self,
        member_id: Option<&'a str>,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        workspace_id: Option<&'a str>,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1ListProjectsResponse>, Error<()>>
    {
        let url = format!("{}/v0/projects", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("memberId", &member_id))
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new("workspaceId", &workspace_id))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_list_projects" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*CreateProject

    Sends a `POST` request to `/v0/projects`

    */
    pub async fn project_service_create_project<'a>(
        &'a self,
        body: &'a types::LivekitPublicapiProjectsV1CreateProjectRequest,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1CreateProjectResponse>, Error<()>>
    {
        let url = format!("{}/v0/projects", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_create_project" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetProject

    Sends a `GET` request to `/v0/projects/{projectId}`

    */
    pub async fn project_service_get_project<'a>(
        &'a self,
        project_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1GetProjectResponse>, Error<()>> {
        let url = format!("{}/v0/projects/{}", self.baseurl, encode_path(&project_id.to_string()),);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_get_project" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*DeleteProject

    Sends a `DELETE` request to `/v0/projects/{projectId}`

    */
    pub async fn project_service_delete_project<'a>(
        &'a self,
        project_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1DeleteProjectResponse>, Error<()>>
    {
        let url = format!("{}/v0/projects/{}", self.baseurl, encode_path(&project_id.to_string()),);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_delete_project" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*UpdateProject

    Sends a `PATCH` request to `/v0/projects/{projectId}`

    */
    pub async fn project_service_update_project<'a>(
        &'a self,
        project_id: &'a str,
        body: &'a types::ProjectServiceUpdateProjectBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1UpdateProjectResponse>, Error<()>>
    {
        let url = format!("{}/v0/projects/{}", self.baseurl, encode_path(&project_id.to_string()),);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .patch(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_update_project" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetProjectAnalytics

    GetProjectAnalytics returns the project overview over a time range.

    Sends a `GET` request to `/v0/projects/{projectId}/analytics`

    Arguments:
    - `project_id`
    - `range_end_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    - `range_start_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    */
    pub async fn analytics_service_get_project_analytics<'a>(
        &'a self,
        project_id: &'a str,
        range_end_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
        range_start_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiAnalyticsV1ProjectOverviewGetResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/analytics",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("range.endTime", &range_end_time))
            .query(&progenitor_client::QueryParam::new("range.startTime", &range_start_time))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "analytics_service_get_project_analytics" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListAgentAnalytics

    ListAgentAnalytics returns the same per-agent analytics for every agent in
     the project, one AgentAnalytics row per agent — so a single agent and the
     whole roster share one shape.

    Sends a `GET` request to `/v0/projects/{projectId}/analytics/agents`

    Arguments:
    - `project_id`
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `range_end_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    - `range_start_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    */
    pub async fn analytics_service_list_agent_analytics<'a>(
        &'a self,
        project_id: &'a str,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        range_end_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
        range_start_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
    ) -> Result<ResponseValue<types::LivekitPublicapiAnalyticsV1AgentsListResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/analytics/agents",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new("range.endTime", &range_end_time))
            .query(&progenitor_client::QueryParam::new("range.startTime", &range_start_time))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "analytics_service_list_agent_analytics" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetAgentAnalytics

    GetAgentAnalytics returns the analytics for one agent over a time range.

    Sends a `GET` request to `/v0/projects/{projectId}/analytics/agents/{agentId}`

    Arguments:
    - `project_id`
    - `agent_id`
    - `range_end_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    - `range_start_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    */
    pub async fn analytics_service_get_agent_analytics<'a>(
        &'a self,
        project_id: &'a str,
        agent_id: &'a str,
        range_end_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
        range_start_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
    ) -> Result<ResponseValue<types::LivekitPublicapiAnalyticsV1AgentsGetResponse>, Error<()>> {
        let url = format!(
            "{}/v0/projects/{}/analytics/agents/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&agent_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("range.endTime", &range_end_time))
            .query(&progenitor_client::QueryParam::new("range.startTime", &range_start_time))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "analytics_service_get_agent_analytics" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListDatabases

    ListDatabases lists the project's databases, cursor-paginated.

    Sends a `GET` request to `/v0/projects/{projectId}/databases`

    Arguments:
    - `project_id`
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    */
    pub async fn database_service_list_databases<'a>(
        &'a self,
        project_id: &'a str,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
    ) -> Result<ResponseValue<types::LivekitPublicapiDatabasesV1DatabasesListResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/databases",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "database_service_list_databases" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*CreateDatabase

    CreateDatabase creates an empty database. Not idempotent: a retried
     request creates a second database.

    Sends a `POST` request to `/v0/projects/{projectId}/databases`

    */
    pub async fn database_service_create_database<'a>(
        &'a self,
        project_id: &'a str,
        body: &'a types::DatabaseServiceCreateDatabaseBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiDatabasesV1DatabasesCreateResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/databases",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "database_service_create_database" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetDatabase

    Sends a `GET` request to `/v0/projects/{projectId}/databases/{databaseId}`

    */
    pub async fn database_service_get_database<'a>(
        &'a self,
        project_id: &'a str,
        database_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiDatabasesV1DatabasesGetResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/databases/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&database_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "database_service_get_database" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*DeleteDatabase

    DeleteDatabase deletes the stored data, not just the metadata.

    Sends a `DELETE` request to `/v0/projects/{projectId}/databases/{databaseId}`

    */
    pub async fn database_service_delete_database<'a>(
        &'a self,
        project_id: &'a str,
        database_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiDatabasesV1DatabasesDeleteResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/databases/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&database_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "database_service_delete_database" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ExportDatabase

    ExportDatabase exports a consistent SQLite file as a time-limited download
     URL.

    Sends a `POST` request to `/v0/projects/{projectId}/databases/{databaseId}:export`

    */
    pub async fn database_service_export_database<'a>(
        &'a self,
        project_id: &'a str,
        database_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiDatabasesV1DatabasesExportResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/databases/{}:export",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&database_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "database_service_export_database" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListInvites

    Sends a `GET` request to `/v0/projects/{projectId}/invites`

    */
    pub async fn project_service_list_invites<'a>(
        &'a self,
        project_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1ListInvitesResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/invites",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_list_invites" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*InviteMember

    Sends a `POST` request to `/v0/projects/{projectId}/invites`

    */
    pub async fn project_service_invite_member<'a>(
        &'a self,
        project_id: &'a str,
        body: &'a types::ProjectServiceInviteMemberBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1InviteMemberResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/invites",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_invite_member" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*DeleteInvite

    Sends a `DELETE` request to `/v0/projects/{projectId}/invites/{email}`

    */
    pub async fn project_service_delete_invite<'a>(
        &'a self,
        project_id: &'a str,
        email: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1DeleteInviteResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/invites/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&email.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_delete_invite" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*UpdateInvite

    Sends a `PATCH` request to `/v0/projects/{projectId}/invites/{email}`

    */
    pub async fn project_service_update_invite<'a>(
        &'a self,
        project_id: &'a str,
        email: &'a str,
        body: &'a types::ProjectServiceUpdateInviteBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1UpdateInviteResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/invites/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&email.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .patch(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_update_invite" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListKeys

    Sends a `GET` request to `/v0/projects/{projectId}/keys`

    Arguments:
    - `project_id`
    - `include_agent_keys`: Agent keys are hidden by default, matching cloud-api-server.
    */
    pub async fn project_service_list_keys<'a>(
        &'a self,
        project_id: &'a str,
        include_agent_keys: Option<bool>,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1ListKeysResponse>, Error<()>> {
        let url =
            format!("{}/v0/projects/{}/keys", self.baseurl, encode_path(&project_id.to_string()),);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("includeAgentKeys", &include_agent_keys))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_list_keys" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GenerateKey

    Access keys (mirrors cloud ProjectService GenerateKey / ListKeys /
     ListScopedKeys / DeleteKey).

    Sends a `POST` request to `/v0/projects/{projectId}/keys`

    */
    pub async fn project_service_generate_key<'a>(
        &'a self,
        project_id: &'a str,
        body: &'a types::ProjectServiceGenerateKeyBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1GenerateKeyResponse>, Error<()>>
    {
        let url =
            format!("{}/v0/projects/{}/keys", self.baseurl, encode_path(&project_id.to_string()),);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_generate_key" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*DeleteKey

    Sends a `DELETE` request to `/v0/projects/{projectId}/keys/{apiKey}`

    */
    pub async fn project_service_delete_key<'a>(
        &'a self,
        project_id: &'a str,
        api_key: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1DeleteKeyResponse>, Error<()>> {
        let url = format!(
            "{}/v0/projects/{}/keys/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&api_key.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_delete_key" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListMembers

    Members & invites (token-based; mirrors cloud ProjectService current flows).

    Sends a `GET` request to `/v0/projects/{projectId}/members`

    */
    pub async fn project_service_list_members<'a>(
        &'a self,
        project_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1ListMembersResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/members",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_list_members" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetMember

    Sends a `GET` request to `/v0/projects/{projectId}/members/{userId}`

    */
    pub async fn project_service_get_member<'a>(
        &'a self,
        project_id: &'a str,
        user_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1GetMemberResponse>, Error<()>> {
        let url = format!(
            "{}/v0/projects/{}/members/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&user_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_get_member" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*RemoveMember

    Sends a `DELETE` request to `/v0/projects/{projectId}/members/{userId}`

    */
    pub async fn project_service_remove_member<'a>(
        &'a self,
        project_id: &'a str,
        user_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1RemoveMemberResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/members/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&user_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_remove_member" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*UpdateMember

    Sends a `PATCH` request to `/v0/projects/{projectId}/members/{userId}`

    */
    pub async fn project_service_update_member<'a>(
        &'a self,
        project_id: &'a str,
        user_id: &'a str,
        body: &'a types::ProjectServiceUpdateMemberBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1UpdateMemberResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/members/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&user_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .patch(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_update_member" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*AddWorkspaceMembersToProject

    Sends a `POST` request to `/v0/projects/{projectId}/members:addWorkspaceMembers`

    */
    pub async fn project_service_add_workspace_members_to_project<'a>(
        &'a self,
        project_id: &'a str,
        body: &'a types::ProjectServiceAddWorkspaceMembersToProjectBody,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiProjectsV1AddWorkspaceMembersToProjectResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/members:addWorkspaceMembers",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info =
            OperationInfo { operation_id: "project_service_add_workspace_members_to_project" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GenerateScenarioFromSession

    GenerateScenarioFromSession derives a reusable scenario (label,
     instructions and expectations) from a recorded room session, for use in a
     later run's scenario_group. Nothing is stored; the returned scenario is the
     result. The session must have a recorded chat history. Each call runs an
     LLM over it, so it counts against the project's scenario-generation quota
     and can take up to about a minute.

    Sends a `POST` request to `/v0/projects/{projectId}/scenarios:generateFromSession`

    */
    pub async fn simulation_service_generate_scenario_from_session<'a>(
        &'a self,
        project_id: &'a str,
        body: &'a types::SimulationServiceGenerateScenarioFromSessionBody,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiSimulationsV1ScenariosGenerateFromSessionResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/scenarios:generateFromSession",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info =
            OperationInfo { operation_id: "simulation_service_generate_scenario_from_session" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListScopedKeys

    Sends a `GET` request to `/v0/projects/{projectId}/scoped-keys`

    */
    pub async fn project_service_list_scoped_keys<'a>(
        &'a self,
        project_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1ListScopedKeysResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/scoped-keys",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_list_scoped_keys" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListProjectSessions

    ListProjectSessions lists room sessions for a project, newest first,
     cursor-paginated. Backed upstream by the ListingService room-sessions list.

    Sends a `GET` request to `/v0/projects/{projectId}/sessions`

    Arguments:
    - `project_id`
    - `filter_agent_id`: Cloud agent id (CA_...) — return only sessions this agent served. Duration is not filterable in v1.
    - `filter_range_end_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    - `filter_range_start_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    - `filter_room_name`: Room-name prefix match (case-sensitive): returns sessions whose room name
     starts with this value, e.g. `demo-` matches `demo-1` and `demo-lobby`.
    - `filter_session_id`: Exact room-session id match (RM_...).
    - `filter_statuses`: OR semantics; empty matches any status.
    - `filter_tags`: OR semantics.
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `sort_order`: Direction of the started_at ordering, the only column sessions sort on.
     Defaults to descending (newest first) when unset.
    */
    pub async fn analytics_service_list_project_sessions<'a>(
        &'a self,
        project_id: &'a str,
        filter_agent_id: Option<&'a str>,
        filter_range_end_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
        filter_range_start_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
        filter_room_name: Option<&'a str>,
        filter_session_id: Option<&'a str>,
        filter_statuses: Option<
            &'a ::std::vec::Vec<types::LivekitPublicapiAnalyticsV1SessionStatus>,
        >,
        filter_tags: Option<&'a ::std::vec::Vec<::std::string::String>>,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        sort_order: Option<types::LivekitPublicapiCommonV1SortOrder>,
    ) -> Result<ResponseValue<types::LivekitPublicapiAnalyticsV1SessionsListResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/sessions",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("filter.agentId", &filter_agent_id))
            .query(&progenitor_client::QueryParam::new(
                "filter.range.endTime",
                &filter_range_end_time,
            ))
            .query(&progenitor_client::QueryParam::new(
                "filter.range.startTime",
                &filter_range_start_time,
            ))
            .query(&progenitor_client::QueryParam::new("filter.roomName", &filter_room_name))
            .query(&progenitor_client::QueryParam::new("filter.sessionId", &filter_session_id))
            .query(&progenitor_client::QueryParam::new("filter.statuses", &filter_statuses))
            .query(&progenitor_client::QueryParam::new("filter.tags", &filter_tags))
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new("sortOrder", &sort_order))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "analytics_service_list_project_sessions" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetSession

    GetSession returns one room session. The response carries both the list-row
     `session` and the richer `detail` (participants, per-metric data points).

    Sends a `GET` request to `/v0/projects/{projectId}/sessions/{sessionId}`

    */
    pub async fn analytics_service_get_session<'a>(
        &'a self,
        project_id: &'a str,
        session_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiAnalyticsV1SessionsGetResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/sessions/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&session_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "analytics_service_get_session" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListSessionEvents lists one room session's events, oldest first by default,
     cursor-paginated with no total. With no `types`, it returns the seven the
     dashboard's events table shows: PARTICIPANT_JOINED, PARTICIPANT_LEFT,
     PARTICIPANT_ACTIVE, PARTICIPANT_RESUMED, ROOM_CREATED, ROOM_ENDED and
     API_CALL. `types` asks for others, such as TRACK_PUBLISHED, and
     `participant_session_id` keeps one participant session's events. With
     `participant_session_id` and no `types`, it returns the eleven the
     dashboard's participant events table shows: that participant session's
     PARTICIPANT_JOINED, PARTICIPANT_LEFT, PARTICIPANT_RESUMED and
     PARTICIPANT_ACTIVE, and its TRACK_MUTED, TRACK_UNMUTED, TRACK_PUBLISHED,
     TRACK_UNPUBLISHED, TRACK_SUBSCRIBED, TRACK_SUBSCRIBE_REQUESTED and
     TRACK_SUBSCRIBE_FAILED

    Unlike the dashboard, on purpose: an unknown type or a malformed
     participant session id is InvalidArgument rather than being searched for
     as typed, and types match exactly, so TRACK_PUBLISHED doesn't also return
     TRACK_PUBLISHED_UPDATE. Each event's payload keeps only an allowlist of
     fields, leaving out participants' attributes and metadata and API calls'
     request bodies. Each event and participant row still carries the
     participant's identity, as the dashboard shows it to every member, and
     for a SIP caller that can be a phone number.

     Events are kept for 60 days, which can be shorter than the session's other
     data, so an older session can list no events. An ACTIVE session lists the
     events recorded so far. An unknown session is NotFound.

    Sends a `GET` request to `/v0/projects/{projectId}/sessions/{sessionId}/events`

    Arguments:
    - `project_id`
    - `session_id`
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `participant_session_id`: Only the events of this participant session (PA_...), as the
     participants list's ParticipantSession.participant_session_id names
     it. Room events and API calls name no participant session, so they
     are left out. Anything but a PA_ id is InvalidArgument.
    - `sort_order`: Direction of the timestamp ordering. Defaults to ascending (oldest
     first) when unset.
    - `types`: Event types to return, by name, such as TRACK_PUBLISHED: the names of
     LiveKit's AnalyticsEventType. Each matches exactly. Empty returns the
     dashboard's seven defaults, or with participant_session_id its eleven
     participant defaults, track events included (see ListSessionEvents).
     An unknown name is InvalidArgument.
    */
    pub async fn analytics_service_list_session_events<'a>(
        &'a self,
        project_id: &'a str,
        session_id: &'a str,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        participant_session_id: Option<&'a str>,
        sort_order: Option<types::LivekitPublicapiCommonV1SortOrder>,
        types: Option<&'a ::std::vec::Vec<::std::string::String>>,
    ) -> Result<ResponseValue<types::LivekitPublicapiAnalyticsV1SessionEventsListResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/sessions/{}/events",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&session_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new(
                "participantSessionId",
                &participant_session_id,
            ))
            .query(&progenitor_client::QueryParam::new("sortOrder", &sort_order))
            .query(&progenitor_client::QueryParam::new("types", &types))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "analytics_service_list_session_events" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetSessionLogs returns the log records the session's agents exported, in
     time order: what the dashboard's logs panel shows. Their chat history is
     left out, since GetSessionTranscript reads it, and their evaluation
     results stay in. The session's events, such as participants joining,
     come from AnalyticsService's ListSessionEvents

    An ACTIVE session returns what its agents have exported so far. A record
     exported mid-read with a time this read has already paged past, earlier
     than its cursor's when oldest first, is missed until a new read. An
     unknown session is NotFound. A read filtered by log_levels can come back
     empty because no record is at those levels, so only an unfiltered one is
     ObservabilityDisabled.

    Sends a `GET` request to `/v0/projects/{projectId}/sessions/{sessionId}/logs`

    Arguments:
    - `project_id`
    - `session_id`: The session's RM_ id.
    - `log_levels`: Only records at these levels, as the dashboard's logs filter selects
     them, for example only TRACE and FATAL. Empty returns every record,
     including those with no level, such as a passed evaluation.
     LOG_LEVEL_UNSPECIFIED is InvalidArgument.
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `sort_order`: Direction of the timestamp ordering. Defaults to ascending (oldest
     first) when unset.
    */
    pub async fn observability_service_get_session_logs<'a>(
        &'a self,
        project_id: &'a str,
        session_id: &'a str,
        log_levels: Option<&'a ::std::vec::Vec<types::LivekitPublicapiObservabilityV1LogLevel>>,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        sort_order: Option<types::LivekitPublicapiCommonV1SortOrder>,
    ) -> Result<ResponseValue<types::LivekitPublicapiObservabilityV1LogsGetResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/sessions/{}/logs",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&session_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("logLevels", &log_levels))
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new("sortOrder", &sort_order))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "observability_service_get_session_logs" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetSessionMetrics returns the OpenTelemetry metric points the session's
     agents exported, by time, typed: turn latencies such as
     lk.agents.turn.e2e_latency and lk.agents.turn.llm_ttft, token and duration
     usage such as lk.agents.usage.llm_input_tokens, and the gen_ai.*
     histograms, along with any metrics the agent's own code recorded

    These are the raw metrics agents emit, so they won't exactly match the
     dashboard's metrics panel, which derives its numbers from the transcript
     and traces. Only agents that export OpenTelemetry metrics to LiveKit Cloud
     produce them: an agent whose code installs its own MeterProvider exports
     none to LiveKit Cloud, and its sessions return no points.

     Some points aren't labeled as their agent exported them. These are
     limitations of the upstream aggregator, which groups a session's series
     by their attributes alone and names each group after its first row:
       - several metrics can come back under one name, such as an LLM's input,
         output and cached token counts, all named
         lk.agents.usage.llm_input_tokens;
       - points of one series at the same time that recorded equal values
         collapse into one point;
       - with two agents in one session, a point can carry the other agent's
         resource attributes.

     An agent exports its metrics every 30 seconds, and its turn latencies
     when the session ends, so an ACTIVE session returns what it has exported
     so far. An unknown session is NotFound. A read filtered by names can come
     back empty because no metric has those names, so only an unfiltered one
     is ObservabilityDisabled.

    Sends a `GET` request to `/v0/projects/{projectId}/sessions/{sessionId}/metrics`

    Arguments:
    - `project_id`
    - `session_id`: The session's RM_ id.
    - `names`: Only the points of these metrics, matched exactly, such as
     lk.agents.turn.e2e_latency. Empty returns every metric. At most 50
     names, each 1 to 256 characters.
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    */
    pub async fn observability_service_get_session_metrics<'a>(
        &'a self,
        project_id: &'a str,
        session_id: &'a str,
        names: Option<&'a ::std::vec::Vec<::std::string::String>>,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
    ) -> Result<ResponseValue<types::LivekitPublicapiObservabilityV1MetricsGetResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/sessions/{}/metrics",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&session_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("names", &names))
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "observability_service_get_session_metrics" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListSessionParticipants

    ListSessionParticipants lists the participants of one room session, one row
     per identity, cursor-paginated; newest join first by default. Each row
     carries the participant's participant sessions (PA_...), each with the
     client it connected from.

    Sends a `GET` request to `/v0/projects/{projectId}/sessions/{sessionId}/participants`

    Arguments:
    - `project_id`
    - `session_id`
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `sort_by`: Column to order by. Defaults to joined_at when unset.
    - `sort_order`: Direction of sort_by. Defaults to descending (newest first) when unset.
    */
    pub async fn analytics_service_list_session_participants<'a>(
        &'a self,
        project_id: &'a str,
        session_id: &'a str,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        sort_by: Option<types::LivekitPublicapiAnalyticsV1ParticipantSortField>,
        sort_order: Option<types::LivekitPublicapiCommonV1SortOrder>,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiAnalyticsV1SessionParticipantsListResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/sessions/{}/participants",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&session_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new("sortBy", &sort_by))
            .query(&progenitor_client::QueryParam::new("sortOrder", &sort_order))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "analytics_service_list_session_participants" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetSessionRecordingURL

    GetSessionRecordingURL returns a short-lived signed URL for one of the
     session's recordings: its audio or its chat history. A session with no
     recording of that type is NotFound. A new recording can be NotFound for
     up to a minute after the session ends.

    Sends a `GET` request to `/v0/projects/{projectId}/sessions/{sessionId}/recording-url`

    Arguments:
    - `project_id`
    - `session_id`
    - `expiry_seconds`: How long the URL stays valid, in seconds. Unset or 0 is 900 (15
     minutes), and anything longer is clamped to 900 without an error;
     expires_at says what was granted.
    - `file_type`: Which recording to sign a URL for. UNSPECIFIED is InvalidArgument.
    */
    pub async fn observability_service_get_session_recording_url<'a>(
        &'a self,
        project_id: &'a str,
        session_id: &'a str,
        expiry_seconds: Option<i64>,
        file_type: Option<types::LivekitPublicapiObservabilityV1RecordingFileType>,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiObservabilityV1RecordingGetUrlResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/sessions/{}/recording-url",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&session_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("expirySeconds", &expiry_seconds))
            .query(&progenitor_client::QueryParam::new("fileType", &file_type))
            .headers(header_map)
            .build()?;
        let info =
            OperationInfo { operation_id: "observability_service_get_session_recording_url" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetSessionTraces returns the spans the session's agents exported, by
     start time: what the dashboard's trace view shows. Each span names its
     parent, so the pages rebuild the span tree, and its attributes carry the
     turn and latency fields the dashboard's turn view reads, such as
     lk.generation_id and lk.response.ttft

    An ACTIVE session returns what its agents have exported so far; a span
     exported after the first page waits for a new read. The later pages are
     read by offset, so a span exported mid-read can still shift them: a span
     can repeat, or be skipped. Dedupe by span_id, and read again from the
     first page to pick up a skipped span. An unknown session is NotFound.

    Sends a `GET` request to `/v0/projects/{projectId}/sessions/{sessionId}/traces`

    Arguments:
    - `project_id`
    - `session_id`: The session's RM_ id.
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    */
    pub async fn observability_service_get_session_traces<'a>(
        &'a self,
        project_id: &'a str,
        session_id: &'a str,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
    ) -> Result<ResponseValue<types::LivekitPublicapiObservabilityV1TracesGetResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/sessions/{}/traces",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&session_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "observability_service_get_session_traces" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetSessionTranscript returns the session's conversation as ordered
     transcript items: messages, tool calls and results, agent handoffs and
     agent configuration changes. It is the conversation the dashboard's
     transcript shows

    The agent exports its transcript when the session ends, and it can be
     read a minute or two later; on a project with PII redaction, only once
     the session's recording has been redacted. So a session that is still
     ACTIVE returns what exists so far, usually nothing, without an error:
     read it again after the session ends. An unknown session is NotFound.

    Sends a `GET` request to `/v0/projects/{projectId}/sessions/{sessionId}/transcript`

    Arguments:
    - `project_id`
    - `session_id`: The session's RM_ id.
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    */
    pub async fn observability_service_get_session_transcript<'a>(
        &'a self,
        project_id: &'a str,
        session_id: &'a str,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
    ) -> Result<ResponseValue<types::LivekitPublicapiObservabilityV1TranscriptGetResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/sessions/{}/transcript",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&session_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "observability_service_get_session_transcript" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListSimulationRuns

    ListSimulationRuns lists a project's runs, newest first, cursor-paginated,
     optionally narrowed by status, agent, conversation mode and a time window.
     Rows carry headline counts (job_count, passed_count, failed_count,
     issue_count) but neither jobs nor the summary.

    Sends a `GET` request to `/v0/projects/{projectId}/simulation-runs`

    Arguments:
    - `project_id`
    - `agent_name`: Only runs of this agent (exact name).
    - `end_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    - `mode`: Only runs in this conversation mode.
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `start_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    - `status`: Only runs in this status.
    */
    pub async fn simulation_service_list_simulation_runs<'a>(
        &'a self,
        project_id: &'a str,
        agent_name: Option<&'a str>,
        end_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
        mode: Option<types::LivekitSimulationMode>,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        start_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
        status: Option<types::LivekitSimulationRunStatus>,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiSimulationsV1SimulationRunsListResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/simulation-runs",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("agentName", &agent_name))
            .query(&progenitor_client::QueryParam::new("endTime", &end_time))
            .query(&progenitor_client::QueryParam::new("mode", &mode))
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new("startTime", &start_time))
            .query(&progenitor_client::QueryParam::new("status", &status))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "simulation_service_list_simulation_runs" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*CreateSimulationRun

    CreateSimulationRun registers a new run. With a scenario_group it starts
     right away and no upload target is returned. Without one it waits in
     PENDING_UPLOAD for the agent source that scenarios are generated from:
     upload it to the returned presigned POST, then call
     ConfirmSimulationSourceUpload. A run left pending for an hour is failed.
     Creating a run is not idempotent: a retried request starts a second run.

    Sends a `POST` request to `/v0/projects/{projectId}/simulation-runs`

    */
    pub async fn simulation_service_create_simulation_run<'a>(
        &'a self,
        project_id: &'a str,
        body: &'a types::SimulationServiceCreateSimulationRunBody,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiSimulationsV1SimulationRunsCreateResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/simulation-runs",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "simulation_service_create_simulation_run" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetSimulationRun

    GetSimulationRun returns one run with its jobs and aggregate metrics. The
     compressed summary blob (summary_zstd) is omitted; use
     GetSimulationRunSummary for the decoded summary.

    Sends a `GET` request to `/v0/projects/{projectId}/simulation-runs/{simulationRunId}`

    */
    pub async fn simulation_service_get_simulation_run<'a>(
        &'a self,
        project_id: &'a str,
        simulation_run_id: &'a str,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiSimulationsV1SimulationRunsGetResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/simulation-runs/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&simulation_run_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "simulation_service_get_simulation_run" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetSimulationRunSummary

    GetSimulationRunSummary returns the graded outcome of a finished run:
     pass/fail counts, what went well, what to improve, flagged issues with
     suggestions, and the per-job chat history. FailedPrecondition while the
     run is still going; NotFound if the run finished without a summary.

    Sends a `GET` request to `/v0/projects/{projectId}/simulation-runs/{simulationRunId}/summary`

    */
    pub async fn simulation_service_get_simulation_run_summary<'a>(
        &'a self,
        project_id: &'a str,
        simulation_run_id: &'a str,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiSimulationsV1SimulationRunsGetSummaryResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/simulation-runs/{}/summary",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&simulation_run_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "simulation_service_get_simulation_run_summary" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*CancelSimulationRun

    CancelSimulationRun stops a run that has not finished. Cancelling a run
     that already finished succeeds without effect.

    Sends a `POST` request to `/v0/projects/{projectId}/simulation-runs/{simulationRunId}:cancel`

    */
    pub async fn simulation_service_cancel_simulation_run<'a>(
        &'a self,
        project_id: &'a str,
        simulation_run_id: &'a str,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiSimulationsV1SimulationRunsCancelResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/simulation-runs/{}:cancel",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&simulation_run_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "simulation_service_cancel_simulation_run" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ConfirmSimulationSourceUpload

    ConfirmSimulationSourceUpload marks the agent source as uploaded and starts
     scenario generation; the run moves to GENERATING, then RUNNING once the
     scenarios exist. Only valid while the run is PENDING_UPLOAD, so a repeated
     call fails.

    Sends a `POST` request to `/v0/projects/{projectId}/simulation-runs/{simulationRunId}:confirmSourceUpload`

    */
    pub async fn simulation_service_confirm_simulation_source_upload<'a>(
        &'a self,
        project_id: &'a str,
        simulation_run_id: &'a str,
        body: &'a types::SimulationServiceConfirmSimulationSourceUploadBody,
    ) -> Result<
        ResponseValue<
            types::LivekitPublicapiSimulationsV1SimulationRunsConfirmSourceUploadResponse,
        >,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/simulation-runs/{}:confirmSourceUpload",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&simulation_run_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info =
            OperationInfo { operation_id: "simulation_service_confirm_simulation_source_upload" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*CountSimulationRuns

    CountSimulationRuns buckets the runs ListSimulationRuns would return over
     [start_time, end_time) into a histogram. It takes the same filters over the
     same window, so the bars and the rows beneath them always describe one set.
     Both bounds are required and end_time must be after start_time.

    Sends a `GET` request to `/v0/projects/{projectId}/simulation-runs:counts`

    Arguments:
    - `project_id`
    - `agent_name`: Only runs of this agent (exact name).
    - `end_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    - `mode`: Only runs in this conversation mode.
    - `start_time`: A Timestamp represents a point in time independent of any time zone or local
     calendar, encoded as a count of seconds and fractions of seconds at
     nanosecond resolution. The count is relative to an epoch at UTC midnight on
     January 1, 1970, in the proleptic Gregorian calendar which extends the
     Gregorian calendar backwards to year one.

     All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
     second table is needed for interpretation, using a [24-hour linear
     smear](https://developers.google.com/time/smear).

     The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
     restricting to that range, we ensure that we can convert to and from [RFC
     3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

     # Examples

     Example 1: Compute Timestamp from POSIX `time()`.

         Timestamp timestamp;
         timestamp.set_seconds(time(NULL));
         timestamp.set_nanos(0);

     Example 2: Compute Timestamp from POSIX `gettimeofday()`.

         struct timeval tv;
         gettimeofday(&tv, NULL);

         Timestamp timestamp;
         timestamp.set_seconds(tv.tv_sec);
         timestamp.set_nanos(tv.tv_usec * 1000);

     Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
         UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

         // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
         // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
         Timestamp timestamp;
         timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
         timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

     Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

         long millis = System.currentTimeMillis();

         Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
             .setNanos((int) ((millis % 1000) * 1000000)).build();

     Example 5: Compute Timestamp from Java `Instant.now()`.

         Instant now = Instant.now();

         Timestamp timestamp =
             Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                 .setNanos(now.getNano()).build();

     Example 6: Compute Timestamp from current time in Python.

         timestamp = Timestamp()
         timestamp.GetCurrentTime()

     # JSON Mapping

     In JSON format, the Timestamp type is encoded as a string in the
     [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
     format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
     where {year} is always expressed using four digits while {month}, {day},
     {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
     seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
     are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
     is required. A ProtoJSON serializer should always use UTC (as indicated by
     "Z") when printing the Timestamp type and a ProtoJSON parser should be
     able to accept both UTC and other timezones (as indicated by an offset).

     For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
     01:30 UTC on January 15, 2017.

     In JavaScript, one can convert a Date object to this format using the
     standard
     [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
     method. In Python, a standard `datetime.datetime` object can be converted
     to this format using
     [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
     the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
     the Joda Time's [`ISODateTimeFormat.dateTime()`](
     http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
     ) to obtain a formatter capable of generating timestamps in this format.
    - `status`: Only runs in this status.
    */
    pub async fn simulation_service_count_simulation_runs<'a>(
        &'a self,
        project_id: &'a str,
        agent_name: Option<&'a str>,
        end_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
        mode: Option<types::LivekitSimulationMode>,
        start_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
        status: Option<types::LivekitSimulationRunStatus>,
    ) -> Result<
        ResponseValue<types::LivekitPublicapiSimulationsV1SimulationRunsCountsResponse>,
        Error<()>,
    > {
        let url = format!(
            "{}/v0/projects/{}/simulation-runs:counts",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("agentName", &agent_name))
            .query(&progenitor_client::QueryParam::new("endTime", &end_time))
            .query(&progenitor_client::QueryParam::new("mode", &mode))
            .query(&progenitor_client::QueryParam::new("startTime", &start_time))
            .query(&progenitor_client::QueryParam::new("status", &status))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "simulation_service_count_simulation_runs" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListThreads

    ListThreads lists the threads of one scope, newest first.

    Sends a `GET` request to `/v0/projects/{projectId}/threads`

    Arguments:
    - `project_id`
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `scope`
    */
    pub async fn thread_service_list_threads<'a>(
        &'a self,
        project_id: &'a str,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        scope: Option<&'a str>,
    ) -> Result<ResponseValue<types::LivekitPublicapiThreadsV1ThreadsListResponse>, Error<()>> {
        let url = format!(
            "{}/v0/projects/{}/threads",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new("scope", &scope))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "thread_service_list_threads" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*CreateThread

    CreateThread creates a thread and its database.

    Sends a `POST` request to `/v0/projects/{projectId}/threads`

    */
    pub async fn thread_service_create_thread<'a>(
        &'a self,
        project_id: &'a str,
        body: &'a types::ThreadServiceCreateThreadBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiThreadsV1ThreadsCreateResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/threads",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "thread_service_create_thread" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetThread

    Sends a `GET` request to `/v0/projects/{projectId}/threads/{threadId}`

    */
    pub async fn thread_service_get_thread<'a>(
        &'a self,
        project_id: &'a str,
        thread_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiThreadsV1ThreadsGetResponse>, Error<()>> {
        let url = format!(
            "{}/v0/projects/{}/threads/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&thread_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "thread_service_get_thread" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*DeleteThread

    DeleteThread deletes the thread and its database.

    Sends a `DELETE` request to `/v0/projects/{projectId}/threads/{threadId}`

    */
    pub async fn thread_service_delete_thread<'a>(
        &'a self,
        project_id: &'a str,
        thread_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiThreadsV1ThreadsDeleteResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/threads/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&thread_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "thread_service_delete_thread" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*UpdateThread

    UpdateThread merges attributes (an empty value deletes the entry) and sets
     the idle TTL. Every update counts as activity and pushes expires_at out.

    Sends a `PATCH` request to `/v0/projects/{projectId}/threads/{threadId}`

    */
    pub async fn thread_service_update_thread<'a>(
        &'a self,
        project_id: &'a str,
        thread_id: &'a str,
        body: &'a types::ThreadServiceUpdateThreadBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiThreadsV1ThreadsUpdateResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/threads/{}",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&thread_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .patch(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "thread_service_update_thread" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetThreadItems

    GetThreadItems returns the thread's chat items, oldest first.

    Sends a `GET` request to `/v0/projects/{projectId}/threads/{threadId}/items`

    Arguments:
    - `project_id`
    - `thread_id`
    - `agent`: One agent's items; empty for every agent's.
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `sort_order`: Direction of the item order. Defaults to ascending (oldest first) when
     unset; descending starts from the latest item and pages back.
    */
    pub async fn thread_service_get_thread_items<'a>(
        &'a self,
        project_id: &'a str,
        thread_id: &'a str,
        agent: Option<&'a str>,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        sort_order: Option<types::LivekitPublicapiCommonV1SortOrder>,
    ) -> Result<ResponseValue<types::LivekitPublicapiThreadsV1ThreadsItemsResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/threads/{}/items",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&thread_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("agent", &agent))
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new("sortOrder", &sort_order))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "thread_service_get_thread_items" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetThreadTasks

    GetThreadTasks returns the thread's background tasks, oldest first.

    Sends a `GET` request to `/v0/projects/{projectId}/threads/{threadId}/tasks`

    Arguments:
    - `project_id`
    - `thread_id`
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `status`: Only tasks in this status; unset for every status.
    */
    pub async fn thread_service_get_thread_tasks<'a>(
        &'a self,
        project_id: &'a str,
        thread_id: &'a str,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        status: Option<&'a ::livekit_protocol::agent::agent_task::Status>,
    ) -> Result<ResponseValue<types::LivekitPublicapiThreadsV1ThreadsTasksResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/threads/{}/tasks",
            self.baseurl,
            encode_path(&project_id.to_string()),
            encode_path(&thread_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new("status", &status))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "thread_service_get_thread_tasks" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*CreateToken

    CreateToken mints a short-lived LiveKit access token for the project,
     signed server-side, so user-authenticated clients can call LiveKit server
     APIs (rooms, SIP, egress, …) or join rooms without holding an API secret.

    Sends a `POST` request to `/v0/projects/{projectId}/tokens`

    */
    pub async fn project_service_create_token<'a>(
        &'a self,
        project_id: &'a str,
        body: &'a types::ProjectServiceCreateTokenBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1CreateTokenResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/projects/{}/tokens",
            self.baseurl,
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "project_service_create_token" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListUsers

    Sends a `GET` request to `/v0/users`

    Arguments:
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    - `project_id`: At least one of project_id or workspace_id is required.
     If both are set, project_id must belong to workspace_id; members are
     the project's members.
    - `workspace_id`
    */
    pub async fn user_service_list_users<'a>(
        &'a self,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
        project_id: Option<&'a str>,
        workspace_id: Option<&'a str>,
    ) -> Result<ResponseValue<types::LivekitPublicapiUsersV1ListUsersResponse>, Error<()>> {
        let url = format!("{}/v0/users", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .query(&progenitor_client::QueryParam::new("projectId", &project_id))
            .query(&progenitor_client::QueryParam::new("workspaceId", &workspace_id))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "user_service_list_users" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetCurrentUser

    Sends a `GET` request to `/v0/users/me`

    */
    pub async fn user_service_get_current_user<'a>(
        &'a self,
    ) -> Result<ResponseValue<types::LivekitPublicapiUsersV1GetCurrentUserResponse>, Error<()>>
    {
        let url = format!("{}/v0/users/me", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "user_service_get_current_user" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetUser

    Sends a `GET` request to `/v0/users/{userId}`

    */
    pub async fn user_service_get_user<'a>(
        &'a self,
        user_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiUsersV1GetUserResponse>, Error<()>> {
        let url = format!("{}/v0/users/{}", self.baseurl, encode_path(&user_id.to_string()),);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "user_service_get_user" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetInvite

    Sends a `GET` request to `/v0/workspace-invites/{inviteToken}`

    */
    pub async fn workspace_service_get_invite<'a>(
        &'a self,
        invite_token: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1GetInviteResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspace-invites/{}",
            self.baseurl,
            encode_path(&invite_token.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_get_invite" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*AnswerInvite

    Sends a `POST` request to `/v0/workspace-invites/{inviteToken}:answer`

    */
    pub async fn workspace_service_answer_invite<'a>(
        &'a self,
        invite_token: &'a str,
        body: &'a types::WorkspaceServiceAnswerInviteBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1AnswerInviteResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspace-invites/{}:answer",
            self.baseurl,
            encode_path(&invite_token.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_answer_invite" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListWorkspaces

    Sends a `GET` request to `/v0/workspaces`

    Arguments:
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    */
    pub async fn workspace_service_list_workspaces<'a>(
        &'a self,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1ListWorkspacesResponse>, Error<()>>
    {
        let url = format!("{}/v0/workspaces", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_list_workspaces" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*CreateWorkspace

    Sends a `POST` request to `/v0/workspaces`

    */
    pub async fn workspace_service_create_workspace<'a>(
        &'a self,
        body: &'a types::LivekitPublicapiWorkspacesV1CreateWorkspaceRequest,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1CreateWorkspaceResponse>, Error<()>>
    {
        let url = format!("{}/v0/workspaces", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_create_workspace" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetWorkspace

    Sends a `GET` request to `/v0/workspaces/{workspaceId}`

    */
    pub async fn workspace_service_get_workspace<'a>(
        &'a self,
        workspace_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1GetWorkspaceResponse>, Error<()>>
    {
        let url =
            format!("{}/v0/workspaces/{}", self.baseurl, encode_path(&workspace_id.to_string()),);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_get_workspace" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*DeleteWorkspace

    Sends a `DELETE` request to `/v0/workspaces/{workspaceId}`

    */
    pub async fn workspace_service_delete_workspace<'a>(
        &'a self,
        workspace_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1DeleteWorkspaceResponse>, Error<()>>
    {
        let url =
            format!("{}/v0/workspaces/{}", self.baseurl, encode_path(&workspace_id.to_string()),);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_delete_workspace" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*UpdateWorkspace

    Sends a `PATCH` request to `/v0/workspaces/{workspaceId}`

    */
    pub async fn workspace_service_update_workspace<'a>(
        &'a self,
        workspace_id: &'a str,
        body: &'a types::WorkspaceServiceUpdateWorkspaceBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1UpdateWorkspaceResponse>, Error<()>>
    {
        let url =
            format!("{}/v0/workspaces/{}", self.baseurl, encode_path(&workspace_id.to_string()),);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .patch(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_update_workspace" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListInvites

    Sends a `GET` request to `/v0/workspaces/{workspaceId}/invites`

    */
    pub async fn workspace_service_list_invites<'a>(
        &'a self,
        workspace_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1ListInvitesResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/invites",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_list_invites" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*CreateInvite

    Sends a `POST` request to `/v0/workspaces/{workspaceId}/invites`

    */
    pub async fn workspace_service_create_invite<'a>(
        &'a self,
        workspace_id: &'a str,
        body: &'a types::WorkspaceServiceCreateInviteBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1CreateInviteResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/invites",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_create_invite" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*DeleteInvite

    Sends a `DELETE` request to `/v0/workspaces/{workspaceId}/invites/{email}`

    */
    pub async fn workspace_service_delete_invite<'a>(
        &'a self,
        workspace_id: &'a str,
        email: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1DeleteInviteResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/invites/{}",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
            encode_path(&email.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_delete_invite" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListMembers

    Members & invites (mirrors cloud WorkspaceService current flows).

    Sends a `GET` request to `/v0/workspaces/{workspaceId}/members`

    */
    pub async fn workspace_service_list_members<'a>(
        &'a self,
        workspace_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1ListMembersResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/members",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_list_members" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetMember

    Sends a `GET` request to `/v0/workspaces/{workspaceId}/members/{userId}`

    */
    pub async fn workspace_service_get_member<'a>(
        &'a self,
        workspace_id: &'a str,
        user_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1GetMemberResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/members/{}",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
            encode_path(&user_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_get_member" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*DeleteMember

    Sends a `DELETE` request to `/v0/workspaces/{workspaceId}/members/{userId}`

    */
    pub async fn workspace_service_delete_member<'a>(
        &'a self,
        workspace_id: &'a str,
        user_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1DeleteMemberResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/members/{}",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
            encode_path(&user_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_delete_member" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*UpdateMember

    Sends a `PATCH` request to `/v0/workspaces/{workspaceId}/members/{userId}`

    */
    pub async fn workspace_service_update_member<'a>(
        &'a self,
        workspace_id: &'a str,
        user_id: &'a str,
        body: &'a types::WorkspaceServiceUpdateMemberBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiWorkspacesV1UpdateMemberResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/members/{}",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
            encode_path(&user_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .patch(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_update_member" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*ListProjects

    Project CRUD scoped to a workspace — responses owned by projects.v1.

    Sends a `GET` request to `/v0/workspaces/{workspaceId}/projects`

    Arguments:
    - `workspace_id`
    - `page_cursor`: Opaque cursor returned by a prior page (PageInfo.next_cursor). Empty starts
     from the beginning.
    - `page_page_size`: Maximum items to return; 0 lets the server pick a default.
    */
    pub async fn workspace_service_list_projects<'a>(
        &'a self,
        workspace_id: &'a str,
        page_cursor: Option<&'a str>,
        page_page_size: Option<i32>,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1ListProjectsResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/projects",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("page.cursor", &page_cursor))
            .query(&progenitor_client::QueryParam::new("page.pageSize", &page_page_size))
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_list_projects" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*CreateProject

    Sends a `POST` request to `/v0/workspaces/{workspaceId}/projects`

    */
    pub async fn workspace_service_create_project<'a>(
        &'a self,
        workspace_id: &'a str,
        body: &'a types::WorkspaceServiceCreateProjectBody,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1CreateProjectResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/projects",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_create_project" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*GetProject

    Sends a `GET` request to `/v0/workspaces/{workspaceId}/projects/{projectId}`

    */
    pub async fn workspace_service_get_project<'a>(
        &'a self,
        workspace_id: &'a str,
        project_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1GetProjectResponse>, Error<()>> {
        let url = format!(
            "{}/v0/workspaces/{}/projects/{}",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_get_project" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*DeleteProject

    Sends a `DELETE` request to `/v0/workspaces/{workspaceId}/projects/{projectId}`

    */
    pub async fn workspace_service_delete_project<'a>(
        &'a self,
        workspace_id: &'a str,
        project_id: &'a str,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1DeleteProjectResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/projects/{}",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
            encode_path(&project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_delete_project" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
    /*UpdateProject

    Sends a `PATCH` request to `/v0/workspaces/{workspaceId}/projects/{update.projectId}`

    Arguments:
    - `workspace_id`
    - `update_project_id`
    - `body`: Nested projects.v1 update; the handler applies this request's workspace_id
     as the store constraint.
    */
    pub async fn workspace_service_update_project<'a>(
        &'a self,
        workspace_id: &'a str,
        update_project_id: &'a str,
        body: &'a types::LivekitPublicapiProjectsV1UpdateProjectRequest,
    ) -> Result<ResponseValue<types::LivekitPublicapiProjectsV1UpdateProjectResponse>, Error<()>>
    {
        let url = format!(
            "{}/v0/workspaces/{}/projects/{}",
            self.baseurl,
            encode_path(&workspace_id.to_string()),
            encode_path(&update_project_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .patch(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo { operation_id: "workspace_service_update_project" };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
}
// Items consumers will typically use such as the Client.
pub mod prelude {
    #[allow(unused_imports)]
    pub use super::Client;
}