origincloud_support/generated/

origincloud.support.v1beta1.rs

// Code generated by origincloud-sdk-generator. DO NOT EDIT.
// source: origincloud/support/v1beta1/case.proto
// source: origincloud/support/v1beta1/case_message.proto

/// A support case: one question or problem, and the conversation about it.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Case {
    /// The case's resource name, `organizations/{organization}/cases/{case}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The case's URN, the identifier access policies and the audit log use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// The project the case is about, `projects/{project}`, one of the
    /// organization's. Empty for a case about the organization as a whole.
    #[prost(string, tag = "3")]
    pub project: ::prost::alloc::string::String,
    /// A one-line summary. Not empty.
    #[prost(string, tag = "4")]
    pub subject: ::prost::alloc::string::String,
    /// What the case is about, in full. Not empty.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// The email address every notification about the case is sent to, for
    /// as long as the case exists: when support replies, and when its state
    /// changes.
    #[prost(string, tag = "6")]
    pub contact_email: ::prost::alloc::string::String,
    /// Where the case stands. Changed by support, and by `CloseCase` and
    /// `ReopenCase`.
    #[prost(enumeration = "case::State", tag = "7")]
    pub state: i32,
    /// The principal that opened the case, such as `user:<id>` or
    /// `service_account:<id>`.
    #[prost(string, tag = "8")]
    pub creator: ::prost::alloc::string::String,
    /// When the case was opened.
    #[prost(message, optional, tag = "9")]
    pub create_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// When the case last changed: a message added, or its state changed.
    #[prost(message, optional, tag = "10")]
    pub update_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
}
/// Nested message and enum types in `Case`.
pub mod case {
    /// Where the case stands.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not set.
        Unspecified = 0,
        /// Opened, or opened again, and waiting for support.
        Open = 1,
        /// Support is working on it.
        InProgress = 2,
        /// Support considers it solved. Reopen it if it isn't.
        Resolved = 3,
        /// Finished. Reopen it to continue the conversation.
        Closed = 4,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Open => "OPEN",
                Self::InProgress => "IN_PROGRESS",
                Self::Resolved => "RESOLVED",
                Self::Closed => "CLOSED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "OPEN" => Some(Self::Open),
                "IN_PROGRESS" => Some(Self::InProgress),
                "RESOLVED" => Some(Self::Resolved),
                "CLOSED" => Some(Self::Closed),
                _ => None,
            }
        }
    }
}
/// The request for GetCase.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetCaseRequest {
    /// The case to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListCases.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListCasesRequest {
    /// The organization whose cases to list, `organizations/{organization}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most cases to return; the server clamps it, and 0 means its
    /// default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A previous response's `next_page_token`, for the page after it.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for ListCases.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListCasesResponse {
    /// The cases on this page.
    #[prost(message, repeated, tag = "1")]
    pub cases: ::prost::alloc::vec::Vec<Case>,
    /// The token for the next page; empty on the last one.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request for CreateCase.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateCaseRequest {
    /// The organization to open the case in, `organizations/{organization}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The case to open: its `subject`, `description` and `contact_email`,
    /// and its `project` if it is about one.
    #[prost(message, optional, tag = "2")]
    pub case: ::core::option::Option<Case>,
    /// A UUID; a repeat with the same id returns the case the first request
    /// opened instead of opening a second one.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for CloseCase.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloseCaseRequest {
    /// The case to close.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ReopenCase.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ReopenCaseRequest {
    /// The case to open again.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// One message of a case's conversation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CaseMessage {
    /// The message's resource name,
    /// `organizations/{organization}/cases/{case}/messages/{message}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The message's text. Not empty.
    #[prost(string, tag = "2")]
    pub body: ::prost::alloc::string::String,
    /// The principal that wrote the message, such as `user:<id>` or
    /// `service_account:<id>`.
    #[prost(string, tag = "3")]
    pub author: ::prost::alloc::string::String,
    /// When the message was added.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
}
/// The request for GetCaseMessage.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetCaseMessageRequest {
    /// The message to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListCaseMessages.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListCaseMessagesRequest {
    /// The case whose messages to list,
    /// `organizations/{organization}/cases/{case}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most messages to return; the server clamps it, and 0 means its
    /// default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A previous response's `next_page_token`, for the page after it.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for ListCaseMessages.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListCaseMessagesResponse {
    /// The messages on this page.
    #[prost(message, repeated, tag = "1")]
    pub case_messages: ::prost::alloc::vec::Vec<CaseMessage>,
    /// The token for the next page; empty on the last one.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request for CreateCaseMessage.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateCaseMessageRequest {
    /// The case to add the message to,
    /// `organizations/{organization}/cases/{case}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The message to add: its `body`.
    #[prost(message, optional, tag = "2")]
    pub case_message: ::core::option::Option<CaseMessage>,
    /// A UUID; a repeat with the same id returns the message the first
    /// request added instead of adding a second one.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
impl serde::Serialize for Case {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        if !self.urn.is_empty() {
            len += 1;
        }
        if !self.project.is_empty() {
            len += 1;
        }
        if !self.subject.is_empty() {
            len += 1;
        }
        if !self.description.is_empty() {
            len += 1;
        }
        if !self.contact_email.is_empty() {
            len += 1;
        }
        if self.state != 0 {
            len += 1;
        }
        if !self.creator.is_empty() {
            len += 1;
        }
        if self.create_time.is_some() {
            len += 1;
        }
        if self.update_time.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.support.v1beta1.Case", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if !self.urn.is_empty() {
            struct_ser.serialize_field("urn", &self.urn)?;
        }
        if !self.project.is_empty() {
            struct_ser.serialize_field("project", &self.project)?;
        }
        if !self.subject.is_empty() {
            struct_ser.serialize_field("subject", &self.subject)?;
        }
        if !self.description.is_empty() {
            struct_ser.serialize_field("description", &self.description)?;
        }
        if !self.contact_email.is_empty() {
            struct_ser.serialize_field("contactEmail", &self.contact_email)?;
        }
        if self.state != 0 {
            let v = case::State::try_from(self.state)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.state),
                ))?;
            struct_ser.serialize_field("state", &v)?;
        }
        if !self.creator.is_empty() {
            struct_ser.serialize_field("creator", &self.creator)?;
        }
        if let Some(v) = self.create_time.as_ref() {
            struct_ser.serialize_field("createTime", v)?;
        }
        if let Some(v) = self.update_time.as_ref() {
            struct_ser.serialize_field("updateTime", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for Case {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "project",
            "subject",
            "description",
            "contact_email",
            "contactEmail",
            "state",
            "creator",
            "create_time",
            "createTime",
            "update_time",
            "updateTime",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            Project,
            Subject,
            Description,
            ContactEmail,
            State,
            Creator,
            CreateTime,
            UpdateTime,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            "urn" => Ok(GeneratedField::Urn),
                            "project" => Ok(GeneratedField::Project),
                            "subject" => Ok(GeneratedField::Subject),
                            "description" => Ok(GeneratedField::Description),
                            "contactEmail" | "contact_email" => {
                                Ok(GeneratedField::ContactEmail)
                            }
                            "state" => Ok(GeneratedField::State),
                            "creator" => Ok(GeneratedField::Creator),
                            "createTime" | "create_time" => {
                                Ok(GeneratedField::CreateTime)
                            }
                            "updateTime" | "update_time" => {
                                Ok(GeneratedField::UpdateTime)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = Case;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.support.v1beta1.Case")
            }
            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Case, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut project__ = None;
                let mut subject__ = None;
                let mut description__ = None;
                let mut contact_email__ = None;
                let mut state__ = None;
                let mut creator__ = None;
                let mut create_time__ = None;
                let mut update_time__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Urn => {
                            if urn__.is_some() {
                                return Err(serde::de::Error::duplicate_field("urn"));
                            }
                            urn__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Project => {
                            if project__.is_some() {
                                return Err(serde::de::Error::duplicate_field("project"));
                            }
                            project__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Subject => {
                            if subject__.is_some() {
                                return Err(serde::de::Error::duplicate_field("subject"));
                            }
                            subject__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Description => {
                            if description__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("description"),
                                );
                            }
                            description__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ContactEmail => {
                            if contact_email__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("contactEmail"),
                                );
                            }
                            contact_email__ = Some(map_.next_value()?);
                        }
                        GeneratedField::State => {
                            if state__.is_some() {
                                return Err(serde::de::Error::duplicate_field("state"));
                            }
                            state__ = Some(map_.next_value::<case::State>()? as i32);
                        }
                        GeneratedField::Creator => {
                            if creator__.is_some() {
                                return Err(serde::de::Error::duplicate_field("creator"));
                            }
                            creator__ = Some(map_.next_value()?);
                        }
                        GeneratedField::CreateTime => {
                            if create_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("createTime"));
                            }
                            create_time__ = map_.next_value()?;
                        }
                        GeneratedField::UpdateTime => {
                            if update_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updateTime"));
                            }
                            update_time__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(Case {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    project: project__.unwrap_or_default(),
                    subject: subject__.unwrap_or_default(),
                    description: description__.unwrap_or_default(),
                    contact_email: contact_email__.unwrap_or_default(),
                    state: state__.unwrap_or_default(),
                    creator: creator__.unwrap_or_default(),
                    create_time: create_time__,
                    update_time: update_time__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.Case",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for case::State {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let variant = match self {
            Self::Unspecified => "STATE_UNSPECIFIED",
            Self::Open => "OPEN",
            Self::InProgress => "IN_PROGRESS",
            Self::Resolved => "RESOLVED",
            Self::Closed => "CLOSED",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for case::State {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "STATE_UNSPECIFIED",
            "OPEN",
            "IN_PROGRESS",
            "RESOLVED",
            "CLOSED",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = case::State;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                write!(formatter, "expected one of: {:?}", & FIELDS)
            }
            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                i32::try_from(v)
                    .ok()
                    .and_then(|x| {
                        x.try_into().ok().or_else(|| Some(case::State::default()))
                    })
                    .ok_or_else(|| {
                        serde::de::Error::invalid_value(
                            serde::de::Unexpected::Signed(v),
                            &self,
                        )
                    })
            }
            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                i32::try_from(v)
                    .ok()
                    .and_then(|x| {
                        x.try_into().ok().or_else(|| Some(case::State::default()))
                    })
                    .ok_or_else(|| {
                        serde::de::Error::invalid_value(
                            serde::de::Unexpected::Unsigned(v),
                            &self,
                        )
                    })
            }
            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                match value {
                    "STATE_UNSPECIFIED" => Ok(case::State::Unspecified),
                    "OPEN" => Ok(case::State::Open),
                    "IN_PROGRESS" => Ok(case::State::InProgress),
                    "RESOLVED" => Ok(case::State::Resolved),
                    "CLOSED" => Ok(case::State::Closed),
                    _ => Ok(case::State::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for CaseMessage {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        if !self.body.is_empty() {
            len += 1;
        }
        if !self.author.is_empty() {
            len += 1;
        }
        if self.create_time.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.support.v1beta1.CaseMessage", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if !self.body.is_empty() {
            struct_ser.serialize_field("body", &self.body)?;
        }
        if !self.author.is_empty() {
            struct_ser.serialize_field("author", &self.author)?;
        }
        if let Some(v) = self.create_time.as_ref() {
            struct_ser.serialize_field("createTime", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CaseMessage {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name", "body", "author", "create_time", "createTime"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Body,
            Author,
            CreateTime,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            "body" => Ok(GeneratedField::Body),
                            "author" => Ok(GeneratedField::Author),
                            "createTime" | "create_time" => {
                                Ok(GeneratedField::CreateTime)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = CaseMessage;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.support.v1beta1.CaseMessage")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CaseMessage, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut body__ = None;
                let mut author__ = None;
                let mut create_time__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Body => {
                            if body__.is_some() {
                                return Err(serde::de::Error::duplicate_field("body"));
                            }
                            body__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Author => {
                            if author__.is_some() {
                                return Err(serde::de::Error::duplicate_field("author"));
                            }
                            author__ = Some(map_.next_value()?);
                        }
                        GeneratedField::CreateTime => {
                            if create_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("createTime"));
                            }
                            create_time__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(CaseMessage {
                    name: name__.unwrap_or_default(),
                    body: body__.unwrap_or_default(),
                    author: author__.unwrap_or_default(),
                    create_time: create_time__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.CaseMessage",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CloseCaseRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.support.v1beta1.CloseCaseRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CloseCaseRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = CloseCaseRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.support.v1beta1.CloseCaseRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CloseCaseRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(CloseCaseRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.CloseCaseRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateCaseMessageRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.case_message.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.support.v1beta1.CreateCaseMessageRequest",
                len,
            )?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.case_message.as_ref() {
            struct_ser.serialize_field("caseMessage", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateCaseMessageRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "case_message",
            "caseMessage",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            CaseMessage,
            RequestId,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "caseMessage" | "case_message" => {
                                Ok(GeneratedField::CaseMessage)
                            }
                            "requestId" | "request_id" => Ok(GeneratedField::RequestId),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = CreateCaseMessageRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.support.v1beta1.CreateCaseMessageRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateCaseMessageRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut case_message__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::CaseMessage => {
                            if case_message__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("caseMessage"),
                                );
                            }
                            case_message__ = map_.next_value()?;
                        }
                        GeneratedField::RequestId => {
                            if request_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("requestId"));
                            }
                            request_id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(CreateCaseMessageRequest {
                    parent: parent__.unwrap_or_default(),
                    case_message: case_message__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.CreateCaseMessageRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateCaseRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.case.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.support.v1beta1.CreateCaseRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.case.as_ref() {
            struct_ser.serialize_field("case", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateCaseRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["parent", "case", "request_id", "requestId"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            Case,
            RequestId,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "case" => Ok(GeneratedField::Case),
                            "requestId" | "request_id" => Ok(GeneratedField::RequestId),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = CreateCaseRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.support.v1beta1.CreateCaseRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateCaseRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut case__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Case => {
                            if case__.is_some() {
                                return Err(serde::de::Error::duplicate_field("case"));
                            }
                            case__ = map_.next_value()?;
                        }
                        GeneratedField::RequestId => {
                            if request_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("requestId"));
                            }
                            request_id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(CreateCaseRequest {
                    parent: parent__.unwrap_or_default(),
                    case: case__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.CreateCaseRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetCaseMessageRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.support.v1beta1.GetCaseMessageRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetCaseMessageRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = GetCaseMessageRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.support.v1beta1.GetCaseMessageRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetCaseMessageRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(GetCaseMessageRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.GetCaseMessageRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetCaseRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.support.v1beta1.GetCaseRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetCaseRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = GetCaseRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.support.v1beta1.GetCaseRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetCaseRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(GetCaseRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.GetCaseRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListCaseMessagesRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.support.v1beta1.ListCaseMessagesRequest",
                len,
            )?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListCaseMessagesRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListCaseMessagesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.support.v1beta1.ListCaseMessagesRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListCaseMessagesRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListCaseMessagesRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.ListCaseMessagesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListCaseMessagesResponse {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.case_messages.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.support.v1beta1.ListCaseMessagesResponse",
                len,
            )?;
        if !self.case_messages.is_empty() {
            struct_ser.serialize_field("caseMessages", &self.case_messages)?;
        }
        if !self.next_page_token.is_empty() {
            struct_ser.serialize_field("nextPageToken", &self.next_page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListCaseMessagesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "case_messages",
            "caseMessages",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            CaseMessages,
            NextPageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "caseMessages" | "case_messages" => {
                                Ok(GeneratedField::CaseMessages)
                            }
                            "nextPageToken" | "next_page_token" => {
                                Ok(GeneratedField::NextPageToken)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListCaseMessagesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.support.v1beta1.ListCaseMessagesResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListCaseMessagesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut case_messages__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::CaseMessages => {
                            if case_messages__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("caseMessages"),
                                );
                            }
                            case_messages__ = Some(map_.next_value()?);
                        }
                        GeneratedField::NextPageToken => {
                            if next_page_token__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("nextPageToken"),
                                );
                            }
                            next_page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListCaseMessagesResponse {
                    case_messages: case_messages__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.ListCaseMessagesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListCasesRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.support.v1beta1.ListCasesRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListCasesRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListCasesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.support.v1beta1.ListCasesRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListCasesRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListCasesRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.ListCasesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListCasesResponse {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.cases.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.support.v1beta1.ListCasesResponse", len)?;
        if !self.cases.is_empty() {
            struct_ser.serialize_field("cases", &self.cases)?;
        }
        if !self.next_page_token.is_empty() {
            struct_ser.serialize_field("nextPageToken", &self.next_page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListCasesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["cases", "next_page_token", "nextPageToken"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Cases,
            NextPageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "cases" => Ok(GeneratedField::Cases),
                            "nextPageToken" | "next_page_token" => {
                                Ok(GeneratedField::NextPageToken)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListCasesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.support.v1beta1.ListCasesResponse")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListCasesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut cases__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Cases => {
                            if cases__.is_some() {
                                return Err(serde::de::Error::duplicate_field("cases"));
                            }
                            cases__ = Some(map_.next_value()?);
                        }
                        GeneratedField::NextPageToken => {
                            if next_page_token__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("nextPageToken"),
                                );
                            }
                            next_page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListCasesResponse {
                    cases: cases__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.ListCasesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ReopenCaseRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.support.v1beta1.ReopenCaseRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ReopenCaseRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ReopenCaseRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.support.v1beta1.ReopenCaseRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ReopenCaseRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ReopenCaseRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.support.v1beta1.ReopenCaseRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
/// Calls `CaseService`.
///
/// Support cases: an organization's questions and problems, and where each
/// one stands.
#[derive(Clone, Debug)]
pub struct CaseClient {
    service: ::origincloud_core::Service,
}
impl CaseClient {
    /// Returns a client of `CaseService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("support", false),
        }
    }
    /// The endpoint the client sends its calls to, which also serves the operations its methods answer with.
    pub fn service(&self) -> &::origincloud_core::Service {
        &self.service
    }
    /// Returns a case. Needs `admin.support_case.get` on the organization.
    pub async fn get_case(
        &self,
        request: GetCaseRequest,
    ) -> ::core::result::Result<Case, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/cases/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Lists an organization's cases, newest first. Needs
    /// `admin.support_case.list` on the organization.
    pub async fn list_cases(
        &self,
        request: ListCasesRequest,
    ) -> ::core::result::Result<ListCasesResponse, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "organizations/*",
        )?;
        let query = ::origincloud_core::query(&request, &["parent"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/cases"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_cases`](Self::list_cases) lists from `request`'s page on, fetching the next page as the stream reaches it. A page that fails ends the stream with its error.
    pub fn all_cases(
        &self,
        request: ListCasesRequest,
    ) -> ::origincloud_core::Pages<Case> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListCasesRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_cases(request).await?;
                    Ok((page.cases, page.next_page_token))
                }
            },
            |request: &mut ListCasesRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Opens a case, `case::State::Open`. Needs `admin.support_case.create` on the
    /// organization.
    pub async fn create_case(
        &self,
        mut request: CreateCaseRequest,
    ) -> ::core::result::Result<Case, ::origincloud_core::Error> {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "organizations/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.case.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "case"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/cases"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Closes a case: its `state` becomes `case::State::Closed`, and its contact email is
    /// notified. Closing a closed case succeeds and changes nothing. Needs
    /// `admin.support_case.update` on the organization.
    pub async fn close_case(
        &self,
        request: CloseCaseRequest,
    ) -> ::core::result::Result<Case, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/cases/*",
        )?;
        let body = ::origincloud_core::json_body(&request)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}:close"),
            )
            .with_body(body);
        self.service.call(call).await
    }
    /// Opens a resolved or closed case again: its `state` becomes `case::State::Open`, and
    /// its contact email is notified. Reopening a case that is `case::State::Open` or
    /// `case::State::InProgress` succeeds and changes nothing. Needs
    /// `admin.support_case.update` on the organization.
    pub async fn reopen_case(
        &self,
        request: ReopenCaseRequest,
    ) -> ::core::result::Result<Case, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/cases/*",
        )?;
        let body = ::origincloud_core::json_body(&request)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}:reopen"),
            )
            .with_body(body);
        self.service.call(call).await
    }
}
/// Calls `CaseMessageService`.
///
/// A case's messages: its conversation between the organization and
/// support, oldest first. A message is never changed or removed once added.
#[derive(Clone, Debug)]
pub struct CaseMessageClient {
    service: ::origincloud_core::Service,
}
impl CaseMessageClient {
    /// Returns a client of `CaseMessageService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("support", false),
        }
    }
    /// The endpoint the client sends its calls to, which also serves the operations its methods answer with.
    pub fn service(&self) -> &::origincloud_core::Service {
        &self.service
    }
    /// Returns one message of a case. Needs `admin.support_case.get` on the
    /// organization.
    pub async fn get_case_message(
        &self,
        request: GetCaseMessageRequest,
    ) -> ::core::result::Result<CaseMessage, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/cases/*/messages/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Lists a case's messages, oldest first. Needs `admin.support_case.get`
    /// on the organization.
    pub async fn list_case_messages(
        &self,
        request: ListCaseMessagesRequest,
    ) -> ::core::result::Result<ListCaseMessagesResponse, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "organizations/*/cases/*",
        )?;
        let query = ::origincloud_core::query(&request, &["parent"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/messages"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_case_messages`](Self::list_case_messages) lists from `request`'s page on, fetching the next page as the stream reaches it. A page that fails ends the stream with its error.
    pub fn all_case_messages(
        &self,
        request: ListCaseMessagesRequest,
    ) -> ::origincloud_core::Pages<CaseMessage> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListCaseMessagesRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_case_messages(request).await?;
                    Ok((page.case_messages, page.next_page_token))
                }
            },
            |request: &mut ListCaseMessagesRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Adds a message to a case's conversation. The case's contact email is
    /// notified unless the message's author opened the case, so nobody is
    /// emailed their own messages. Needs `admin.support_case.create` on the
    /// organization.
    pub async fn create_case_message(
        &self,
        mut request: CreateCaseMessageRequest,
    ) -> ::core::result::Result<CaseMessage, ::origincloud_core::Error> {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "organizations/*/cases/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.case_message.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "caseMessage"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/messages"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
}