google_cloud_wkt/generated/

mod.rs

// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#![allow(rustdoc::redundant_explicit_links)]
#![allow(rustdoc::broken_intra_doc_links)]
use crate as wkt;

/// Api is a light-weight descriptor for an API Interface.
///
/// Interfaces are also described as "protocol buffer services" in some contexts,
/// such as by the "service" keyword in a .proto file, but they are different
/// from API Services, which represent a concrete implementation of an interface
/// as opposed to simply a description of methods and bindings. They are also
/// sometimes simply referred to as "APIs" in other contexts, such as the name of
/// this message itself. See <https://cloud.google.com/apis/design/glossary> for
/// detailed terminology.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Api {
    /// The fully qualified name of this interface, including package name
    /// followed by the interface's simple name.
    pub name: std::string::String,

    /// The methods of this interface, in unspecified order.
    pub methods: std::vec::Vec<crate::Method>,

    /// Any metadata attached to the interface.
    pub options: std::vec::Vec<crate::Option>,

    /// A version string for this interface. If specified, must have the form
    /// `major-version.minor-version`, as in `1.10`. If the minor version is
    /// omitted, it defaults to zero. If the entire version field is empty, the
    /// major version is derived from the package name, as outlined below. If the
    /// field is not empty, the version in the package name will be verified to be
    /// consistent with what is provided here.
    ///
    /// The versioning schema uses [semantic
    /// versioning](http://semver.org) where the major version number
    /// indicates a breaking change and the minor version an additive,
    /// non-breaking change. Both version numbers are signals to users
    /// what to expect from different versions, and should be carefully
    /// chosen based on the product plan.
    ///
    /// The major version is also reflected in the package name of the
    /// interface, which must end in `v<major-version>`, as in
    /// `google.feature.v1`. For major versions 0 and 1, the suffix can
    /// be omitted. Zero major versions must only be used for
    /// experimental, non-GA interfaces.
    pub version: std::string::String,

    /// Source context for the protocol buffer service represented by this
    /// message.
    pub source_context: std::option::Option<crate::SourceContext>,

    /// Included interfaces. See [Mixin][].
    ///
    /// [Mixin]: crate::Mixin
    pub mixins: std::vec::Vec<crate::Mixin>,

    /// The source syntax of the service.
    pub syntax: crate::Syntax,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Api {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::Api::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [methods][crate::Api::methods].
    pub fn set_methods<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::Method>,
    {
        use std::iter::Iterator;
        self.methods = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [options][crate::Api::options].
    pub fn set_options<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::Option>,
    {
        use std::iter::Iterator;
        self.options = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [version][crate::Api::version].
    pub fn set_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.version = v.into();
        self
    }

    /// Sets the value of [source_context][crate::Api::source_context].
    pub fn set_source_context<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::SourceContext>,
    {
        self.source_context = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [source_context][crate::Api::source_context].
    pub fn set_or_clear_source_context<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::SourceContext>,
    {
        self.source_context = v.map(|x| x.into());
        self
    }

    /// Sets the value of [mixins][crate::Api::mixins].
    pub fn set_mixins<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::Mixin>,
    {
        use std::iter::Iterator;
        self.mixins = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [syntax][crate::Api::syntax].
    pub fn set_syntax<T: std::convert::Into<crate::Syntax>>(mut self, v: T) -> Self {
        self.syntax = v.into();
        self
    }
}

impl wkt::message::Message for Api {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.Api"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for Api {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __methods,
            __options,
            __version,
            __source_context,
            __mixins,
            __syntax,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for Api")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "methods" => Ok(__FieldTag::__methods),
                            "options" => Ok(__FieldTag::__options),
                            "version" => Ok(__FieldTag::__version),
                            "sourceContext" => Ok(__FieldTag::__source_context),
                            "source_context" => Ok(__FieldTag::__source_context),
                            "mixins" => Ok(__FieldTag::__mixins),
                            "syntax" => Ok(__FieldTag::__syntax),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = Api;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Api")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__methods => {
                            if !fields.insert(__FieldTag::__methods) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for methods",
                                ));
                            }
                            result.methods = map
                                .next_value::<std::option::Option<std::vec::Vec<crate::Method>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options = map
                                .next_value::<std::option::Option<std::vec::Vec<crate::Option>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__version => {
                            if !fields.insert(__FieldTag::__version) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for version",
                                ));
                            }
                            result.version = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__source_context => {
                            if !fields.insert(__FieldTag::__source_context) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for source_context",
                                ));
                            }
                            result.source_context =
                                map.next_value::<std::option::Option<crate::SourceContext>>()?;
                        }
                        __FieldTag::__mixins => {
                            if !fields.insert(__FieldTag::__mixins) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for mixins",
                                ));
                            }
                            result.mixins = map
                                .next_value::<std::option::Option<std::vec::Vec<crate::Mixin>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__syntax => {
                            if !fields.insert(__FieldTag::__syntax) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for syntax",
                                ));
                            }
                            result.syntax = map
                                .next_value::<std::option::Option<crate::Syntax>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for Api {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.methods.is_empty() {
            state.serialize_entry("methods", &self.methods)?;
        }
        if !self.options.is_empty() {
            state.serialize_entry("options", &self.options)?;
        }
        if !self.version.is_empty() {
            state.serialize_entry("version", &self.version)?;
        }
        if self.source_context.is_some() {
            state.serialize_entry("sourceContext", &self.source_context)?;
        }
        if !self.mixins.is_empty() {
            state.serialize_entry("mixins", &self.mixins)?;
        }
        if !wkt::internal::is_default(&self.syntax) {
            state.serialize_entry("syntax", &self.syntax)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for Api {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Api");
        debug_struct.field("name", &self.name);
        debug_struct.field("methods", &self.methods);
        debug_struct.field("options", &self.options);
        debug_struct.field("version", &self.version);
        debug_struct.field("source_context", &self.source_context);
        debug_struct.field("mixins", &self.mixins);
        debug_struct.field("syntax", &self.syntax);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Method represents a method of an API interface.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Method {
    /// The simple name of this method.
    pub name: std::string::String,

    /// A URL of the input message type.
    pub request_type_url: std::string::String,

    /// If true, the request is streamed.
    pub request_streaming: bool,

    /// The URL of the output message type.
    pub response_type_url: std::string::String,

    /// If true, the response is streamed.
    pub response_streaming: bool,

    /// Any metadata attached to the method.
    pub options: std::vec::Vec<crate::Option>,

    /// The source syntax of this method.
    pub syntax: crate::Syntax,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Method {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::Method::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [request_type_url][crate::Method::request_type_url].
    pub fn set_request_type_url<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.request_type_url = v.into();
        self
    }

    /// Sets the value of [request_streaming][crate::Method::request_streaming].
    pub fn set_request_streaming<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.request_streaming = v.into();
        self
    }

    /// Sets the value of [response_type_url][crate::Method::response_type_url].
    pub fn set_response_type_url<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.response_type_url = v.into();
        self
    }

    /// Sets the value of [response_streaming][crate::Method::response_streaming].
    pub fn set_response_streaming<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.response_streaming = v.into();
        self
    }

    /// Sets the value of [options][crate::Method::options].
    pub fn set_options<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::Option>,
    {
        use std::iter::Iterator;
        self.options = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [syntax][crate::Method::syntax].
    pub fn set_syntax<T: std::convert::Into<crate::Syntax>>(mut self, v: T) -> Self {
        self.syntax = v.into();
        self
    }
}

impl wkt::message::Message for Method {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.Method"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for Method {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __request_type_url,
            __request_streaming,
            __response_type_url,
            __response_streaming,
            __options,
            __syntax,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for Method")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "requestTypeUrl" => Ok(__FieldTag::__request_type_url),
                            "request_type_url" => Ok(__FieldTag::__request_type_url),
                            "requestStreaming" => Ok(__FieldTag::__request_streaming),
                            "request_streaming" => Ok(__FieldTag::__request_streaming),
                            "responseTypeUrl" => Ok(__FieldTag::__response_type_url),
                            "response_type_url" => Ok(__FieldTag::__response_type_url),
                            "responseStreaming" => Ok(__FieldTag::__response_streaming),
                            "response_streaming" => Ok(__FieldTag::__response_streaming),
                            "options" => Ok(__FieldTag::__options),
                            "syntax" => Ok(__FieldTag::__syntax),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = Method;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Method")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__request_type_url => {
                            if !fields.insert(__FieldTag::__request_type_url) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for request_type_url",
                                ));
                            }
                            result.request_type_url = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__request_streaming => {
                            if !fields.insert(__FieldTag::__request_streaming) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for request_streaming",
                                ));
                            }
                            result.request_streaming = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__response_type_url => {
                            if !fields.insert(__FieldTag::__response_type_url) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for response_type_url",
                                ));
                            }
                            result.response_type_url = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__response_streaming => {
                            if !fields.insert(__FieldTag::__response_streaming) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for response_streaming",
                                ));
                            }
                            result.response_streaming = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options = map
                                .next_value::<std::option::Option<std::vec::Vec<crate::Option>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__syntax => {
                            if !fields.insert(__FieldTag::__syntax) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for syntax",
                                ));
                            }
                            result.syntax = map
                                .next_value::<std::option::Option<crate::Syntax>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for Method {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.request_type_url.is_empty() {
            state.serialize_entry("requestTypeUrl", &self.request_type_url)?;
        }
        if !wkt::internal::is_default(&self.request_streaming) {
            state.serialize_entry("requestStreaming", &self.request_streaming)?;
        }
        if !self.response_type_url.is_empty() {
            state.serialize_entry("responseTypeUrl", &self.response_type_url)?;
        }
        if !wkt::internal::is_default(&self.response_streaming) {
            state.serialize_entry("responseStreaming", &self.response_streaming)?;
        }
        if !self.options.is_empty() {
            state.serialize_entry("options", &self.options)?;
        }
        if !wkt::internal::is_default(&self.syntax) {
            state.serialize_entry("syntax", &self.syntax)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for Method {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Method");
        debug_struct.field("name", &self.name);
        debug_struct.field("request_type_url", &self.request_type_url);
        debug_struct.field("request_streaming", &self.request_streaming);
        debug_struct.field("response_type_url", &self.response_type_url);
        debug_struct.field("response_streaming", &self.response_streaming);
        debug_struct.field("options", &self.options);
        debug_struct.field("syntax", &self.syntax);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Declares an API Interface to be included in this interface. The including
/// interface must redeclare all the methods from the included interface, but
/// documentation and options are inherited as follows:
///
/// - If after comment and whitespace stripping, the documentation
///   string of the redeclared method is empty, it will be inherited
///   from the original method.
///
/// - Each annotation belonging to the service config (http,
///   visibility) which is not set in the redeclared method will be
///   inherited.
///
/// - If an http annotation is inherited, the path pattern will be
///   modified as follows. Any version prefix will be replaced by the
///   version of the including interface plus the [root][] path if
///   specified.
///
///
/// Example of a simple mixin:
///
/// ```norust
/// package google.acl.v1;
/// service AccessControl {
///   // Get the underlying ACL object.
///   rpc GetAcl(GetAclRequest) returns (Acl) {
///     option (google.api.http).get = "/v1/{resource=**}:getAcl";
///   }
/// }
///
/// package google.storage.v2;
/// service Storage {
///   rpc GetAcl(GetAclRequest) returns (Acl);
///
///   // Get a data record.
///   rpc GetData(GetDataRequest) returns (Data) {
///     option (google.api.http).get = "/v2/{resource=**}";
///   }
/// }
/// ```
///
/// Example of a mixin configuration:
///
/// ```norust
/// apis:
/// - name: google.storage.v2.Storage
///   mixins:
///   - name: google.acl.v1.AccessControl
/// ```
///
/// The mixin construct implies that all methods in `AccessControl` are
/// also declared with same name and request/response types in
/// `Storage`. A documentation generator or annotation processor will
/// see the effective `Storage.GetAcl` method after inheriting
/// documentation and annotations as follows:
///
/// ```norust
/// service Storage {
///   // Get the underlying ACL object.
///   rpc GetAcl(GetAclRequest) returns (Acl) {
///     option (google.api.http).get = "/v2/{resource=**}:getAcl";
///   }
///   ...
/// }
/// ```
///
/// Note how the version in the path pattern changed from `v1` to `v2`.
///
/// If the `root` field in the mixin is specified, it should be a
/// relative path under which inherited HTTP paths are placed. Example:
///
/// ```norust
/// apis:
/// - name: google.storage.v2.Storage
///   mixins:
///   - name: google.acl.v1.AccessControl
///     root: acls
/// ```
///
/// This implies the following inherited HTTP annotation:
///
/// ```norust
/// service Storage {
///   // Get the underlying ACL object.
///   rpc GetAcl(GetAclRequest) returns (Acl) {
///     option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";
///   }
///   ...
/// }
/// ```
///
/// [root]: wkt::Mixin::root
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Mixin {
    /// The fully qualified name of the interface which is included.
    pub name: std::string::String,

    /// If non-empty specifies a path under which inherited HTTP paths
    /// are rooted.
    pub root: std::string::String,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Mixin {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::Mixin::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [root][crate::Mixin::root].
    pub fn set_root<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.root = v.into();
        self
    }
}

impl wkt::message::Message for Mixin {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.Mixin"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for Mixin {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __root,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for Mixin")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "root" => Ok(__FieldTag::__root),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = Mixin;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Mixin")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__root => {
                            if !fields.insert(__FieldTag::__root) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for root",
                                ));
                            }
                            result.root = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for Mixin {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.root.is_empty() {
            state.serialize_entry("root", &self.root)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for Mixin {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Mixin");
        debug_struct.field("name", &self.name);
        debug_struct.field("root", &self.root);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// The protocol compiler can output a FileDescriptorSet containing the .proto
/// files it parses.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FileDescriptorSet {
    pub file: std::vec::Vec<crate::FileDescriptorProto>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FileDescriptorSet {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [file][crate::FileDescriptorSet::file].
    pub fn set_file<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::FileDescriptorProto>,
    {
        use std::iter::Iterator;
        self.file = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for FileDescriptorSet {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.FileDescriptorSet"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for FileDescriptorSet {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __file,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for FileDescriptorSet")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "file" => Ok(__FieldTag::__file),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = FileDescriptorSet;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct FileDescriptorSet")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__file => {
                            if !fields.insert(__FieldTag::__file) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for file",
                                ));
                            }
                            result.file = map.next_value::<std::option::Option<std::vec::Vec<crate::FileDescriptorProto>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for FileDescriptorSet {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.file.is_empty() {
            state.serialize_entry("file", &self.file)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for FileDescriptorSet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileDescriptorSet");
        debug_struct.field("file", &self.file);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Describes a complete .proto file.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FileDescriptorProto {
    pub name: std::string::String,

    pub package: std::string::String,

    /// Names of files imported by this file.
    pub dependency: std::vec::Vec<std::string::String>,

    /// Indexes of the public imported files in the dependency list above.
    pub public_dependency: std::vec::Vec<i32>,

    /// Indexes of the weak imported files in the dependency list.
    /// For Google-internal migration only. Do not use.
    pub weak_dependency: std::vec::Vec<i32>,

    /// All top-level definitions in this file.
    pub message_type: std::vec::Vec<crate::DescriptorProto>,

    pub enum_type: std::vec::Vec<crate::EnumDescriptorProto>,

    pub service: std::vec::Vec<crate::ServiceDescriptorProto>,

    pub extension: std::vec::Vec<crate::FieldDescriptorProto>,

    pub options: std::option::Option<crate::FileOptions>,

    /// This field contains optional information about the original source code.
    /// You may safely remove this entire field without harming runtime
    /// functionality of the descriptors -- the information is needed only by
    /// development tools.
    pub source_code_info: std::option::Option<crate::SourceCodeInfo>,

    /// The syntax of the proto file.
    /// The supported values are "proto2", "proto3", and "editions".
    ///
    /// If `edition` is present, this value must be "editions".
    pub syntax: std::string::String,

    /// The edition of the proto file.
    pub edition: crate::Edition,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FileDescriptorProto {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::FileDescriptorProto::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [package][crate::FileDescriptorProto::package].
    pub fn set_package<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.package = v.into();
        self
    }

    /// Sets the value of [dependency][crate::FileDescriptorProto::dependency].
    pub fn set_dependency<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.dependency = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [public_dependency][crate::FileDescriptorProto::public_dependency].
    pub fn set_public_dependency<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<i32>,
    {
        use std::iter::Iterator;
        self.public_dependency = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [weak_dependency][crate::FileDescriptorProto::weak_dependency].
    pub fn set_weak_dependency<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<i32>,
    {
        use std::iter::Iterator;
        self.weak_dependency = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [message_type][crate::FileDescriptorProto::message_type].
    pub fn set_message_type<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::DescriptorProto>,
    {
        use std::iter::Iterator;
        self.message_type = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [enum_type][crate::FileDescriptorProto::enum_type].
    pub fn set_enum_type<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::EnumDescriptorProto>,
    {
        use std::iter::Iterator;
        self.enum_type = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [service][crate::FileDescriptorProto::service].
    pub fn set_service<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::ServiceDescriptorProto>,
    {
        use std::iter::Iterator;
        self.service = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [extension][crate::FileDescriptorProto::extension].
    pub fn set_extension<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::FieldDescriptorProto>,
    {
        use std::iter::Iterator;
        self.extension = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [options][crate::FileDescriptorProto::options].
    pub fn set_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FileOptions>,
    {
        self.options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [options][crate::FileDescriptorProto::options].
    pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FileOptions>,
    {
        self.options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [source_code_info][crate::FileDescriptorProto::source_code_info].
    pub fn set_source_code_info<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::SourceCodeInfo>,
    {
        self.source_code_info = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [source_code_info][crate::FileDescriptorProto::source_code_info].
    pub fn set_or_clear_source_code_info<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::SourceCodeInfo>,
    {
        self.source_code_info = v.map(|x| x.into());
        self
    }

    /// Sets the value of [syntax][crate::FileDescriptorProto::syntax].
    pub fn set_syntax<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.syntax = v.into();
        self
    }

    /// Sets the value of [edition][crate::FileDescriptorProto::edition].
    pub fn set_edition<T: std::convert::Into<crate::Edition>>(mut self, v: T) -> Self {
        self.edition = v.into();
        self
    }
}

impl wkt::message::Message for FileDescriptorProto {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.FileDescriptorProto"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for FileDescriptorProto {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __package,
            __dependency,
            __public_dependency,
            __weak_dependency,
            __message_type,
            __enum_type,
            __service,
            __extension,
            __options,
            __source_code_info,
            __syntax,
            __edition,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for FileDescriptorProto")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "package" => Ok(__FieldTag::__package),
                            "dependency" => Ok(__FieldTag::__dependency),
                            "publicDependency" => Ok(__FieldTag::__public_dependency),
                            "public_dependency" => Ok(__FieldTag::__public_dependency),
                            "weakDependency" => Ok(__FieldTag::__weak_dependency),
                            "weak_dependency" => Ok(__FieldTag::__weak_dependency),
                            "messageType" => Ok(__FieldTag::__message_type),
                            "message_type" => Ok(__FieldTag::__message_type),
                            "enumType" => Ok(__FieldTag::__enum_type),
                            "enum_type" => Ok(__FieldTag::__enum_type),
                            "service" => Ok(__FieldTag::__service),
                            "extension" => Ok(__FieldTag::__extension),
                            "options" => Ok(__FieldTag::__options),
                            "sourceCodeInfo" => Ok(__FieldTag::__source_code_info),
                            "source_code_info" => Ok(__FieldTag::__source_code_info),
                            "syntax" => Ok(__FieldTag::__syntax),
                            "edition" => Ok(__FieldTag::__edition),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = FileDescriptorProto;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct FileDescriptorProto")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__package => {
                            if !fields.insert(__FieldTag::__package) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for package",
                                ));
                            }
                            result.package = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__dependency => {
                            if !fields.insert(__FieldTag::__dependency) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for dependency",
                                ));
                            }
                            result.dependency = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__public_dependency => {
                            if !fields.insert(__FieldTag::__public_dependency) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for public_dependency",
                                ));
                            }
                            struct __With(std::option::Option<std::vec::Vec<i32>>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::<
                                        std::option::Option<std::vec::Vec<wkt::internal::I32>>,
                                    >::deserialize(deserializer)
                                    .map(__With)
                                }
                            }
                            result.public_dependency =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__weak_dependency => {
                            if !fields.insert(__FieldTag::__weak_dependency) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for weak_dependency",
                                ));
                            }
                            struct __With(std::option::Option<std::vec::Vec<i32>>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::<
                                        std::option::Option<std::vec::Vec<wkt::internal::I32>>,
                                    >::deserialize(deserializer)
                                    .map(__With)
                                }
                            }
                            result.weak_dependency =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__message_type => {
                            if !fields.insert(__FieldTag::__message_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for message_type",
                                ));
                            }
                            result.message_type = map.next_value::<std::option::Option<std::vec::Vec<crate::DescriptorProto>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__enum_type => {
                            if !fields.insert(__FieldTag::__enum_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for enum_type",
                                ));
                            }
                            result.enum_type = map.next_value::<std::option::Option<std::vec::Vec<crate::EnumDescriptorProto>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__service => {
                            if !fields.insert(__FieldTag::__service) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for service",
                                ));
                            }
                            result.service =
                                map.next_value::<std::option::Option<
                                    std::vec::Vec<crate::ServiceDescriptorProto>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__extension => {
                            if !fields.insert(__FieldTag::__extension) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for extension",
                                ));
                            }
                            result.extension = map.next_value::<std::option::Option<std::vec::Vec<crate::FieldDescriptorProto>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options =
                                map.next_value::<std::option::Option<crate::FileOptions>>()?;
                        }
                        __FieldTag::__source_code_info => {
                            if !fields.insert(__FieldTag::__source_code_info) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for source_code_info",
                                ));
                            }
                            result.source_code_info =
                                map.next_value::<std::option::Option<crate::SourceCodeInfo>>()?;
                        }
                        __FieldTag::__syntax => {
                            if !fields.insert(__FieldTag::__syntax) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for syntax",
                                ));
                            }
                            result.syntax = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__edition => {
                            if !fields.insert(__FieldTag::__edition) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for edition",
                                ));
                            }
                            result.edition = map
                                .next_value::<std::option::Option<crate::Edition>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for FileDescriptorProto {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.package.is_empty() {
            state.serialize_entry("package", &self.package)?;
        }
        if !self.dependency.is_empty() {
            state.serialize_entry("dependency", &self.dependency)?;
        }
        if !self.public_dependency.is_empty() {
            struct __With<'a>(&'a std::vec::Vec<i32>);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<std::vec::Vec<wkt::internal::I32>>::serialize(
                        self.0, serializer,
                    )
                }
            }
            state.serialize_entry("publicDependency", &__With(&self.public_dependency))?;
        }
        if !self.weak_dependency.is_empty() {
            struct __With<'a>(&'a std::vec::Vec<i32>);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<std::vec::Vec<wkt::internal::I32>>::serialize(
                        self.0, serializer,
                    )
                }
            }
            state.serialize_entry("weakDependency", &__With(&self.weak_dependency))?;
        }
        if !self.message_type.is_empty() {
            state.serialize_entry("messageType", &self.message_type)?;
        }
        if !self.enum_type.is_empty() {
            state.serialize_entry("enumType", &self.enum_type)?;
        }
        if !self.service.is_empty() {
            state.serialize_entry("service", &self.service)?;
        }
        if !self.extension.is_empty() {
            state.serialize_entry("extension", &self.extension)?;
        }
        if self.options.is_some() {
            state.serialize_entry("options", &self.options)?;
        }
        if self.source_code_info.is_some() {
            state.serialize_entry("sourceCodeInfo", &self.source_code_info)?;
        }
        if !self.syntax.is_empty() {
            state.serialize_entry("syntax", &self.syntax)?;
        }
        if !wkt::internal::is_default(&self.edition) {
            state.serialize_entry("edition", &self.edition)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for FileDescriptorProto {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileDescriptorProto");
        debug_struct.field("name", &self.name);
        debug_struct.field("package", &self.package);
        debug_struct.field("dependency", &self.dependency);
        debug_struct.field("public_dependency", &self.public_dependency);
        debug_struct.field("weak_dependency", &self.weak_dependency);
        debug_struct.field("message_type", &self.message_type);
        debug_struct.field("enum_type", &self.enum_type);
        debug_struct.field("service", &self.service);
        debug_struct.field("extension", &self.extension);
        debug_struct.field("options", &self.options);
        debug_struct.field("source_code_info", &self.source_code_info);
        debug_struct.field("syntax", &self.syntax);
        debug_struct.field("edition", &self.edition);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Describes a message type.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DescriptorProto {
    pub name: std::string::String,

    pub field: std::vec::Vec<crate::FieldDescriptorProto>,

    pub extension: std::vec::Vec<crate::FieldDescriptorProto>,

    pub nested_type: std::vec::Vec<crate::DescriptorProto>,

    pub enum_type: std::vec::Vec<crate::EnumDescriptorProto>,

    pub extension_range: std::vec::Vec<crate::descriptor_proto::ExtensionRange>,

    pub oneof_decl: std::vec::Vec<crate::OneofDescriptorProto>,

    pub options: std::option::Option<crate::MessageOptions>,

    pub reserved_range: std::vec::Vec<crate::descriptor_proto::ReservedRange>,

    /// Reserved field names, which may not be used by fields in the same message.
    /// A given name may only be reserved once.
    pub reserved_name: std::vec::Vec<std::string::String>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DescriptorProto {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::DescriptorProto::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [field][crate::DescriptorProto::field].
    pub fn set_field<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::FieldDescriptorProto>,
    {
        use std::iter::Iterator;
        self.field = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [extension][crate::DescriptorProto::extension].
    pub fn set_extension<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::FieldDescriptorProto>,
    {
        use std::iter::Iterator;
        self.extension = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [nested_type][crate::DescriptorProto::nested_type].
    pub fn set_nested_type<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::DescriptorProto>,
    {
        use std::iter::Iterator;
        self.nested_type = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [enum_type][crate::DescriptorProto::enum_type].
    pub fn set_enum_type<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::EnumDescriptorProto>,
    {
        use std::iter::Iterator;
        self.enum_type = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [extension_range][crate::DescriptorProto::extension_range].
    pub fn set_extension_range<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::descriptor_proto::ExtensionRange>,
    {
        use std::iter::Iterator;
        self.extension_range = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [oneof_decl][crate::DescriptorProto::oneof_decl].
    pub fn set_oneof_decl<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::OneofDescriptorProto>,
    {
        use std::iter::Iterator;
        self.oneof_decl = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [options][crate::DescriptorProto::options].
    pub fn set_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::MessageOptions>,
    {
        self.options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [options][crate::DescriptorProto::options].
    pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::MessageOptions>,
    {
        self.options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [reserved_range][crate::DescriptorProto::reserved_range].
    pub fn set_reserved_range<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::descriptor_proto::ReservedRange>,
    {
        use std::iter::Iterator;
        self.reserved_range = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [reserved_name][crate::DescriptorProto::reserved_name].
    pub fn set_reserved_name<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.reserved_name = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for DescriptorProto {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.DescriptorProto"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for DescriptorProto {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __field,
            __extension,
            __nested_type,
            __enum_type,
            __extension_range,
            __oneof_decl,
            __options,
            __reserved_range,
            __reserved_name,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for DescriptorProto")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "field" => Ok(__FieldTag::__field),
                            "extension" => Ok(__FieldTag::__extension),
                            "nestedType" => Ok(__FieldTag::__nested_type),
                            "nested_type" => Ok(__FieldTag::__nested_type),
                            "enumType" => Ok(__FieldTag::__enum_type),
                            "enum_type" => Ok(__FieldTag::__enum_type),
                            "extensionRange" => Ok(__FieldTag::__extension_range),
                            "extension_range" => Ok(__FieldTag::__extension_range),
                            "oneofDecl" => Ok(__FieldTag::__oneof_decl),
                            "oneof_decl" => Ok(__FieldTag::__oneof_decl),
                            "options" => Ok(__FieldTag::__options),
                            "reservedRange" => Ok(__FieldTag::__reserved_range),
                            "reserved_range" => Ok(__FieldTag::__reserved_range),
                            "reservedName" => Ok(__FieldTag::__reserved_name),
                            "reserved_name" => Ok(__FieldTag::__reserved_name),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = DescriptorProto;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct DescriptorProto")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__field => {
                            if !fields.insert(__FieldTag::__field) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for field",
                                ));
                            }
                            result.field = map.next_value::<std::option::Option<std::vec::Vec<crate::FieldDescriptorProto>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__extension => {
                            if !fields.insert(__FieldTag::__extension) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for extension",
                                ));
                            }
                            result.extension = map.next_value::<std::option::Option<std::vec::Vec<crate::FieldDescriptorProto>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__nested_type => {
                            if !fields.insert(__FieldTag::__nested_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for nested_type",
                                ));
                            }
                            result.nested_type = map.next_value::<std::option::Option<std::vec::Vec<crate::DescriptorProto>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__enum_type => {
                            if !fields.insert(__FieldTag::__enum_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for enum_type",
                                ));
                            }
                            result.enum_type = map.next_value::<std::option::Option<std::vec::Vec<crate::EnumDescriptorProto>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__extension_range => {
                            if !fields.insert(__FieldTag::__extension_range) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for extension_range",
                                ));
                            }
                            result.extension_range = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::descriptor_proto::ExtensionRange>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__oneof_decl => {
                            if !fields.insert(__FieldTag::__oneof_decl) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for oneof_decl",
                                ));
                            }
                            result.oneof_decl = map.next_value::<std::option::Option<std::vec::Vec<crate::OneofDescriptorProto>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options =
                                map.next_value::<std::option::Option<crate::MessageOptions>>()?;
                        }
                        __FieldTag::__reserved_range => {
                            if !fields.insert(__FieldTag::__reserved_range) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for reserved_range",
                                ));
                            }
                            result.reserved_range = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::descriptor_proto::ReservedRange>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__reserved_name => {
                            if !fields.insert(__FieldTag::__reserved_name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for reserved_name",
                                ));
                            }
                            result.reserved_name = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for DescriptorProto {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.field.is_empty() {
            state.serialize_entry("field", &self.field)?;
        }
        if !self.extension.is_empty() {
            state.serialize_entry("extension", &self.extension)?;
        }
        if !self.nested_type.is_empty() {
            state.serialize_entry("nestedType", &self.nested_type)?;
        }
        if !self.enum_type.is_empty() {
            state.serialize_entry("enumType", &self.enum_type)?;
        }
        if !self.extension_range.is_empty() {
            state.serialize_entry("extensionRange", &self.extension_range)?;
        }
        if !self.oneof_decl.is_empty() {
            state.serialize_entry("oneofDecl", &self.oneof_decl)?;
        }
        if self.options.is_some() {
            state.serialize_entry("options", &self.options)?;
        }
        if !self.reserved_range.is_empty() {
            state.serialize_entry("reservedRange", &self.reserved_range)?;
        }
        if !self.reserved_name.is_empty() {
            state.serialize_entry("reservedName", &self.reserved_name)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for DescriptorProto {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DescriptorProto");
        debug_struct.field("name", &self.name);
        debug_struct.field("field", &self.field);
        debug_struct.field("extension", &self.extension);
        debug_struct.field("nested_type", &self.nested_type);
        debug_struct.field("enum_type", &self.enum_type);
        debug_struct.field("extension_range", &self.extension_range);
        debug_struct.field("oneof_decl", &self.oneof_decl);
        debug_struct.field("options", &self.options);
        debug_struct.field("reserved_range", &self.reserved_range);
        debug_struct.field("reserved_name", &self.reserved_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [DescriptorProto].
pub mod descriptor_proto {
    #[allow(unused_imports)]
    use super::*;

    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ExtensionRange {
        pub start: i32,

        pub end: i32,

        pub options: std::option::Option<crate::ExtensionRangeOptions>,

        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl ExtensionRange {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [start][crate::descriptor_proto::ExtensionRange::start].
        pub fn set_start<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.start = v.into();
            self
        }

        /// Sets the value of [end][crate::descriptor_proto::ExtensionRange::end].
        pub fn set_end<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.end = v.into();
            self
        }

        /// Sets the value of [options][crate::descriptor_proto::ExtensionRange::options].
        pub fn set_options<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::ExtensionRangeOptions>,
        {
            self.options = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [options][crate::descriptor_proto::ExtensionRange::options].
        pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::ExtensionRangeOptions>,
        {
            self.options = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for ExtensionRange {
        fn typename() -> &'static str {
            "type.googleapis.com/google.protobuf.DescriptorProto.ExtensionRange"
        }
    }

    #[doc(hidden)]
    impl<'de> serde::de::Deserialize<'de> for ExtensionRange {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            #[allow(non_camel_case_types)]
            #[doc(hidden)]
            #[derive(PartialEq, Eq, Hash)]
            enum __FieldTag {
                __start,
                __end,
                __options,
                Unknown(std::string::String),
            }
            impl<'de> serde::de::Deserialize<'de> for __FieldTag {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    struct Visitor;
                    impl<'de> serde::de::Visitor<'de> for Visitor {
                        type Value = __FieldTag;
                        fn expecting(
                            &self,
                            formatter: &mut std::fmt::Formatter,
                        ) -> std::fmt::Result {
                            formatter.write_str("a field name for ExtensionRange")
                        }
                        fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                        where
                            E: serde::de::Error,
                        {
                            use std::result::Result::Ok;
                            use std::string::ToString;
                            match value {
                                "start" => Ok(__FieldTag::__start),
                                "end" => Ok(__FieldTag::__end),
                                "options" => Ok(__FieldTag::__options),
                                _ => Ok(__FieldTag::Unknown(value.to_string())),
                            }
                        }
                    }
                    deserializer.deserialize_identifier(Visitor)
                }
            }
            struct Visitor;
            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = ExtensionRange;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct ExtensionRange")
                }
                fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
                where
                    A: serde::de::MapAccess<'de>,
                {
                    #[allow(unused_imports)]
                    use serde::de::Error;
                    use std::option::Option::Some;
                    let mut fields = std::collections::HashSet::new();
                    let mut result = Self::Value::new();
                    while let Some(tag) = map.next_key::<__FieldTag>()? {
                        #[allow(clippy::match_single_binding)]
                        match tag {
                            __FieldTag::__start => {
                                if !fields.insert(__FieldTag::__start) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for start",
                                    ));
                                }
                                struct __With(std::option::Option<i32>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                    }
                                }
                                result.start = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::__end => {
                                if !fields.insert(__FieldTag::__end) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for end",
                                    ));
                                }
                                struct __With(std::option::Option<i32>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                    }
                                }
                                result.end = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::__options => {
                                if !fields.insert(__FieldTag::__options) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for options",
                                    ));
                                }
                                result.options = map.next_value::<std::option::Option<crate::ExtensionRangeOptions>>()?
                                    ;
                            }
                            __FieldTag::Unknown(key) => {
                                let value = map.next_value::<serde_json::Value>()?;
                                result._unknown_fields.insert(key, value);
                            }
                        }
                    }
                    std::result::Result::Ok(result)
                }
            }
            deserializer.deserialize_any(Visitor)
        }
    }

    #[doc(hidden)]
    impl serde::ser::Serialize for ExtensionRange {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
        {
            use serde::ser::SerializeMap;
            #[allow(unused_imports)]
            use std::option::Option::Some;
            let mut state = serializer.serialize_map(std::option::Option::None)?;
            if !wkt::internal::is_default(&self.start) {
                struct __With<'a>(&'a i32);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                    }
                }
                state.serialize_entry("start", &__With(&self.start))?;
            }
            if !wkt::internal::is_default(&self.end) {
                struct __With<'a>(&'a i32);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                    }
                }
                state.serialize_entry("end", &__With(&self.end))?;
            }
            if self.options.is_some() {
                state.serialize_entry("options", &self.options)?;
            }
            if !self._unknown_fields.is_empty() {
                for (key, value) in self._unknown_fields.iter() {
                    state.serialize_entry(key, &value)?;
                }
            }
            state.end()
        }
    }

    impl std::fmt::Debug for ExtensionRange {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut debug_struct = f.debug_struct("ExtensionRange");
            debug_struct.field("start", &self.start);
            debug_struct.field("end", &self.end);
            debug_struct.field("options", &self.options);
            if !self._unknown_fields.is_empty() {
                debug_struct.field("_unknown_fields", &self._unknown_fields);
            }
            debug_struct.finish()
        }
    }

    /// Range of reserved tag numbers. Reserved tag numbers may not be used by
    /// fields or extension ranges in the same message. Reserved ranges may
    /// not overlap.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ReservedRange {
        pub start: i32,

        pub end: i32,

        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl ReservedRange {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [start][crate::descriptor_proto::ReservedRange::start].
        pub fn set_start<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.start = v.into();
            self
        }

        /// Sets the value of [end][crate::descriptor_proto::ReservedRange::end].
        pub fn set_end<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.end = v.into();
            self
        }
    }

    impl wkt::message::Message for ReservedRange {
        fn typename() -> &'static str {
            "type.googleapis.com/google.protobuf.DescriptorProto.ReservedRange"
        }
    }

    #[doc(hidden)]
    impl<'de> serde::de::Deserialize<'de> for ReservedRange {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            #[allow(non_camel_case_types)]
            #[doc(hidden)]
            #[derive(PartialEq, Eq, Hash)]
            enum __FieldTag {
                __start,
                __end,
                Unknown(std::string::String),
            }
            impl<'de> serde::de::Deserialize<'de> for __FieldTag {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    struct Visitor;
                    impl<'de> serde::de::Visitor<'de> for Visitor {
                        type Value = __FieldTag;
                        fn expecting(
                            &self,
                            formatter: &mut std::fmt::Formatter,
                        ) -> std::fmt::Result {
                            formatter.write_str("a field name for ReservedRange")
                        }
                        fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                        where
                            E: serde::de::Error,
                        {
                            use std::result::Result::Ok;
                            use std::string::ToString;
                            match value {
                                "start" => Ok(__FieldTag::__start),
                                "end" => Ok(__FieldTag::__end),
                                _ => Ok(__FieldTag::Unknown(value.to_string())),
                            }
                        }
                    }
                    deserializer.deserialize_identifier(Visitor)
                }
            }
            struct Visitor;
            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = ReservedRange;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct ReservedRange")
                }
                fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
                where
                    A: serde::de::MapAccess<'de>,
                {
                    #[allow(unused_imports)]
                    use serde::de::Error;
                    use std::option::Option::Some;
                    let mut fields = std::collections::HashSet::new();
                    let mut result = Self::Value::new();
                    while let Some(tag) = map.next_key::<__FieldTag>()? {
                        #[allow(clippy::match_single_binding)]
                        match tag {
                            __FieldTag::__start => {
                                if !fields.insert(__FieldTag::__start) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for start",
                                    ));
                                }
                                struct __With(std::option::Option<i32>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                    }
                                }
                                result.start = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::__end => {
                                if !fields.insert(__FieldTag::__end) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for end",
                                    ));
                                }
                                struct __With(std::option::Option<i32>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                    }
                                }
                                result.end = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::Unknown(key) => {
                                let value = map.next_value::<serde_json::Value>()?;
                                result._unknown_fields.insert(key, value);
                            }
                        }
                    }
                    std::result::Result::Ok(result)
                }
            }
            deserializer.deserialize_any(Visitor)
        }
    }

    #[doc(hidden)]
    impl serde::ser::Serialize for ReservedRange {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
        {
            use serde::ser::SerializeMap;
            #[allow(unused_imports)]
            use std::option::Option::Some;
            let mut state = serializer.serialize_map(std::option::Option::None)?;
            if !wkt::internal::is_default(&self.start) {
                struct __With<'a>(&'a i32);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                    }
                }
                state.serialize_entry("start", &__With(&self.start))?;
            }
            if !wkt::internal::is_default(&self.end) {
                struct __With<'a>(&'a i32);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                    }
                }
                state.serialize_entry("end", &__With(&self.end))?;
            }
            if !self._unknown_fields.is_empty() {
                for (key, value) in self._unknown_fields.iter() {
                    state.serialize_entry(key, &value)?;
                }
            }
            state.end()
        }
    }

    impl std::fmt::Debug for ReservedRange {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut debug_struct = f.debug_struct("ReservedRange");
            debug_struct.field("start", &self.start);
            debug_struct.field("end", &self.end);
            if !self._unknown_fields.is_empty() {
                debug_struct.field("_unknown_fields", &self._unknown_fields);
            }
            debug_struct.finish()
        }
    }
}

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExtensionRangeOptions {
    /// The parser stores options it doesn't recognize here. See above.
    pub uninterpreted_option: std::vec::Vec<crate::UninterpretedOption>,

    /// For external users: DO NOT USE. We are in the process of open sourcing
    /// extension declaration and executing internal cleanups before it can be
    /// used externally.
    pub declaration: std::vec::Vec<crate::extension_range_options::Declaration>,

    /// Any features defined in the specific edition.
    pub features: std::option::Option<crate::FeatureSet>,

    /// The verification state of the range.
    /// TODO: flip the default to DECLARATION once all empty ranges
    /// are marked as UNVERIFIED.
    pub verification: crate::extension_range_options::VerificationState,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ExtensionRangeOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [uninterpreted_option][crate::ExtensionRangeOptions::uninterpreted_option].
    pub fn set_uninterpreted_option<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::UninterpretedOption>,
    {
        use std::iter::Iterator;
        self.uninterpreted_option = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [declaration][crate::ExtensionRangeOptions::declaration].
    pub fn set_declaration<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::extension_range_options::Declaration>,
    {
        use std::iter::Iterator;
        self.declaration = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [features][crate::ExtensionRangeOptions::features].
    pub fn set_features<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [features][crate::ExtensionRangeOptions::features].
    pub fn set_or_clear_features<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = v.map(|x| x.into());
        self
    }

    /// Sets the value of [verification][crate::ExtensionRangeOptions::verification].
    pub fn set_verification<
        T: std::convert::Into<crate::extension_range_options::VerificationState>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.verification = v.into();
        self
    }
}

impl wkt::message::Message for ExtensionRangeOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.ExtensionRangeOptions"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for ExtensionRangeOptions {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __uninterpreted_option,
            __declaration,
            __features,
            __verification,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for ExtensionRangeOptions")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "uninterpretedOption" => Ok(__FieldTag::__uninterpreted_option),
                            "uninterpreted_option" => Ok(__FieldTag::__uninterpreted_option),
                            "declaration" => Ok(__FieldTag::__declaration),
                            "features" => Ok(__FieldTag::__features),
                            "verification" => Ok(__FieldTag::__verification),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = ExtensionRangeOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ExtensionRangeOptions")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__uninterpreted_option => {
                            if !fields.insert(__FieldTag::__uninterpreted_option) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for uninterpreted_option",
                                ));
                            }
                            result.uninterpreted_option = map.next_value::<std::option::Option<std::vec::Vec<crate::UninterpretedOption>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__declaration => {
                            if !fields.insert(__FieldTag::__declaration) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for declaration",
                                ));
                            }
                            result.declaration = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::extension_range_options::Declaration>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__features => {
                            if !fields.insert(__FieldTag::__features) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for features",
                                ));
                            }
                            result.features =
                                map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                        }
                        __FieldTag::__verification => {
                            if !fields.insert(__FieldTag::__verification) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for verification",
                                ));
                            }
                            result.verification = map
                                .next_value::<std::option::Option<
                                    crate::extension_range_options::VerificationState,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for ExtensionRangeOptions {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.uninterpreted_option.is_empty() {
            state.serialize_entry("uninterpretedOption", &self.uninterpreted_option)?;
        }
        if !self.declaration.is_empty() {
            state.serialize_entry("declaration", &self.declaration)?;
        }
        if self.features.is_some() {
            state.serialize_entry("features", &self.features)?;
        }
        if !wkt::internal::is_default(&self.verification) {
            state.serialize_entry("verification", &self.verification)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for ExtensionRangeOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExtensionRangeOptions");
        debug_struct.field("uninterpreted_option", &self.uninterpreted_option);
        debug_struct.field("declaration", &self.declaration);
        debug_struct.field("features", &self.features);
        debug_struct.field("verification", &self.verification);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [ExtensionRangeOptions].
pub mod extension_range_options {
    #[allow(unused_imports)]
    use super::*;

    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Declaration {
        /// The extension number declared within the extension range.
        pub number: i32,

        /// The fully-qualified name of the extension field. There must be a leading
        /// dot in front of the full name.
        pub full_name: std::string::String,

        /// The fully-qualified type name of the extension field. Unlike
        /// Metadata.type, Declaration.type must have a leading dot for messages
        /// and enums.
        pub r#type: std::string::String,

        /// If true, indicates that the number is reserved in the extension range,
        /// and any extension field with the number will fail to compile. Set this
        /// when a declared extension field is deleted.
        pub reserved: bool,

        /// If true, indicates that the extension must be defined as repeated.
        /// Otherwise the extension must be defined as optional.
        pub repeated: bool,

        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl Declaration {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [number][crate::extension_range_options::Declaration::number].
        pub fn set_number<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.number = v.into();
            self
        }

        /// Sets the value of [full_name][crate::extension_range_options::Declaration::full_name].
        pub fn set_full_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.full_name = v.into();
            self
        }

        /// Sets the value of [r#type][crate::extension_range_options::Declaration::type].
        pub fn set_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.r#type = v.into();
            self
        }

        /// Sets the value of [reserved][crate::extension_range_options::Declaration::reserved].
        pub fn set_reserved<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.reserved = v.into();
            self
        }

        /// Sets the value of [repeated][crate::extension_range_options::Declaration::repeated].
        pub fn set_repeated<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.repeated = v.into();
            self
        }
    }

    impl wkt::message::Message for Declaration {
        fn typename() -> &'static str {
            "type.googleapis.com/google.protobuf.ExtensionRangeOptions.Declaration"
        }
    }

    #[doc(hidden)]
    impl<'de> serde::de::Deserialize<'de> for Declaration {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            #[allow(non_camel_case_types)]
            #[doc(hidden)]
            #[derive(PartialEq, Eq, Hash)]
            enum __FieldTag {
                __number,
                __full_name,
                __type,
                __reserved,
                __repeated,
                Unknown(std::string::String),
            }
            impl<'de> serde::de::Deserialize<'de> for __FieldTag {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    struct Visitor;
                    impl<'de> serde::de::Visitor<'de> for Visitor {
                        type Value = __FieldTag;
                        fn expecting(
                            &self,
                            formatter: &mut std::fmt::Formatter,
                        ) -> std::fmt::Result {
                            formatter.write_str("a field name for Declaration")
                        }
                        fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                        where
                            E: serde::de::Error,
                        {
                            use std::result::Result::Ok;
                            use std::string::ToString;
                            match value {
                                "number" => Ok(__FieldTag::__number),
                                "fullName" => Ok(__FieldTag::__full_name),
                                "full_name" => Ok(__FieldTag::__full_name),
                                "type" => Ok(__FieldTag::__type),
                                "reserved" => Ok(__FieldTag::__reserved),
                                "repeated" => Ok(__FieldTag::__repeated),
                                _ => Ok(__FieldTag::Unknown(value.to_string())),
                            }
                        }
                    }
                    deserializer.deserialize_identifier(Visitor)
                }
            }
            struct Visitor;
            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = Declaration;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct Declaration")
                }
                fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
                where
                    A: serde::de::MapAccess<'de>,
                {
                    #[allow(unused_imports)]
                    use serde::de::Error;
                    use std::option::Option::Some;
                    let mut fields = std::collections::HashSet::new();
                    let mut result = Self::Value::new();
                    while let Some(tag) = map.next_key::<__FieldTag>()? {
                        #[allow(clippy::match_single_binding)]
                        match tag {
                            __FieldTag::__number => {
                                if !fields.insert(__FieldTag::__number) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for number",
                                    ));
                                }
                                struct __With(std::option::Option<i32>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                    }
                                }
                                result.number = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::__full_name => {
                                if !fields.insert(__FieldTag::__full_name) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for full_name",
                                    ));
                                }
                                result.full_name = map
                                    .next_value::<std::option::Option<std::string::String>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__type => {
                                if !fields.insert(__FieldTag::__type) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for type",
                                    ));
                                }
                                result.r#type = map
                                    .next_value::<std::option::Option<std::string::String>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__reserved => {
                                if !fields.insert(__FieldTag::__reserved) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for reserved",
                                    ));
                                }
                                result.reserved = map
                                    .next_value::<std::option::Option<bool>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__repeated => {
                                if !fields.insert(__FieldTag::__repeated) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for repeated",
                                    ));
                                }
                                result.repeated = map
                                    .next_value::<std::option::Option<bool>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::Unknown(key) => {
                                let value = map.next_value::<serde_json::Value>()?;
                                result._unknown_fields.insert(key, value);
                            }
                        }
                    }
                    std::result::Result::Ok(result)
                }
            }
            deserializer.deserialize_any(Visitor)
        }
    }

    #[doc(hidden)]
    impl serde::ser::Serialize for Declaration {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
        {
            use serde::ser::SerializeMap;
            #[allow(unused_imports)]
            use std::option::Option::Some;
            let mut state = serializer.serialize_map(std::option::Option::None)?;
            if !wkt::internal::is_default(&self.number) {
                struct __With<'a>(&'a i32);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                    }
                }
                state.serialize_entry("number", &__With(&self.number))?;
            }
            if !self.full_name.is_empty() {
                state.serialize_entry("fullName", &self.full_name)?;
            }
            if !self.r#type.is_empty() {
                state.serialize_entry("type", &self.r#type)?;
            }
            if !wkt::internal::is_default(&self.reserved) {
                state.serialize_entry("reserved", &self.reserved)?;
            }
            if !wkt::internal::is_default(&self.repeated) {
                state.serialize_entry("repeated", &self.repeated)?;
            }
            if !self._unknown_fields.is_empty() {
                for (key, value) in self._unknown_fields.iter() {
                    state.serialize_entry(key, &value)?;
                }
            }
            state.end()
        }
    }

    impl std::fmt::Debug for Declaration {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut debug_struct = f.debug_struct("Declaration");
            debug_struct.field("number", &self.number);
            debug_struct.field("full_name", &self.full_name);
            debug_struct.field("r#type", &self.r#type);
            debug_struct.field("reserved", &self.reserved);
            debug_struct.field("repeated", &self.repeated);
            if !self._unknown_fields.is_empty() {
                debug_struct.field("_unknown_fields", &self._unknown_fields);
            }
            debug_struct.finish()
        }
    }

    /// The verification state of the extension range.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum VerificationState {
        /// All the extensions of the range must be declared.
        Declaration,
        Unverified,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [VerificationState::value] or
        /// [VerificationState::name].
        UnknownValue(verification_state::UnknownValue),
    }

    #[doc(hidden)]
    pub mod verification_state {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl VerificationState {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Declaration => std::option::Option::Some(0),
                Self::Unverified => std::option::Option::Some(1),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Declaration => std::option::Option::Some("DECLARATION"),
                Self::Unverified => std::option::Option::Some("UNVERIFIED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for VerificationState {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for VerificationState {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for VerificationState {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Declaration,
                1 => Self::Unverified,
                _ => Self::UnknownValue(verification_state::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for VerificationState {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "DECLARATION" => Self::Declaration,
                "UNVERIFIED" => Self::Unverified,
                _ => Self::UnknownValue(verification_state::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for VerificationState {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Declaration => serializer.serialize_i32(0),
                Self::Unverified => serializer.serialize_i32(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for VerificationState {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<VerificationState>::new(
                ".google.protobuf.ExtensionRangeOptions.VerificationState",
            ))
        }
    }
}

/// Describes a field within a message.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FieldDescriptorProto {
    pub name: std::string::String,

    pub number: i32,

    pub label: crate::field_descriptor_proto::Label,

    /// If type_name is set, this need not be set.  If both this and type_name
    /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
    pub r#type: crate::field_descriptor_proto::Type,

    /// For message and enum types, this is the name of the type.  If the name
    /// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
    /// rules are used to find the type (i.e. first the nested types within this
    /// message are searched, then within the parent, on up to the root
    /// namespace).
    pub type_name: std::string::String,

    /// For extensions, this is the name of the type being extended.  It is
    /// resolved in the same manner as type_name.
    pub extendee: std::string::String,

    /// For numeric types, contains the original text representation of the value.
    /// For booleans, "true" or "false".
    /// For strings, contains the default text contents (not escaped in any way).
    /// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
    pub default_value: std::string::String,

    /// If set, gives the index of a oneof in the containing type's oneof_decl
    /// list.  This field is a member of that oneof.
    pub oneof_index: i32,

    /// JSON name of this field. The value is set by protocol compiler. If the
    /// user has set a "json_name" option on this field, that option's value
    /// will be used. Otherwise, it's deduced from the field's name by converting
    /// it to camelCase.
    pub json_name: std::string::String,

    pub options: std::option::Option<crate::FieldOptions>,

    /// If true, this is a proto3 "optional". When a proto3 field is optional, it
    /// tracks presence regardless of field type.
    ///
    /// When proto3_optional is true, this field must belong to a oneof to signal
    /// to old proto3 clients that presence is tracked for this field. This oneof
    /// is known as a "synthetic" oneof, and this field must be its sole member
    /// (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs
    /// exist in the descriptor only, and do not generate any API. Synthetic oneofs
    /// must be ordered after all "real" oneofs.
    ///
    /// For message fields, proto3_optional doesn't create any semantic change,
    /// since non-repeated message fields always track presence. However it still
    /// indicates the semantic detail of whether the user wrote "optional" or not.
    /// This can be useful for round-tripping the .proto file. For consistency we
    /// give message fields a synthetic oneof also, even though it is not required
    /// to track presence. This is especially important because the parser can't
    /// tell if a field is a message or an enum, so it must always create a
    /// synthetic oneof.
    ///
    /// Proto2 optional fields do not set this flag, because they already indicate
    /// optional with `LABEL_OPTIONAL`.
    pub proto3_optional: bool,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FieldDescriptorProto {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::FieldDescriptorProto::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [number][crate::FieldDescriptorProto::number].
    pub fn set_number<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.number = v.into();
        self
    }

    /// Sets the value of [label][crate::FieldDescriptorProto::label].
    pub fn set_label<T: std::convert::Into<crate::field_descriptor_proto::Label>>(
        mut self,
        v: T,
    ) -> Self {
        self.label = v.into();
        self
    }

    /// Sets the value of [r#type][crate::FieldDescriptorProto::type].
    pub fn set_type<T: std::convert::Into<crate::field_descriptor_proto::Type>>(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = v.into();
        self
    }

    /// Sets the value of [type_name][crate::FieldDescriptorProto::type_name].
    pub fn set_type_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.type_name = v.into();
        self
    }

    /// Sets the value of [extendee][crate::FieldDescriptorProto::extendee].
    pub fn set_extendee<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.extendee = v.into();
        self
    }

    /// Sets the value of [default_value][crate::FieldDescriptorProto::default_value].
    pub fn set_default_value<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.default_value = v.into();
        self
    }

    /// Sets the value of [oneof_index][crate::FieldDescriptorProto::oneof_index].
    pub fn set_oneof_index<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.oneof_index = v.into();
        self
    }

    /// Sets the value of [json_name][crate::FieldDescriptorProto::json_name].
    pub fn set_json_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.json_name = v.into();
        self
    }

    /// Sets the value of [options][crate::FieldDescriptorProto::options].
    pub fn set_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FieldOptions>,
    {
        self.options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [options][crate::FieldDescriptorProto::options].
    pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FieldOptions>,
    {
        self.options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [proto3_optional][crate::FieldDescriptorProto::proto3_optional].
    pub fn set_proto3_optional<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.proto3_optional = v.into();
        self
    }
}

impl wkt::message::Message for FieldDescriptorProto {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.FieldDescriptorProto"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for FieldDescriptorProto {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __number,
            __label,
            __type,
            __type_name,
            __extendee,
            __default_value,
            __oneof_index,
            __json_name,
            __options,
            __proto3_optional,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for FieldDescriptorProto")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "number" => Ok(__FieldTag::__number),
                            "label" => Ok(__FieldTag::__label),
                            "type" => Ok(__FieldTag::__type),
                            "typeName" => Ok(__FieldTag::__type_name),
                            "type_name" => Ok(__FieldTag::__type_name),
                            "extendee" => Ok(__FieldTag::__extendee),
                            "defaultValue" => Ok(__FieldTag::__default_value),
                            "default_value" => Ok(__FieldTag::__default_value),
                            "oneofIndex" => Ok(__FieldTag::__oneof_index),
                            "oneof_index" => Ok(__FieldTag::__oneof_index),
                            "jsonName" => Ok(__FieldTag::__json_name),
                            "json_name" => Ok(__FieldTag::__json_name),
                            "options" => Ok(__FieldTag::__options),
                            "proto3Optional" => Ok(__FieldTag::__proto3_optional),
                            "proto3_optional" => Ok(__FieldTag::__proto3_optional),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = FieldDescriptorProto;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct FieldDescriptorProto")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__number => {
                            if !fields.insert(__FieldTag::__number) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for number",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.number = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__label => {
                            if !fields.insert(__FieldTag::__label) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for label",
                                ));
                            }
                            result.label = map.next_value::<std::option::Option<crate::field_descriptor_proto::Label>>()?.unwrap_or_default();
                        }
                        __FieldTag::__type => {
                            if !fields.insert(__FieldTag::__type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for type",
                                ));
                            }
                            result.r#type = map.next_value::<std::option::Option<crate::field_descriptor_proto::Type>>()?.unwrap_or_default();
                        }
                        __FieldTag::__type_name => {
                            if !fields.insert(__FieldTag::__type_name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for type_name",
                                ));
                            }
                            result.type_name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__extendee => {
                            if !fields.insert(__FieldTag::__extendee) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for extendee",
                                ));
                            }
                            result.extendee = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__default_value => {
                            if !fields.insert(__FieldTag::__default_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for default_value",
                                ));
                            }
                            result.default_value = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__oneof_index => {
                            if !fields.insert(__FieldTag::__oneof_index) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for oneof_index",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.oneof_index = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__json_name => {
                            if !fields.insert(__FieldTag::__json_name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for json_name",
                                ));
                            }
                            result.json_name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options =
                                map.next_value::<std::option::Option<crate::FieldOptions>>()?;
                        }
                        __FieldTag::__proto3_optional => {
                            if !fields.insert(__FieldTag::__proto3_optional) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for proto3_optional",
                                ));
                            }
                            result.proto3_optional = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for FieldDescriptorProto {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !wkt::internal::is_default(&self.number) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("number", &__With(&self.number))?;
        }
        if !wkt::internal::is_default(&self.label) {
            state.serialize_entry("label", &self.label)?;
        }
        if !wkt::internal::is_default(&self.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !self.type_name.is_empty() {
            state.serialize_entry("typeName", &self.type_name)?;
        }
        if !self.extendee.is_empty() {
            state.serialize_entry("extendee", &self.extendee)?;
        }
        if !self.default_value.is_empty() {
            state.serialize_entry("defaultValue", &self.default_value)?;
        }
        if !wkt::internal::is_default(&self.oneof_index) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("oneofIndex", &__With(&self.oneof_index))?;
        }
        if !self.json_name.is_empty() {
            state.serialize_entry("jsonName", &self.json_name)?;
        }
        if self.options.is_some() {
            state.serialize_entry("options", &self.options)?;
        }
        if !wkt::internal::is_default(&self.proto3_optional) {
            state.serialize_entry("proto3Optional", &self.proto3_optional)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for FieldDescriptorProto {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FieldDescriptorProto");
        debug_struct.field("name", &self.name);
        debug_struct.field("number", &self.number);
        debug_struct.field("label", &self.label);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("type_name", &self.type_name);
        debug_struct.field("extendee", &self.extendee);
        debug_struct.field("default_value", &self.default_value);
        debug_struct.field("oneof_index", &self.oneof_index);
        debug_struct.field("json_name", &self.json_name);
        debug_struct.field("options", &self.options);
        debug_struct.field("proto3_optional", &self.proto3_optional);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [FieldDescriptorProto].
pub mod field_descriptor_proto {
    #[allow(unused_imports)]
    use super::*;

    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Type {
        /// 0 is reserved for errors.
        /// Order is weird for historical reasons.
        Double,
        Float,
        /// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
        /// negative values are likely.
        Int64,
        Uint64,
        /// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
        /// negative values are likely.
        Int32,
        Fixed64,
        Fixed32,
        Bool,
        String,
        /// Tag-delimited aggregate.
        /// Group type is deprecated and not supported after google.protobuf. However, Proto3
        /// implementations should still be able to parse the group wire format and
        /// treat group fields as unknown fields.  In Editions, the group wire format
        /// can be enabled via the `message_encoding` feature.
        Group,
        Message,
        /// New in version 2.
        Bytes,
        Uint32,
        Enum,
        Sfixed32,
        Sfixed64,
        Sint32,
        Sint64,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Type::value] or
        /// [Type::name].
        UnknownValue(r#type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod r#type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Type {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Double => std::option::Option::Some(1),
                Self::Float => std::option::Option::Some(2),
                Self::Int64 => std::option::Option::Some(3),
                Self::Uint64 => std::option::Option::Some(4),
                Self::Int32 => std::option::Option::Some(5),
                Self::Fixed64 => std::option::Option::Some(6),
                Self::Fixed32 => std::option::Option::Some(7),
                Self::Bool => std::option::Option::Some(8),
                Self::String => std::option::Option::Some(9),
                Self::Group => std::option::Option::Some(10),
                Self::Message => std::option::Option::Some(11),
                Self::Bytes => std::option::Option::Some(12),
                Self::Uint32 => std::option::Option::Some(13),
                Self::Enum => std::option::Option::Some(14),
                Self::Sfixed32 => std::option::Option::Some(15),
                Self::Sfixed64 => std::option::Option::Some(16),
                Self::Sint32 => std::option::Option::Some(17),
                Self::Sint64 => std::option::Option::Some(18),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Double => std::option::Option::Some("TYPE_DOUBLE"),
                Self::Float => std::option::Option::Some("TYPE_FLOAT"),
                Self::Int64 => std::option::Option::Some("TYPE_INT64"),
                Self::Uint64 => std::option::Option::Some("TYPE_UINT64"),
                Self::Int32 => std::option::Option::Some("TYPE_INT32"),
                Self::Fixed64 => std::option::Option::Some("TYPE_FIXED64"),
                Self::Fixed32 => std::option::Option::Some("TYPE_FIXED32"),
                Self::Bool => std::option::Option::Some("TYPE_BOOL"),
                Self::String => std::option::Option::Some("TYPE_STRING"),
                Self::Group => std::option::Option::Some("TYPE_GROUP"),
                Self::Message => std::option::Option::Some("TYPE_MESSAGE"),
                Self::Bytes => std::option::Option::Some("TYPE_BYTES"),
                Self::Uint32 => std::option::Option::Some("TYPE_UINT32"),
                Self::Enum => std::option::Option::Some("TYPE_ENUM"),
                Self::Sfixed32 => std::option::Option::Some("TYPE_SFIXED32"),
                Self::Sfixed64 => std::option::Option::Some("TYPE_SFIXED64"),
                Self::Sint32 => std::option::Option::Some("TYPE_SINT32"),
                Self::Sint64 => std::option::Option::Some("TYPE_SINT64"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Type {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Type {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Type {
        fn from(value: i32) -> Self {
            match value {
                1 => Self::Double,
                2 => Self::Float,
                3 => Self::Int64,
                4 => Self::Uint64,
                5 => Self::Int32,
                6 => Self::Fixed64,
                7 => Self::Fixed32,
                8 => Self::Bool,
                9 => Self::String,
                10 => Self::Group,
                11 => Self::Message,
                12 => Self::Bytes,
                13 => Self::Uint32,
                14 => Self::Enum,
                15 => Self::Sfixed32,
                16 => Self::Sfixed64,
                17 => Self::Sint32,
                18 => Self::Sint64,
                _ => Self::UnknownValue(r#type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Type {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TYPE_DOUBLE" => Self::Double,
                "TYPE_FLOAT" => Self::Float,
                "TYPE_INT64" => Self::Int64,
                "TYPE_UINT64" => Self::Uint64,
                "TYPE_INT32" => Self::Int32,
                "TYPE_FIXED64" => Self::Fixed64,
                "TYPE_FIXED32" => Self::Fixed32,
                "TYPE_BOOL" => Self::Bool,
                "TYPE_STRING" => Self::String,
                "TYPE_GROUP" => Self::Group,
                "TYPE_MESSAGE" => Self::Message,
                "TYPE_BYTES" => Self::Bytes,
                "TYPE_UINT32" => Self::Uint32,
                "TYPE_ENUM" => Self::Enum,
                "TYPE_SFIXED32" => Self::Sfixed32,
                "TYPE_SFIXED64" => Self::Sfixed64,
                "TYPE_SINT32" => Self::Sint32,
                "TYPE_SINT64" => Self::Sint64,
                _ => Self::UnknownValue(r#type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Type {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Double => serializer.serialize_i32(1),
                Self::Float => serializer.serialize_i32(2),
                Self::Int64 => serializer.serialize_i32(3),
                Self::Uint64 => serializer.serialize_i32(4),
                Self::Int32 => serializer.serialize_i32(5),
                Self::Fixed64 => serializer.serialize_i32(6),
                Self::Fixed32 => serializer.serialize_i32(7),
                Self::Bool => serializer.serialize_i32(8),
                Self::String => serializer.serialize_i32(9),
                Self::Group => serializer.serialize_i32(10),
                Self::Message => serializer.serialize_i32(11),
                Self::Bytes => serializer.serialize_i32(12),
                Self::Uint32 => serializer.serialize_i32(13),
                Self::Enum => serializer.serialize_i32(14),
                Self::Sfixed32 => serializer.serialize_i32(15),
                Self::Sfixed64 => serializer.serialize_i32(16),
                Self::Sint32 => serializer.serialize_i32(17),
                Self::Sint64 => serializer.serialize_i32(18),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Type {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Type>::new(
                ".google.protobuf.FieldDescriptorProto.Type",
            ))
        }
    }

    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Label {
        /// 0 is reserved for errors
        Optional,
        Repeated,
        /// The required label is only allowed in google.protobuf.  In proto3 and Editions
        /// it's explicitly prohibited.  In Editions, the `field_presence` feature
        /// can be used to get this behavior.
        Required,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Label::value] or
        /// [Label::name].
        UnknownValue(label::UnknownValue),
    }

    #[doc(hidden)]
    pub mod label {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Label {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Optional => std::option::Option::Some(1),
                Self::Repeated => std::option::Option::Some(3),
                Self::Required => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Optional => std::option::Option::Some("LABEL_OPTIONAL"),
                Self::Repeated => std::option::Option::Some("LABEL_REPEATED"),
                Self::Required => std::option::Option::Some("LABEL_REQUIRED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Label {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Label {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Label {
        fn from(value: i32) -> Self {
            match value {
                1 => Self::Optional,
                2 => Self::Required,
                3 => Self::Repeated,
                _ => Self::UnknownValue(label::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Label {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "LABEL_OPTIONAL" => Self::Optional,
                "LABEL_REPEATED" => Self::Repeated,
                "LABEL_REQUIRED" => Self::Required,
                _ => Self::UnknownValue(label::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Label {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Optional => serializer.serialize_i32(1),
                Self::Repeated => serializer.serialize_i32(3),
                Self::Required => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Label {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Label>::new(
                ".google.protobuf.FieldDescriptorProto.Label",
            ))
        }
    }
}

/// Describes a oneof.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OneofDescriptorProto {
    pub name: std::string::String,

    pub options: std::option::Option<crate::OneofOptions>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl OneofDescriptorProto {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::OneofDescriptorProto::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [options][crate::OneofDescriptorProto::options].
    pub fn set_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::OneofOptions>,
    {
        self.options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [options][crate::OneofDescriptorProto::options].
    pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::OneofOptions>,
    {
        self.options = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for OneofDescriptorProto {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.OneofDescriptorProto"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for OneofDescriptorProto {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __options,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for OneofDescriptorProto")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "options" => Ok(__FieldTag::__options),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = OneofDescriptorProto;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct OneofDescriptorProto")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options =
                                map.next_value::<std::option::Option<crate::OneofOptions>>()?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for OneofDescriptorProto {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if self.options.is_some() {
            state.serialize_entry("options", &self.options)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for OneofDescriptorProto {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OneofDescriptorProto");
        debug_struct.field("name", &self.name);
        debug_struct.field("options", &self.options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Describes an enum type.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct EnumDescriptorProto {
    pub name: std::string::String,

    pub value: std::vec::Vec<crate::EnumValueDescriptorProto>,

    pub options: std::option::Option<crate::EnumOptions>,

    /// Range of reserved numeric values. Reserved numeric values may not be used
    /// by enum values in the same enum declaration. Reserved ranges may not
    /// overlap.
    pub reserved_range: std::vec::Vec<crate::enum_descriptor_proto::EnumReservedRange>,

    /// Reserved enum value names, which may not be reused. A given name may only
    /// be reserved once.
    pub reserved_name: std::vec::Vec<std::string::String>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EnumDescriptorProto {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::EnumDescriptorProto::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [value][crate::EnumDescriptorProto::value].
    pub fn set_value<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::EnumValueDescriptorProto>,
    {
        use std::iter::Iterator;
        self.value = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [options][crate::EnumDescriptorProto::options].
    pub fn set_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::EnumOptions>,
    {
        self.options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [options][crate::EnumDescriptorProto::options].
    pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::EnumOptions>,
    {
        self.options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [reserved_range][crate::EnumDescriptorProto::reserved_range].
    pub fn set_reserved_range<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::enum_descriptor_proto::EnumReservedRange>,
    {
        use std::iter::Iterator;
        self.reserved_range = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [reserved_name][crate::EnumDescriptorProto::reserved_name].
    pub fn set_reserved_name<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.reserved_name = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for EnumDescriptorProto {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.EnumDescriptorProto"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for EnumDescriptorProto {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __value,
            __options,
            __reserved_range,
            __reserved_name,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for EnumDescriptorProto")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "value" => Ok(__FieldTag::__value),
                            "options" => Ok(__FieldTag::__options),
                            "reservedRange" => Ok(__FieldTag::__reserved_range),
                            "reserved_range" => Ok(__FieldTag::__reserved_range),
                            "reservedName" => Ok(__FieldTag::__reserved_name),
                            "reserved_name" => Ok(__FieldTag::__reserved_name),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = EnumDescriptorProto;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct EnumDescriptorProto")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__value => {
                            if !fields.insert(__FieldTag::__value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for value",
                                ));
                            }
                            result.value =
                                map.next_value::<std::option::Option<
                                    std::vec::Vec<crate::EnumValueDescriptorProto>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options =
                                map.next_value::<std::option::Option<crate::EnumOptions>>()?;
                        }
                        __FieldTag::__reserved_range => {
                            if !fields.insert(__FieldTag::__reserved_range) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for reserved_range",
                                ));
                            }
                            result.reserved_range = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::enum_descriptor_proto::EnumReservedRange>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__reserved_name => {
                            if !fields.insert(__FieldTag::__reserved_name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for reserved_name",
                                ));
                            }
                            result.reserved_name = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for EnumDescriptorProto {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.value.is_empty() {
            state.serialize_entry("value", &self.value)?;
        }
        if self.options.is_some() {
            state.serialize_entry("options", &self.options)?;
        }
        if !self.reserved_range.is_empty() {
            state.serialize_entry("reservedRange", &self.reserved_range)?;
        }
        if !self.reserved_name.is_empty() {
            state.serialize_entry("reservedName", &self.reserved_name)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for EnumDescriptorProto {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnumDescriptorProto");
        debug_struct.field("name", &self.name);
        debug_struct.field("value", &self.value);
        debug_struct.field("options", &self.options);
        debug_struct.field("reserved_range", &self.reserved_range);
        debug_struct.field("reserved_name", &self.reserved_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [EnumDescriptorProto].
pub mod enum_descriptor_proto {
    #[allow(unused_imports)]
    use super::*;

    /// Range of reserved numeric values. Reserved values may not be used by
    /// entries in the same enum. Reserved ranges may not overlap.
    ///
    /// Note that this is distinct from DescriptorProto.ReservedRange in that it
    /// is inclusive such that it can appropriately represent the entire int32
    /// domain.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct EnumReservedRange {
        pub start: i32,

        pub end: i32,

        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl EnumReservedRange {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [start][crate::enum_descriptor_proto::EnumReservedRange::start].
        pub fn set_start<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.start = v.into();
            self
        }

        /// Sets the value of [end][crate::enum_descriptor_proto::EnumReservedRange::end].
        pub fn set_end<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.end = v.into();
            self
        }
    }

    impl wkt::message::Message for EnumReservedRange {
        fn typename() -> &'static str {
            "type.googleapis.com/google.protobuf.EnumDescriptorProto.EnumReservedRange"
        }
    }

    #[doc(hidden)]
    impl<'de> serde::de::Deserialize<'de> for EnumReservedRange {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            #[allow(non_camel_case_types)]
            #[doc(hidden)]
            #[derive(PartialEq, Eq, Hash)]
            enum __FieldTag {
                __start,
                __end,
                Unknown(std::string::String),
            }
            impl<'de> serde::de::Deserialize<'de> for __FieldTag {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    struct Visitor;
                    impl<'de> serde::de::Visitor<'de> for Visitor {
                        type Value = __FieldTag;
                        fn expecting(
                            &self,
                            formatter: &mut std::fmt::Formatter,
                        ) -> std::fmt::Result {
                            formatter.write_str("a field name for EnumReservedRange")
                        }
                        fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                        where
                            E: serde::de::Error,
                        {
                            use std::result::Result::Ok;
                            use std::string::ToString;
                            match value {
                                "start" => Ok(__FieldTag::__start),
                                "end" => Ok(__FieldTag::__end),
                                _ => Ok(__FieldTag::Unknown(value.to_string())),
                            }
                        }
                    }
                    deserializer.deserialize_identifier(Visitor)
                }
            }
            struct Visitor;
            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = EnumReservedRange;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct EnumReservedRange")
                }
                fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
                where
                    A: serde::de::MapAccess<'de>,
                {
                    #[allow(unused_imports)]
                    use serde::de::Error;
                    use std::option::Option::Some;
                    let mut fields = std::collections::HashSet::new();
                    let mut result = Self::Value::new();
                    while let Some(tag) = map.next_key::<__FieldTag>()? {
                        #[allow(clippy::match_single_binding)]
                        match tag {
                            __FieldTag::__start => {
                                if !fields.insert(__FieldTag::__start) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for start",
                                    ));
                                }
                                struct __With(std::option::Option<i32>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                    }
                                }
                                result.start = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::__end => {
                                if !fields.insert(__FieldTag::__end) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for end",
                                    ));
                                }
                                struct __With(std::option::Option<i32>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                    }
                                }
                                result.end = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::Unknown(key) => {
                                let value = map.next_value::<serde_json::Value>()?;
                                result._unknown_fields.insert(key, value);
                            }
                        }
                    }
                    std::result::Result::Ok(result)
                }
            }
            deserializer.deserialize_any(Visitor)
        }
    }

    #[doc(hidden)]
    impl serde::ser::Serialize for EnumReservedRange {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
        {
            use serde::ser::SerializeMap;
            #[allow(unused_imports)]
            use std::option::Option::Some;
            let mut state = serializer.serialize_map(std::option::Option::None)?;
            if !wkt::internal::is_default(&self.start) {
                struct __With<'a>(&'a i32);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                    }
                }
                state.serialize_entry("start", &__With(&self.start))?;
            }
            if !wkt::internal::is_default(&self.end) {
                struct __With<'a>(&'a i32);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                    }
                }
                state.serialize_entry("end", &__With(&self.end))?;
            }
            if !self._unknown_fields.is_empty() {
                for (key, value) in self._unknown_fields.iter() {
                    state.serialize_entry(key, &value)?;
                }
            }
            state.end()
        }
    }

    impl std::fmt::Debug for EnumReservedRange {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut debug_struct = f.debug_struct("EnumReservedRange");
            debug_struct.field("start", &self.start);
            debug_struct.field("end", &self.end);
            if !self._unknown_fields.is_empty() {
                debug_struct.field("_unknown_fields", &self._unknown_fields);
            }
            debug_struct.finish()
        }
    }
}

/// Describes a value within an enum.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct EnumValueDescriptorProto {
    pub name: std::string::String,

    pub number: i32,

    pub options: std::option::Option<crate::EnumValueOptions>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EnumValueDescriptorProto {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::EnumValueDescriptorProto::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [number][crate::EnumValueDescriptorProto::number].
    pub fn set_number<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.number = v.into();
        self
    }

    /// Sets the value of [options][crate::EnumValueDescriptorProto::options].
    pub fn set_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::EnumValueOptions>,
    {
        self.options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [options][crate::EnumValueDescriptorProto::options].
    pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::EnumValueOptions>,
    {
        self.options = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for EnumValueDescriptorProto {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.EnumValueDescriptorProto"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for EnumValueDescriptorProto {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __number,
            __options,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for EnumValueDescriptorProto")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "number" => Ok(__FieldTag::__number),
                            "options" => Ok(__FieldTag::__options),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = EnumValueDescriptorProto;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct EnumValueDescriptorProto")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__number => {
                            if !fields.insert(__FieldTag::__number) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for number",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.number = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options =
                                map.next_value::<std::option::Option<crate::EnumValueOptions>>()?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for EnumValueDescriptorProto {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !wkt::internal::is_default(&self.number) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("number", &__With(&self.number))?;
        }
        if self.options.is_some() {
            state.serialize_entry("options", &self.options)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for EnumValueDescriptorProto {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnumValueDescriptorProto");
        debug_struct.field("name", &self.name);
        debug_struct.field("number", &self.number);
        debug_struct.field("options", &self.options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Describes a service.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ServiceDescriptorProto {
    pub name: std::string::String,

    pub method: std::vec::Vec<crate::MethodDescriptorProto>,

    pub options: std::option::Option<crate::ServiceOptions>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ServiceDescriptorProto {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::ServiceDescriptorProto::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [method][crate::ServiceDescriptorProto::method].
    pub fn set_method<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::MethodDescriptorProto>,
    {
        use std::iter::Iterator;
        self.method = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [options][crate::ServiceDescriptorProto::options].
    pub fn set_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::ServiceOptions>,
    {
        self.options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [options][crate::ServiceDescriptorProto::options].
    pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::ServiceOptions>,
    {
        self.options = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ServiceDescriptorProto {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.ServiceDescriptorProto"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for ServiceDescriptorProto {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __method,
            __options,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for ServiceDescriptorProto")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "method" => Ok(__FieldTag::__method),
                            "options" => Ok(__FieldTag::__options),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = ServiceDescriptorProto;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ServiceDescriptorProto")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__method => {
                            if !fields.insert(__FieldTag::__method) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for method",
                                ));
                            }
                            result.method =
                                map.next_value::<std::option::Option<
                                    std::vec::Vec<crate::MethodDescriptorProto>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options =
                                map.next_value::<std::option::Option<crate::ServiceOptions>>()?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for ServiceDescriptorProto {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.method.is_empty() {
            state.serialize_entry("method", &self.method)?;
        }
        if self.options.is_some() {
            state.serialize_entry("options", &self.options)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for ServiceDescriptorProto {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ServiceDescriptorProto");
        debug_struct.field("name", &self.name);
        debug_struct.field("method", &self.method);
        debug_struct.field("options", &self.options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Describes a method of a service.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MethodDescriptorProto {
    pub name: std::string::String,

    /// Input and output type names.  These are resolved in the same way as
    /// FieldDescriptorProto.type_name, but must refer to a message type.
    pub input_type: std::string::String,

    pub output_type: std::string::String,

    pub options: std::option::Option<crate::MethodOptions>,

    /// Identifies if client streams multiple client messages
    pub client_streaming: bool,

    /// Identifies if server streams multiple server messages
    pub server_streaming: bool,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MethodDescriptorProto {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::MethodDescriptorProto::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [input_type][crate::MethodDescriptorProto::input_type].
    pub fn set_input_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.input_type = v.into();
        self
    }

    /// Sets the value of [output_type][crate::MethodDescriptorProto::output_type].
    pub fn set_output_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.output_type = v.into();
        self
    }

    /// Sets the value of [options][crate::MethodDescriptorProto::options].
    pub fn set_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::MethodOptions>,
    {
        self.options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [options][crate::MethodDescriptorProto::options].
    pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::MethodOptions>,
    {
        self.options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [client_streaming][crate::MethodDescriptorProto::client_streaming].
    pub fn set_client_streaming<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.client_streaming = v.into();
        self
    }

    /// Sets the value of [server_streaming][crate::MethodDescriptorProto::server_streaming].
    pub fn set_server_streaming<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.server_streaming = v.into();
        self
    }
}

impl wkt::message::Message for MethodDescriptorProto {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.MethodDescriptorProto"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for MethodDescriptorProto {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __input_type,
            __output_type,
            __options,
            __client_streaming,
            __server_streaming,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for MethodDescriptorProto")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "inputType" => Ok(__FieldTag::__input_type),
                            "input_type" => Ok(__FieldTag::__input_type),
                            "outputType" => Ok(__FieldTag::__output_type),
                            "output_type" => Ok(__FieldTag::__output_type),
                            "options" => Ok(__FieldTag::__options),
                            "clientStreaming" => Ok(__FieldTag::__client_streaming),
                            "client_streaming" => Ok(__FieldTag::__client_streaming),
                            "serverStreaming" => Ok(__FieldTag::__server_streaming),
                            "server_streaming" => Ok(__FieldTag::__server_streaming),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = MethodDescriptorProto;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct MethodDescriptorProto")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__input_type => {
                            if !fields.insert(__FieldTag::__input_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for input_type",
                                ));
                            }
                            result.input_type = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__output_type => {
                            if !fields.insert(__FieldTag::__output_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for output_type",
                                ));
                            }
                            result.output_type = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options =
                                map.next_value::<std::option::Option<crate::MethodOptions>>()?;
                        }
                        __FieldTag::__client_streaming => {
                            if !fields.insert(__FieldTag::__client_streaming) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for client_streaming",
                                ));
                            }
                            result.client_streaming = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__server_streaming => {
                            if !fields.insert(__FieldTag::__server_streaming) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for server_streaming",
                                ));
                            }
                            result.server_streaming = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for MethodDescriptorProto {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.input_type.is_empty() {
            state.serialize_entry("inputType", &self.input_type)?;
        }
        if !self.output_type.is_empty() {
            state.serialize_entry("outputType", &self.output_type)?;
        }
        if self.options.is_some() {
            state.serialize_entry("options", &self.options)?;
        }
        if !wkt::internal::is_default(&self.client_streaming) {
            state.serialize_entry("clientStreaming", &self.client_streaming)?;
        }
        if !wkt::internal::is_default(&self.server_streaming) {
            state.serialize_entry("serverStreaming", &self.server_streaming)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for MethodDescriptorProto {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MethodDescriptorProto");
        debug_struct.field("name", &self.name);
        debug_struct.field("input_type", &self.input_type);
        debug_struct.field("output_type", &self.output_type);
        debug_struct.field("options", &self.options);
        debug_struct.field("client_streaming", &self.client_streaming);
        debug_struct.field("server_streaming", &self.server_streaming);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FileOptions {
    /// Sets the Java package where classes generated from this .proto will be
    /// placed.  By default, the proto package is used, but this is often
    /// inappropriate because proto packages do not normally start with backwards
    /// domain names.
    pub java_package: std::string::String,

    /// Controls the name of the wrapper Java class generated for the .proto file.
    /// That class will always contain the .proto file's getDescriptor() method as
    /// well as any top-level extensions defined in the .proto file.
    /// If java_multiple_files is disabled, then all the other classes from the
    /// .proto file will be nested inside the single wrapper outer class.
    pub java_outer_classname: std::string::String,

    /// If enabled, then the Java code generator will generate a separate .java
    /// file for each top-level message, enum, and service defined in the .proto
    /// file.  Thus, these types will *not* be nested inside the wrapper class
    /// named by java_outer_classname.  However, the wrapper class will still be
    /// generated to contain the file's getDescriptor() method as well as any
    /// top-level extensions defined in the file.
    pub java_multiple_files: bool,

    /// This option does nothing.
    #[deprecated]
    pub java_generate_equals_and_hash: bool,

    /// A proto2 file can set this to true to opt in to UTF-8 checking for Java,
    /// which will throw an exception if invalid UTF-8 is parsed from the wire or
    /// assigned to a string field.
    ///
    /// TODO: clarify exactly what kinds of field types this option
    /// applies to, and update these docs accordingly.
    ///
    /// Proto3 files already perform these checks. Setting the option explicitly to
    /// false has no effect: it cannot be used to opt proto3 files out of UTF-8
    /// checks.
    pub java_string_check_utf8: bool,

    pub optimize_for: crate::file_options::OptimizeMode,

    /// Sets the Go package where structs generated from this .proto will be
    /// placed. If omitted, the Go package will be derived from the following:
    ///
    /// - The basename of the package import path, if provided.
    /// - Otherwise, the package statement in the .proto file, if present.
    /// - Otherwise, the basename of the .proto file, without extension.
    pub go_package: std::string::String,

    /// Should generic services be generated in each language?  "Generic" services
    /// are not specific to any particular RPC system.  They are generated by the
    /// main code generators in each language (without additional plugins).
    /// Generic services were the only kind of service generation supported by
    /// early versions of google.protobuf.
    ///
    /// Generic services are now considered deprecated in favor of using plugins
    /// that generate code specific to your particular RPC system.  Therefore,
    /// these default to false.  Old code which depends on generic services should
    /// explicitly set them to true.
    pub cc_generic_services: bool,

    pub java_generic_services: bool,

    pub py_generic_services: bool,

    /// Is this file deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for everything in the file, or it will be completely ignored; in the very
    /// least, this is a formalization for deprecating files.
    pub deprecated: bool,

    /// Enables the use of arenas for the proto messages in this file. This applies
    /// only to generated classes for C++.
    pub cc_enable_arenas: bool,

    /// Sets the objective c class prefix which is prepended to all objective c
    /// generated classes from this .proto. There is no default.
    pub objc_class_prefix: std::string::String,

    /// Namespace for generated classes; defaults to the package.
    pub csharp_namespace: std::string::String,

    /// By default Swift generators will take the proto package and CamelCase it
    /// replacing '.' with underscore and use that to prefix the types/symbols
    /// defined. When this options is provided, they will use this value instead
    /// to prefix the types/symbols defined.
    pub swift_prefix: std::string::String,

    /// Sets the php class prefix which is prepended to all php generated classes
    /// from this .proto. Default is empty.
    pub php_class_prefix: std::string::String,

    /// Use this option to change the namespace of php generated classes. Default
    /// is empty. When this option is empty, the package name will be used for
    /// determining the namespace.
    pub php_namespace: std::string::String,

    /// Use this option to change the namespace of php generated metadata classes.
    /// Default is empty. When this option is empty, the proto file name will be
    /// used for determining the namespace.
    pub php_metadata_namespace: std::string::String,

    /// Use this option to change the package of ruby generated classes. Default
    /// is empty. When this option is not set, the package name will be used for
    /// determining the ruby package.
    pub ruby_package: std::string::String,

    /// Any features defined in the specific edition.
    pub features: std::option::Option<crate::FeatureSet>,

    /// The parser stores options it doesn't recognize here.
    /// See the documentation for the "Options" section above.
    pub uninterpreted_option: std::vec::Vec<crate::UninterpretedOption>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FileOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [java_package][crate::FileOptions::java_package].
    pub fn set_java_package<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.java_package = v.into();
        self
    }

    /// Sets the value of [java_outer_classname][crate::FileOptions::java_outer_classname].
    pub fn set_java_outer_classname<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.java_outer_classname = v.into();
        self
    }

    /// Sets the value of [java_multiple_files][crate::FileOptions::java_multiple_files].
    pub fn set_java_multiple_files<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.java_multiple_files = v.into();
        self
    }

    /// Sets the value of [java_generate_equals_and_hash][crate::FileOptions::java_generate_equals_and_hash].
    #[deprecated]
    pub fn set_java_generate_equals_and_hash<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.java_generate_equals_and_hash = v.into();
        self
    }

    /// Sets the value of [java_string_check_utf8][crate::FileOptions::java_string_check_utf8].
    pub fn set_java_string_check_utf8<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.java_string_check_utf8 = v.into();
        self
    }

    /// Sets the value of [optimize_for][crate::FileOptions::optimize_for].
    pub fn set_optimize_for<T: std::convert::Into<crate::file_options::OptimizeMode>>(
        mut self,
        v: T,
    ) -> Self {
        self.optimize_for = v.into();
        self
    }

    /// Sets the value of [go_package][crate::FileOptions::go_package].
    pub fn set_go_package<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.go_package = v.into();
        self
    }

    /// Sets the value of [cc_generic_services][crate::FileOptions::cc_generic_services].
    pub fn set_cc_generic_services<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.cc_generic_services = v.into();
        self
    }

    /// Sets the value of [java_generic_services][crate::FileOptions::java_generic_services].
    pub fn set_java_generic_services<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.java_generic_services = v.into();
        self
    }

    /// Sets the value of [py_generic_services][crate::FileOptions::py_generic_services].
    pub fn set_py_generic_services<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.py_generic_services = v.into();
        self
    }

    /// Sets the value of [deprecated][crate::FileOptions::deprecated].
    pub fn set_deprecated<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.deprecated = v.into();
        self
    }

    /// Sets the value of [cc_enable_arenas][crate::FileOptions::cc_enable_arenas].
    pub fn set_cc_enable_arenas<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.cc_enable_arenas = v.into();
        self
    }

    /// Sets the value of [objc_class_prefix][crate::FileOptions::objc_class_prefix].
    pub fn set_objc_class_prefix<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.objc_class_prefix = v.into();
        self
    }

    /// Sets the value of [csharp_namespace][crate::FileOptions::csharp_namespace].
    pub fn set_csharp_namespace<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.csharp_namespace = v.into();
        self
    }

    /// Sets the value of [swift_prefix][crate::FileOptions::swift_prefix].
    pub fn set_swift_prefix<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.swift_prefix = v.into();
        self
    }

    /// Sets the value of [php_class_prefix][crate::FileOptions::php_class_prefix].
    pub fn set_php_class_prefix<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.php_class_prefix = v.into();
        self
    }

    /// Sets the value of [php_namespace][crate::FileOptions::php_namespace].
    pub fn set_php_namespace<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.php_namespace = v.into();
        self
    }

    /// Sets the value of [php_metadata_namespace][crate::FileOptions::php_metadata_namespace].
    pub fn set_php_metadata_namespace<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.php_metadata_namespace = v.into();
        self
    }

    /// Sets the value of [ruby_package][crate::FileOptions::ruby_package].
    pub fn set_ruby_package<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.ruby_package = v.into();
        self
    }

    /// Sets the value of [features][crate::FileOptions::features].
    pub fn set_features<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [features][crate::FileOptions::features].
    pub fn set_or_clear_features<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = v.map(|x| x.into());
        self
    }

    /// Sets the value of [uninterpreted_option][crate::FileOptions::uninterpreted_option].
    pub fn set_uninterpreted_option<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::UninterpretedOption>,
    {
        use std::iter::Iterator;
        self.uninterpreted_option = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for FileOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.FileOptions"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for FileOptions {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __java_package,
            __java_outer_classname,
            __java_multiple_files,
            __java_generate_equals_and_hash,
            __java_string_check_utf8,
            __optimize_for,
            __go_package,
            __cc_generic_services,
            __java_generic_services,
            __py_generic_services,
            __deprecated,
            __cc_enable_arenas,
            __objc_class_prefix,
            __csharp_namespace,
            __swift_prefix,
            __php_class_prefix,
            __php_namespace,
            __php_metadata_namespace,
            __ruby_package,
            __features,
            __uninterpreted_option,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for FileOptions")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "javaPackage" => Ok(__FieldTag::__java_package),
                            "java_package" => Ok(__FieldTag::__java_package),
                            "javaOuterClassname" => Ok(__FieldTag::__java_outer_classname),
                            "java_outer_classname" => Ok(__FieldTag::__java_outer_classname),
                            "javaMultipleFiles" => Ok(__FieldTag::__java_multiple_files),
                            "java_multiple_files" => Ok(__FieldTag::__java_multiple_files),
                            "javaGenerateEqualsAndHash" => {
                                Ok(__FieldTag::__java_generate_equals_and_hash)
                            }
                            "java_generate_equals_and_hash" => {
                                Ok(__FieldTag::__java_generate_equals_and_hash)
                            }
                            "javaStringCheckUtf8" => Ok(__FieldTag::__java_string_check_utf8),
                            "java_string_check_utf8" => Ok(__FieldTag::__java_string_check_utf8),
                            "optimizeFor" => Ok(__FieldTag::__optimize_for),
                            "optimize_for" => Ok(__FieldTag::__optimize_for),
                            "goPackage" => Ok(__FieldTag::__go_package),
                            "go_package" => Ok(__FieldTag::__go_package),
                            "ccGenericServices" => Ok(__FieldTag::__cc_generic_services),
                            "cc_generic_services" => Ok(__FieldTag::__cc_generic_services),
                            "javaGenericServices" => Ok(__FieldTag::__java_generic_services),
                            "java_generic_services" => Ok(__FieldTag::__java_generic_services),
                            "pyGenericServices" => Ok(__FieldTag::__py_generic_services),
                            "py_generic_services" => Ok(__FieldTag::__py_generic_services),
                            "deprecated" => Ok(__FieldTag::__deprecated),
                            "ccEnableArenas" => Ok(__FieldTag::__cc_enable_arenas),
                            "cc_enable_arenas" => Ok(__FieldTag::__cc_enable_arenas),
                            "objcClassPrefix" => Ok(__FieldTag::__objc_class_prefix),
                            "objc_class_prefix" => Ok(__FieldTag::__objc_class_prefix),
                            "csharpNamespace" => Ok(__FieldTag::__csharp_namespace),
                            "csharp_namespace" => Ok(__FieldTag::__csharp_namespace),
                            "swiftPrefix" => Ok(__FieldTag::__swift_prefix),
                            "swift_prefix" => Ok(__FieldTag::__swift_prefix),
                            "phpClassPrefix" => Ok(__FieldTag::__php_class_prefix),
                            "php_class_prefix" => Ok(__FieldTag::__php_class_prefix),
                            "phpNamespace" => Ok(__FieldTag::__php_namespace),
                            "php_namespace" => Ok(__FieldTag::__php_namespace),
                            "phpMetadataNamespace" => Ok(__FieldTag::__php_metadata_namespace),
                            "php_metadata_namespace" => Ok(__FieldTag::__php_metadata_namespace),
                            "rubyPackage" => Ok(__FieldTag::__ruby_package),
                            "ruby_package" => Ok(__FieldTag::__ruby_package),
                            "features" => Ok(__FieldTag::__features),
                            "uninterpretedOption" => Ok(__FieldTag::__uninterpreted_option),
                            "uninterpreted_option" => Ok(__FieldTag::__uninterpreted_option),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = FileOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct FileOptions")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__java_package => {
                            if !fields.insert(__FieldTag::__java_package) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for java_package",
                                ));
                            }
                            result.java_package = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__java_outer_classname => {
                            if !fields.insert(__FieldTag::__java_outer_classname) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for java_outer_classname",
                                ));
                            }
                            result.java_outer_classname = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__java_multiple_files => {
                            if !fields.insert(__FieldTag::__java_multiple_files) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for java_multiple_files",
                                ));
                            }
                            result.java_multiple_files = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__java_generate_equals_and_hash => {
                            if !fields.insert(__FieldTag::__java_generate_equals_and_hash) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for java_generate_equals_and_hash",
                                ));
                            }
                            result.java_generate_equals_and_hash = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__java_string_check_utf8 => {
                            if !fields.insert(__FieldTag::__java_string_check_utf8) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for java_string_check_utf8",
                                ));
                            }
                            result.java_string_check_utf8 = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__optimize_for => {
                            if !fields.insert(__FieldTag::__optimize_for) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for optimize_for",
                                ));
                            }
                            result.optimize_for = map.next_value::<std::option::Option<crate::file_options::OptimizeMode>>()?.unwrap_or_default();
                        }
                        __FieldTag::__go_package => {
                            if !fields.insert(__FieldTag::__go_package) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for go_package",
                                ));
                            }
                            result.go_package = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__cc_generic_services => {
                            if !fields.insert(__FieldTag::__cc_generic_services) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for cc_generic_services",
                                ));
                            }
                            result.cc_generic_services = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__java_generic_services => {
                            if !fields.insert(__FieldTag::__java_generic_services) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for java_generic_services",
                                ));
                            }
                            result.java_generic_services = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__py_generic_services => {
                            if !fields.insert(__FieldTag::__py_generic_services) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for py_generic_services",
                                ));
                            }
                            result.py_generic_services = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__deprecated => {
                            if !fields.insert(__FieldTag::__deprecated) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for deprecated",
                                ));
                            }
                            result.deprecated = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__cc_enable_arenas => {
                            if !fields.insert(__FieldTag::__cc_enable_arenas) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for cc_enable_arenas",
                                ));
                            }
                            result.cc_enable_arenas = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__objc_class_prefix => {
                            if !fields.insert(__FieldTag::__objc_class_prefix) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for objc_class_prefix",
                                ));
                            }
                            result.objc_class_prefix = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__csharp_namespace => {
                            if !fields.insert(__FieldTag::__csharp_namespace) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for csharp_namespace",
                                ));
                            }
                            result.csharp_namespace = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__swift_prefix => {
                            if !fields.insert(__FieldTag::__swift_prefix) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for swift_prefix",
                                ));
                            }
                            result.swift_prefix = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__php_class_prefix => {
                            if !fields.insert(__FieldTag::__php_class_prefix) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for php_class_prefix",
                                ));
                            }
                            result.php_class_prefix = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__php_namespace => {
                            if !fields.insert(__FieldTag::__php_namespace) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for php_namespace",
                                ));
                            }
                            result.php_namespace = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__php_metadata_namespace => {
                            if !fields.insert(__FieldTag::__php_metadata_namespace) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for php_metadata_namespace",
                                ));
                            }
                            result.php_metadata_namespace = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__ruby_package => {
                            if !fields.insert(__FieldTag::__ruby_package) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for ruby_package",
                                ));
                            }
                            result.ruby_package = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__features => {
                            if !fields.insert(__FieldTag::__features) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for features",
                                ));
                            }
                            result.features =
                                map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                        }
                        __FieldTag::__uninterpreted_option => {
                            if !fields.insert(__FieldTag::__uninterpreted_option) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for uninterpreted_option",
                                ));
                            }
                            result.uninterpreted_option = map.next_value::<std::option::Option<std::vec::Vec<crate::UninterpretedOption>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for FileOptions {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.java_package.is_empty() {
            state.serialize_entry("javaPackage", &self.java_package)?;
        }
        if !self.java_outer_classname.is_empty() {
            state.serialize_entry("javaOuterClassname", &self.java_outer_classname)?;
        }
        if !wkt::internal::is_default(&self.java_multiple_files) {
            state.serialize_entry("javaMultipleFiles", &self.java_multiple_files)?;
        }
        if !wkt::internal::is_default(&self.java_generate_equals_and_hash) {
            state.serialize_entry(
                "javaGenerateEqualsAndHash",
                &self.java_generate_equals_and_hash,
            )?;
        }
        if !wkt::internal::is_default(&self.java_string_check_utf8) {
            state.serialize_entry("javaStringCheckUtf8", &self.java_string_check_utf8)?;
        }
        if !wkt::internal::is_default(&self.optimize_for) {
            state.serialize_entry("optimizeFor", &self.optimize_for)?;
        }
        if !self.go_package.is_empty() {
            state.serialize_entry("goPackage", &self.go_package)?;
        }
        if !wkt::internal::is_default(&self.cc_generic_services) {
            state.serialize_entry("ccGenericServices", &self.cc_generic_services)?;
        }
        if !wkt::internal::is_default(&self.java_generic_services) {
            state.serialize_entry("javaGenericServices", &self.java_generic_services)?;
        }
        if !wkt::internal::is_default(&self.py_generic_services) {
            state.serialize_entry("pyGenericServices", &self.py_generic_services)?;
        }
        if !wkt::internal::is_default(&self.deprecated) {
            state.serialize_entry("deprecated", &self.deprecated)?;
        }
        if !wkt::internal::is_default(&self.cc_enable_arenas) {
            state.serialize_entry("ccEnableArenas", &self.cc_enable_arenas)?;
        }
        if !self.objc_class_prefix.is_empty() {
            state.serialize_entry("objcClassPrefix", &self.objc_class_prefix)?;
        }
        if !self.csharp_namespace.is_empty() {
            state.serialize_entry("csharpNamespace", &self.csharp_namespace)?;
        }
        if !self.swift_prefix.is_empty() {
            state.serialize_entry("swiftPrefix", &self.swift_prefix)?;
        }
        if !self.php_class_prefix.is_empty() {
            state.serialize_entry("phpClassPrefix", &self.php_class_prefix)?;
        }
        if !self.php_namespace.is_empty() {
            state.serialize_entry("phpNamespace", &self.php_namespace)?;
        }
        if !self.php_metadata_namespace.is_empty() {
            state.serialize_entry("phpMetadataNamespace", &self.php_metadata_namespace)?;
        }
        if !self.ruby_package.is_empty() {
            state.serialize_entry("rubyPackage", &self.ruby_package)?;
        }
        if self.features.is_some() {
            state.serialize_entry("features", &self.features)?;
        }
        if !self.uninterpreted_option.is_empty() {
            state.serialize_entry("uninterpretedOption", &self.uninterpreted_option)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for FileOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileOptions");
        debug_struct.field("java_package", &self.java_package);
        debug_struct.field("java_outer_classname", &self.java_outer_classname);
        debug_struct.field("java_multiple_files", &self.java_multiple_files);
        debug_struct.field(
            "java_generate_equals_and_hash",
            &self.java_generate_equals_and_hash,
        );
        debug_struct.field("java_string_check_utf8", &self.java_string_check_utf8);
        debug_struct.field("optimize_for", &self.optimize_for);
        debug_struct.field("go_package", &self.go_package);
        debug_struct.field("cc_generic_services", &self.cc_generic_services);
        debug_struct.field("java_generic_services", &self.java_generic_services);
        debug_struct.field("py_generic_services", &self.py_generic_services);
        debug_struct.field("deprecated", &self.deprecated);
        debug_struct.field("cc_enable_arenas", &self.cc_enable_arenas);
        debug_struct.field("objc_class_prefix", &self.objc_class_prefix);
        debug_struct.field("csharp_namespace", &self.csharp_namespace);
        debug_struct.field("swift_prefix", &self.swift_prefix);
        debug_struct.field("php_class_prefix", &self.php_class_prefix);
        debug_struct.field("php_namespace", &self.php_namespace);
        debug_struct.field("php_metadata_namespace", &self.php_metadata_namespace);
        debug_struct.field("ruby_package", &self.ruby_package);
        debug_struct.field("features", &self.features);
        debug_struct.field("uninterpreted_option", &self.uninterpreted_option);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [FileOptions].
pub mod file_options {
    #[allow(unused_imports)]
    use super::*;

    /// Generated classes can be optimized for speed or code size.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum OptimizeMode {
        Speed,
        /// etc.
        CodeSize,
        LiteRuntime,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [OptimizeMode::value] or
        /// [OptimizeMode::name].
        UnknownValue(optimize_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod optimize_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl OptimizeMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Speed => std::option::Option::Some(1),
                Self::CodeSize => std::option::Option::Some(2),
                Self::LiteRuntime => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Speed => std::option::Option::Some("SPEED"),
                Self::CodeSize => std::option::Option::Some("CODE_SIZE"),
                Self::LiteRuntime => std::option::Option::Some("LITE_RUNTIME"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for OptimizeMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for OptimizeMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for OptimizeMode {
        fn from(value: i32) -> Self {
            match value {
                1 => Self::Speed,
                2 => Self::CodeSize,
                3 => Self::LiteRuntime,
                _ => Self::UnknownValue(optimize_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for OptimizeMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "SPEED" => Self::Speed,
                "CODE_SIZE" => Self::CodeSize,
                "LITE_RUNTIME" => Self::LiteRuntime,
                _ => Self::UnknownValue(optimize_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for OptimizeMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Speed => serializer.serialize_i32(1),
                Self::CodeSize => serializer.serialize_i32(2),
                Self::LiteRuntime => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for OptimizeMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<OptimizeMode>::new(
                ".google.protobuf.FileOptions.OptimizeMode",
            ))
        }
    }
}

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MessageOptions {
    /// Set true to use the old proto1 MessageSet wire format for extensions.
    /// This is provided for backwards-compatibility with the MessageSet wire
    /// format.  You should not use this for any other reason:  It's less
    /// efficient, has fewer features, and is more complicated.
    ///
    /// The message must be defined exactly as follows:
    /// message Foo {
    /// option message_set_wire_format = true;
    /// extensions 4 to max;
    /// }
    /// Note that the message cannot have any defined fields; MessageSets only
    /// have extensions.
    ///
    /// All extensions of your type must be singular messages; e.g. they cannot
    /// be int32s, enums, or repeated messages.
    ///
    /// Because this is an option, the above two restrictions are not enforced by
    /// the protocol compiler.
    pub message_set_wire_format: bool,

    /// Disables the generation of the standard "descriptor()" accessor, which can
    /// conflict with a field of the same name.  This is meant to make migration
    /// from proto1 easier; new code should avoid fields named "descriptor".
    pub no_standard_descriptor_accessor: bool,

    /// Is this message deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for the message, or it will be completely ignored; in the very least,
    /// this is a formalization for deprecating messages.
    pub deprecated: bool,

    /// Whether the message is an automatically generated map entry type for the
    /// maps field.
    ///
    /// For maps fields:
    /// map<KeyType, ValueType> map_field = 1;
    /// The parsed descriptor looks like:
    /// message MapFieldEntry {
    /// option map_entry = true;
    /// optional KeyType key = 1;
    /// optional ValueType value = 2;
    /// }
    /// repeated MapFieldEntry map_field = 1;
    ///
    /// Implementations may choose not to generate the map_entry=true message, but
    /// use a native map in the target language to hold the keys and values.
    /// The reflection APIs in such implementations still need to work as
    /// if the field is a repeated message field.
    ///
    /// NOTE: Do not set the option in .proto files. Always use the maps syntax
    /// instead. The option should only be implicitly set by the proto compiler
    /// parser.
    pub map_entry: bool,

    /// Enable the legacy handling of JSON field name conflicts.  This lowercases
    /// and strips underscored from the fields before comparison in proto3 only.
    /// The new behavior takes `json_name` into account and applies to proto2 as
    /// well.
    ///
    /// This should only be used as a temporary measure against broken builds due
    /// to the change in behavior for JSON field name conflicts.
    ///
    /// TODO This is legacy behavior we plan to remove once downstream
    /// teams have had time to migrate.
    #[deprecated]
    pub deprecated_legacy_json_field_conflicts: bool,

    /// Any features defined in the specific edition.
    pub features: std::option::Option<crate::FeatureSet>,

    /// The parser stores options it doesn't recognize here. See above.
    pub uninterpreted_option: std::vec::Vec<crate::UninterpretedOption>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MessageOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [message_set_wire_format][crate::MessageOptions::message_set_wire_format].
    pub fn set_message_set_wire_format<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.message_set_wire_format = v.into();
        self
    }

    /// Sets the value of [no_standard_descriptor_accessor][crate::MessageOptions::no_standard_descriptor_accessor].
    pub fn set_no_standard_descriptor_accessor<T: std::convert::Into<bool>>(
        mut self,
        v: T,
    ) -> Self {
        self.no_standard_descriptor_accessor = v.into();
        self
    }

    /// Sets the value of [deprecated][crate::MessageOptions::deprecated].
    pub fn set_deprecated<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.deprecated = v.into();
        self
    }

    /// Sets the value of [map_entry][crate::MessageOptions::map_entry].
    pub fn set_map_entry<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.map_entry = v.into();
        self
    }

    /// Sets the value of [deprecated_legacy_json_field_conflicts][crate::MessageOptions::deprecated_legacy_json_field_conflicts].
    #[deprecated]
    pub fn set_deprecated_legacy_json_field_conflicts<T: std::convert::Into<bool>>(
        mut self,
        v: T,
    ) -> Self {
        self.deprecated_legacy_json_field_conflicts = v.into();
        self
    }

    /// Sets the value of [features][crate::MessageOptions::features].
    pub fn set_features<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [features][crate::MessageOptions::features].
    pub fn set_or_clear_features<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = v.map(|x| x.into());
        self
    }

    /// Sets the value of [uninterpreted_option][crate::MessageOptions::uninterpreted_option].
    pub fn set_uninterpreted_option<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::UninterpretedOption>,
    {
        use std::iter::Iterator;
        self.uninterpreted_option = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for MessageOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.MessageOptions"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for MessageOptions {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __message_set_wire_format,
            __no_standard_descriptor_accessor,
            __deprecated,
            __map_entry,
            __deprecated_legacy_json_field_conflicts,
            __features,
            __uninterpreted_option,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for MessageOptions")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "messageSetWireFormat" => Ok(__FieldTag::__message_set_wire_format),
                            "message_set_wire_format" => Ok(__FieldTag::__message_set_wire_format),
                            "noStandardDescriptorAccessor" => {
                                Ok(__FieldTag::__no_standard_descriptor_accessor)
                            }
                            "no_standard_descriptor_accessor" => {
                                Ok(__FieldTag::__no_standard_descriptor_accessor)
                            }
                            "deprecated" => Ok(__FieldTag::__deprecated),
                            "mapEntry" => Ok(__FieldTag::__map_entry),
                            "map_entry" => Ok(__FieldTag::__map_entry),
                            "deprecatedLegacyJsonFieldConflicts" => {
                                Ok(__FieldTag::__deprecated_legacy_json_field_conflicts)
                            }
                            "deprecated_legacy_json_field_conflicts" => {
                                Ok(__FieldTag::__deprecated_legacy_json_field_conflicts)
                            }
                            "features" => Ok(__FieldTag::__features),
                            "uninterpretedOption" => Ok(__FieldTag::__uninterpreted_option),
                            "uninterpreted_option" => Ok(__FieldTag::__uninterpreted_option),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = MessageOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct MessageOptions")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__message_set_wire_format => {
                            if !fields.insert(__FieldTag::__message_set_wire_format) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for message_set_wire_format",
                                ));
                            }
                            result.message_set_wire_format = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__no_standard_descriptor_accessor => {
                            if !fields.insert(__FieldTag::__no_standard_descriptor_accessor) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for no_standard_descriptor_accessor",
                                ));
                            }
                            result.no_standard_descriptor_accessor = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__deprecated => {
                            if !fields.insert(__FieldTag::__deprecated) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for deprecated",
                                ));
                            }
                            result.deprecated = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__map_entry => {
                            if !fields.insert(__FieldTag::__map_entry) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for map_entry",
                                ));
                            }
                            result.map_entry = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__deprecated_legacy_json_field_conflicts => {
                            if !fields.insert(__FieldTag::__deprecated_legacy_json_field_conflicts)
                            {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for deprecated_legacy_json_field_conflicts",
                                ));
                            }
                            result.deprecated_legacy_json_field_conflicts = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__features => {
                            if !fields.insert(__FieldTag::__features) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for features",
                                ));
                            }
                            result.features =
                                map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                        }
                        __FieldTag::__uninterpreted_option => {
                            if !fields.insert(__FieldTag::__uninterpreted_option) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for uninterpreted_option",
                                ));
                            }
                            result.uninterpreted_option = map.next_value::<std::option::Option<std::vec::Vec<crate::UninterpretedOption>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for MessageOptions {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.message_set_wire_format) {
            state.serialize_entry("messageSetWireFormat", &self.message_set_wire_format)?;
        }
        if !wkt::internal::is_default(&self.no_standard_descriptor_accessor) {
            state.serialize_entry(
                "noStandardDescriptorAccessor",
                &self.no_standard_descriptor_accessor,
            )?;
        }
        if !wkt::internal::is_default(&self.deprecated) {
            state.serialize_entry("deprecated", &self.deprecated)?;
        }
        if !wkt::internal::is_default(&self.map_entry) {
            state.serialize_entry("mapEntry", &self.map_entry)?;
        }
        if !wkt::internal::is_default(&self.deprecated_legacy_json_field_conflicts) {
            state.serialize_entry(
                "deprecatedLegacyJsonFieldConflicts",
                &self.deprecated_legacy_json_field_conflicts,
            )?;
        }
        if self.features.is_some() {
            state.serialize_entry("features", &self.features)?;
        }
        if !self.uninterpreted_option.is_empty() {
            state.serialize_entry("uninterpretedOption", &self.uninterpreted_option)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for MessageOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MessageOptions");
        debug_struct.field("message_set_wire_format", &self.message_set_wire_format);
        debug_struct.field(
            "no_standard_descriptor_accessor",
            &self.no_standard_descriptor_accessor,
        );
        debug_struct.field("deprecated", &self.deprecated);
        debug_struct.field("map_entry", &self.map_entry);
        debug_struct.field(
            "deprecated_legacy_json_field_conflicts",
            &self.deprecated_legacy_json_field_conflicts,
        );
        debug_struct.field("features", &self.features);
        debug_struct.field("uninterpreted_option", &self.uninterpreted_option);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FieldOptions {
    /// NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead.
    /// The ctype option instructs the C++ code generator to use a different
    /// representation of the field than it normally would.  See the specific
    /// options below.  This option is only implemented to support use of
    /// [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of
    /// type "bytes" in the open source release.
    /// TODO: make ctype actually deprecated.
    pub ctype: crate::field_options::CType,

    /// The packed option can be enabled for repeated primitive fields to enable
    /// a more efficient representation on the wire. Rather than repeatedly
    /// writing the tag and type for each element, the entire array is encoded as
    /// a single length-delimited blob. In proto3, only explicit setting it to
    /// false will avoid using packed encoding.  This option is prohibited in
    /// Editions, but the `repeated_field_encoding` feature can be used to control
    /// the behavior.
    pub packed: bool,

    /// The jstype option determines the JavaScript type used for values of the
    /// field.  The option is permitted only for 64 bit integral and fixed types
    /// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
    /// is represented as JavaScript string, which avoids loss of precision that
    /// can happen when a large value is converted to a floating point JavaScript.
    /// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
    /// use the JavaScript "number" type.  The behavior of the default option
    /// JS_NORMAL is implementation dependent.
    ///
    /// This option is an enum to permit additional types to be added, e.g.
    /// goog.math.Integer.
    pub jstype: crate::field_options::JSType,

    /// Should this field be parsed lazily?  Lazy applies only to message-type
    /// fields.  It means that when the outer message is initially parsed, the
    /// inner message's contents will not be parsed but instead stored in encoded
    /// form.  The inner message will actually be parsed when it is first accessed.
    ///
    /// This is only a hint.  Implementations are free to choose whether to use
    /// eager or lazy parsing regardless of the value of this option.  However,
    /// setting this option true suggests that the protocol author believes that
    /// using lazy parsing on this field is worth the additional bookkeeping
    /// overhead typically needed to implement it.
    ///
    /// This option does not affect the public interface of any generated code;
    /// all method signatures remain the same.  Furthermore, thread-safety of the
    /// interface is not affected by this option; const methods remain safe to
    /// call from multiple threads concurrently, while non-const methods continue
    /// to require exclusive access.
    ///
    /// Note that lazy message fields are still eagerly verified to check
    /// ill-formed wireformat or missing required fields. Calling IsInitialized()
    /// on the outer message would fail if the inner message has missing required
    /// fields. Failed verification would result in parsing failure (except when
    /// uninitialized messages are acceptable).
    pub lazy: bool,

    /// unverified_lazy does no correctness checks on the byte stream. This should
    /// only be used where lazy with verification is prohibitive for performance
    /// reasons.
    pub unverified_lazy: bool,

    /// Is this field deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for accessors, or it will be completely ignored; in the very least, this
    /// is a formalization for deprecating fields.
    pub deprecated: bool,

    /// For Google-internal migration only. Do not use.
    pub weak: bool,

    /// Indicate that the field value should not be printed out when using debug
    /// formats, e.g. when the field contains sensitive credentials.
    pub debug_redact: bool,

    pub retention: crate::field_options::OptionRetention,

    pub targets: std::vec::Vec<crate::field_options::OptionTargetType>,

    pub edition_defaults: std::vec::Vec<crate::field_options::EditionDefault>,

    /// Any features defined in the specific edition.
    pub features: std::option::Option<crate::FeatureSet>,

    pub feature_support: std::option::Option<crate::field_options::FeatureSupport>,

    /// The parser stores options it doesn't recognize here. See above.
    pub uninterpreted_option: std::vec::Vec<crate::UninterpretedOption>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FieldOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [ctype][crate::FieldOptions::ctype].
    pub fn set_ctype<T: std::convert::Into<crate::field_options::CType>>(mut self, v: T) -> Self {
        self.ctype = v.into();
        self
    }

    /// Sets the value of [packed][crate::FieldOptions::packed].
    pub fn set_packed<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.packed = v.into();
        self
    }

    /// Sets the value of [jstype][crate::FieldOptions::jstype].
    pub fn set_jstype<T: std::convert::Into<crate::field_options::JSType>>(mut self, v: T) -> Self {
        self.jstype = v.into();
        self
    }

    /// Sets the value of [lazy][crate::FieldOptions::lazy].
    pub fn set_lazy<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.lazy = v.into();
        self
    }

    /// Sets the value of [unverified_lazy][crate::FieldOptions::unverified_lazy].
    pub fn set_unverified_lazy<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.unverified_lazy = v.into();
        self
    }

    /// Sets the value of [deprecated][crate::FieldOptions::deprecated].
    pub fn set_deprecated<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.deprecated = v.into();
        self
    }

    /// Sets the value of [weak][crate::FieldOptions::weak].
    pub fn set_weak<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.weak = v.into();
        self
    }

    /// Sets the value of [debug_redact][crate::FieldOptions::debug_redact].
    pub fn set_debug_redact<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.debug_redact = v.into();
        self
    }

    /// Sets the value of [retention][crate::FieldOptions::retention].
    pub fn set_retention<T: std::convert::Into<crate::field_options::OptionRetention>>(
        mut self,
        v: T,
    ) -> Self {
        self.retention = v.into();
        self
    }

    /// Sets the value of [targets][crate::FieldOptions::targets].
    pub fn set_targets<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::field_options::OptionTargetType>,
    {
        use std::iter::Iterator;
        self.targets = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [edition_defaults][crate::FieldOptions::edition_defaults].
    pub fn set_edition_defaults<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::field_options::EditionDefault>,
    {
        use std::iter::Iterator;
        self.edition_defaults = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [features][crate::FieldOptions::features].
    pub fn set_features<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [features][crate::FieldOptions::features].
    pub fn set_or_clear_features<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = v.map(|x| x.into());
        self
    }

    /// Sets the value of [feature_support][crate::FieldOptions::feature_support].
    pub fn set_feature_support<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::field_options::FeatureSupport>,
    {
        self.feature_support = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [feature_support][crate::FieldOptions::feature_support].
    pub fn set_or_clear_feature_support<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::field_options::FeatureSupport>,
    {
        self.feature_support = v.map(|x| x.into());
        self
    }

    /// Sets the value of [uninterpreted_option][crate::FieldOptions::uninterpreted_option].
    pub fn set_uninterpreted_option<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::UninterpretedOption>,
    {
        use std::iter::Iterator;
        self.uninterpreted_option = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for FieldOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.FieldOptions"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for FieldOptions {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __ctype,
            __packed,
            __jstype,
            __lazy,
            __unverified_lazy,
            __deprecated,
            __weak,
            __debug_redact,
            __retention,
            __targets,
            __edition_defaults,
            __features,
            __feature_support,
            __uninterpreted_option,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for FieldOptions")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "ctype" => Ok(__FieldTag::__ctype),
                            "packed" => Ok(__FieldTag::__packed),
                            "jstype" => Ok(__FieldTag::__jstype),
                            "lazy" => Ok(__FieldTag::__lazy),
                            "unverifiedLazy" => Ok(__FieldTag::__unverified_lazy),
                            "unverified_lazy" => Ok(__FieldTag::__unverified_lazy),
                            "deprecated" => Ok(__FieldTag::__deprecated),
                            "weak" => Ok(__FieldTag::__weak),
                            "debugRedact" => Ok(__FieldTag::__debug_redact),
                            "debug_redact" => Ok(__FieldTag::__debug_redact),
                            "retention" => Ok(__FieldTag::__retention),
                            "targets" => Ok(__FieldTag::__targets),
                            "editionDefaults" => Ok(__FieldTag::__edition_defaults),
                            "edition_defaults" => Ok(__FieldTag::__edition_defaults),
                            "features" => Ok(__FieldTag::__features),
                            "featureSupport" => Ok(__FieldTag::__feature_support),
                            "feature_support" => Ok(__FieldTag::__feature_support),
                            "uninterpretedOption" => Ok(__FieldTag::__uninterpreted_option),
                            "uninterpreted_option" => Ok(__FieldTag::__uninterpreted_option),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = FieldOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct FieldOptions")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__ctype => {
                            if !fields.insert(__FieldTag::__ctype) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for ctype",
                                ));
                            }
                            result.ctype = map
                                .next_value::<std::option::Option<crate::field_options::CType>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__packed => {
                            if !fields.insert(__FieldTag::__packed) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for packed",
                                ));
                            }
                            result.packed = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__jstype => {
                            if !fields.insert(__FieldTag::__jstype) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for jstype",
                                ));
                            }
                            result.jstype = map
                                .next_value::<std::option::Option<crate::field_options::JSType>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__lazy => {
                            if !fields.insert(__FieldTag::__lazy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for lazy",
                                ));
                            }
                            result.lazy = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__unverified_lazy => {
                            if !fields.insert(__FieldTag::__unverified_lazy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for unverified_lazy",
                                ));
                            }
                            result.unverified_lazy = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__deprecated => {
                            if !fields.insert(__FieldTag::__deprecated) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for deprecated",
                                ));
                            }
                            result.deprecated = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__weak => {
                            if !fields.insert(__FieldTag::__weak) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for weak",
                                ));
                            }
                            result.weak = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__debug_redact => {
                            if !fields.insert(__FieldTag::__debug_redact) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for debug_redact",
                                ));
                            }
                            result.debug_redact = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__retention => {
                            if !fields.insert(__FieldTag::__retention) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for retention",
                                ));
                            }
                            result.retention = map.next_value::<std::option::Option<crate::field_options::OptionRetention>>()?.unwrap_or_default();
                        }
                        __FieldTag::__targets => {
                            if !fields.insert(__FieldTag::__targets) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for targets",
                                ));
                            }
                            result.targets = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::field_options::OptionTargetType>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__edition_defaults => {
                            if !fields.insert(__FieldTag::__edition_defaults) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for edition_defaults",
                                ));
                            }
                            result.edition_defaults = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::field_options::EditionDefault>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__features => {
                            if !fields.insert(__FieldTag::__features) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for features",
                                ));
                            }
                            result.features =
                                map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                        }
                        __FieldTag::__feature_support => {
                            if !fields.insert(__FieldTag::__feature_support) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for feature_support",
                                ));
                            }
                            result.feature_support = map.next_value::<std::option::Option<crate::field_options::FeatureSupport>>()?
                                ;
                        }
                        __FieldTag::__uninterpreted_option => {
                            if !fields.insert(__FieldTag::__uninterpreted_option) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for uninterpreted_option",
                                ));
                            }
                            result.uninterpreted_option = map.next_value::<std::option::Option<std::vec::Vec<crate::UninterpretedOption>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for FieldOptions {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.ctype) {
            state.serialize_entry("ctype", &self.ctype)?;
        }
        if !wkt::internal::is_default(&self.packed) {
            state.serialize_entry("packed", &self.packed)?;
        }
        if !wkt::internal::is_default(&self.jstype) {
            state.serialize_entry("jstype", &self.jstype)?;
        }
        if !wkt::internal::is_default(&self.lazy) {
            state.serialize_entry("lazy", &self.lazy)?;
        }
        if !wkt::internal::is_default(&self.unverified_lazy) {
            state.serialize_entry("unverifiedLazy", &self.unverified_lazy)?;
        }
        if !wkt::internal::is_default(&self.deprecated) {
            state.serialize_entry("deprecated", &self.deprecated)?;
        }
        if !wkt::internal::is_default(&self.weak) {
            state.serialize_entry("weak", &self.weak)?;
        }
        if !wkt::internal::is_default(&self.debug_redact) {
            state.serialize_entry("debugRedact", &self.debug_redact)?;
        }
        if !wkt::internal::is_default(&self.retention) {
            state.serialize_entry("retention", &self.retention)?;
        }
        if !self.targets.is_empty() {
            state.serialize_entry("targets", &self.targets)?;
        }
        if !self.edition_defaults.is_empty() {
            state.serialize_entry("editionDefaults", &self.edition_defaults)?;
        }
        if self.features.is_some() {
            state.serialize_entry("features", &self.features)?;
        }
        if self.feature_support.is_some() {
            state.serialize_entry("featureSupport", &self.feature_support)?;
        }
        if !self.uninterpreted_option.is_empty() {
            state.serialize_entry("uninterpretedOption", &self.uninterpreted_option)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for FieldOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FieldOptions");
        debug_struct.field("ctype", &self.ctype);
        debug_struct.field("packed", &self.packed);
        debug_struct.field("jstype", &self.jstype);
        debug_struct.field("lazy", &self.lazy);
        debug_struct.field("unverified_lazy", &self.unverified_lazy);
        debug_struct.field("deprecated", &self.deprecated);
        debug_struct.field("weak", &self.weak);
        debug_struct.field("debug_redact", &self.debug_redact);
        debug_struct.field("retention", &self.retention);
        debug_struct.field("targets", &self.targets);
        debug_struct.field("edition_defaults", &self.edition_defaults);
        debug_struct.field("features", &self.features);
        debug_struct.field("feature_support", &self.feature_support);
        debug_struct.field("uninterpreted_option", &self.uninterpreted_option);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [FieldOptions].
pub mod field_options {
    #[allow(unused_imports)]
    use super::*;

    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct EditionDefault {
        pub edition: crate::Edition,

        pub value: std::string::String,

        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl EditionDefault {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [edition][crate::field_options::EditionDefault::edition].
        pub fn set_edition<T: std::convert::Into<crate::Edition>>(mut self, v: T) -> Self {
            self.edition = v.into();
            self
        }

        /// Sets the value of [value][crate::field_options::EditionDefault::value].
        pub fn set_value<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.value = v.into();
            self
        }
    }

    impl wkt::message::Message for EditionDefault {
        fn typename() -> &'static str {
            "type.googleapis.com/google.protobuf.FieldOptions.EditionDefault"
        }
    }

    #[doc(hidden)]
    impl<'de> serde::de::Deserialize<'de> for EditionDefault {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            #[allow(non_camel_case_types)]
            #[doc(hidden)]
            #[derive(PartialEq, Eq, Hash)]
            enum __FieldTag {
                __edition,
                __value,
                Unknown(std::string::String),
            }
            impl<'de> serde::de::Deserialize<'de> for __FieldTag {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    struct Visitor;
                    impl<'de> serde::de::Visitor<'de> for Visitor {
                        type Value = __FieldTag;
                        fn expecting(
                            &self,
                            formatter: &mut std::fmt::Formatter,
                        ) -> std::fmt::Result {
                            formatter.write_str("a field name for EditionDefault")
                        }
                        fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                        where
                            E: serde::de::Error,
                        {
                            use std::result::Result::Ok;
                            use std::string::ToString;
                            match value {
                                "edition" => Ok(__FieldTag::__edition),
                                "value" => Ok(__FieldTag::__value),
                                _ => Ok(__FieldTag::Unknown(value.to_string())),
                            }
                        }
                    }
                    deserializer.deserialize_identifier(Visitor)
                }
            }
            struct Visitor;
            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = EditionDefault;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct EditionDefault")
                }
                fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
                where
                    A: serde::de::MapAccess<'de>,
                {
                    #[allow(unused_imports)]
                    use serde::de::Error;
                    use std::option::Option::Some;
                    let mut fields = std::collections::HashSet::new();
                    let mut result = Self::Value::new();
                    while let Some(tag) = map.next_key::<__FieldTag>()? {
                        #[allow(clippy::match_single_binding)]
                        match tag {
                            __FieldTag::__edition => {
                                if !fields.insert(__FieldTag::__edition) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for edition",
                                    ));
                                }
                                result.edition = map
                                    .next_value::<std::option::Option<crate::Edition>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__value => {
                                if !fields.insert(__FieldTag::__value) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for value",
                                    ));
                                }
                                result.value = map
                                    .next_value::<std::option::Option<std::string::String>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::Unknown(key) => {
                                let value = map.next_value::<serde_json::Value>()?;
                                result._unknown_fields.insert(key, value);
                            }
                        }
                    }
                    std::result::Result::Ok(result)
                }
            }
            deserializer.deserialize_any(Visitor)
        }
    }

    #[doc(hidden)]
    impl serde::ser::Serialize for EditionDefault {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
        {
            use serde::ser::SerializeMap;
            #[allow(unused_imports)]
            use std::option::Option::Some;
            let mut state = serializer.serialize_map(std::option::Option::None)?;
            if !wkt::internal::is_default(&self.edition) {
                state.serialize_entry("edition", &self.edition)?;
            }
            if !self.value.is_empty() {
                state.serialize_entry("value", &self.value)?;
            }
            if !self._unknown_fields.is_empty() {
                for (key, value) in self._unknown_fields.iter() {
                    state.serialize_entry(key, &value)?;
                }
            }
            state.end()
        }
    }

    impl std::fmt::Debug for EditionDefault {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut debug_struct = f.debug_struct("EditionDefault");
            debug_struct.field("edition", &self.edition);
            debug_struct.field("value", &self.value);
            if !self._unknown_fields.is_empty() {
                debug_struct.field("_unknown_fields", &self._unknown_fields);
            }
            debug_struct.finish()
        }
    }

    /// Information about the support window of a feature.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct FeatureSupport {
        /// The edition that this feature was first available in.  In editions
        /// earlier than this one, the default assigned to EDITION_LEGACY will be
        /// used, and proto files will not be able to override it.
        pub edition_introduced: crate::Edition,

        /// The edition this feature becomes deprecated in.  Using this after this
        /// edition may trigger warnings.
        pub edition_deprecated: crate::Edition,

        /// The deprecation warning text if this feature is used after the edition it
        /// was marked deprecated in.
        pub deprecation_warning: std::string::String,

        /// The edition this feature is no longer available in.  In editions after
        /// this one, the last default assigned will be used, and proto files will
        /// not be able to override it.
        pub edition_removed: crate::Edition,

        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl FeatureSupport {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [edition_introduced][crate::field_options::FeatureSupport::edition_introduced].
        pub fn set_edition_introduced<T: std::convert::Into<crate::Edition>>(
            mut self,
            v: T,
        ) -> Self {
            self.edition_introduced = v.into();
            self
        }

        /// Sets the value of [edition_deprecated][crate::field_options::FeatureSupport::edition_deprecated].
        pub fn set_edition_deprecated<T: std::convert::Into<crate::Edition>>(
            mut self,
            v: T,
        ) -> Self {
            self.edition_deprecated = v.into();
            self
        }

        /// Sets the value of [deprecation_warning][crate::field_options::FeatureSupport::deprecation_warning].
        pub fn set_deprecation_warning<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.deprecation_warning = v.into();
            self
        }

        /// Sets the value of [edition_removed][crate::field_options::FeatureSupport::edition_removed].
        pub fn set_edition_removed<T: std::convert::Into<crate::Edition>>(mut self, v: T) -> Self {
            self.edition_removed = v.into();
            self
        }
    }

    impl wkt::message::Message for FeatureSupport {
        fn typename() -> &'static str {
            "type.googleapis.com/google.protobuf.FieldOptions.FeatureSupport"
        }
    }

    #[doc(hidden)]
    impl<'de> serde::de::Deserialize<'de> for FeatureSupport {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            #[allow(non_camel_case_types)]
            #[doc(hidden)]
            #[derive(PartialEq, Eq, Hash)]
            enum __FieldTag {
                __edition_introduced,
                __edition_deprecated,
                __deprecation_warning,
                __edition_removed,
                Unknown(std::string::String),
            }
            impl<'de> serde::de::Deserialize<'de> for __FieldTag {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    struct Visitor;
                    impl<'de> serde::de::Visitor<'de> for Visitor {
                        type Value = __FieldTag;
                        fn expecting(
                            &self,
                            formatter: &mut std::fmt::Formatter,
                        ) -> std::fmt::Result {
                            formatter.write_str("a field name for FeatureSupport")
                        }
                        fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                        where
                            E: serde::de::Error,
                        {
                            use std::result::Result::Ok;
                            use std::string::ToString;
                            match value {
                                "editionIntroduced" => Ok(__FieldTag::__edition_introduced),
                                "edition_introduced" => Ok(__FieldTag::__edition_introduced),
                                "editionDeprecated" => Ok(__FieldTag::__edition_deprecated),
                                "edition_deprecated" => Ok(__FieldTag::__edition_deprecated),
                                "deprecationWarning" => Ok(__FieldTag::__deprecation_warning),
                                "deprecation_warning" => Ok(__FieldTag::__deprecation_warning),
                                "editionRemoved" => Ok(__FieldTag::__edition_removed),
                                "edition_removed" => Ok(__FieldTag::__edition_removed),
                                _ => Ok(__FieldTag::Unknown(value.to_string())),
                            }
                        }
                    }
                    deserializer.deserialize_identifier(Visitor)
                }
            }
            struct Visitor;
            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = FeatureSupport;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct FeatureSupport")
                }
                fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
                where
                    A: serde::de::MapAccess<'de>,
                {
                    #[allow(unused_imports)]
                    use serde::de::Error;
                    use std::option::Option::Some;
                    let mut fields = std::collections::HashSet::new();
                    let mut result = Self::Value::new();
                    while let Some(tag) = map.next_key::<__FieldTag>()? {
                        #[allow(clippy::match_single_binding)]
                        match tag {
                            __FieldTag::__edition_introduced => {
                                if !fields.insert(__FieldTag::__edition_introduced) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for edition_introduced",
                                    ));
                                }
                                result.edition_introduced = map
                                    .next_value::<std::option::Option<crate::Edition>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__edition_deprecated => {
                                if !fields.insert(__FieldTag::__edition_deprecated) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for edition_deprecated",
                                    ));
                                }
                                result.edition_deprecated = map
                                    .next_value::<std::option::Option<crate::Edition>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__deprecation_warning => {
                                if !fields.insert(__FieldTag::__deprecation_warning) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for deprecation_warning",
                                    ));
                                }
                                result.deprecation_warning = map
                                    .next_value::<std::option::Option<std::string::String>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__edition_removed => {
                                if !fields.insert(__FieldTag::__edition_removed) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for edition_removed",
                                    ));
                                }
                                result.edition_removed = map
                                    .next_value::<std::option::Option<crate::Edition>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::Unknown(key) => {
                                let value = map.next_value::<serde_json::Value>()?;
                                result._unknown_fields.insert(key, value);
                            }
                        }
                    }
                    std::result::Result::Ok(result)
                }
            }
            deserializer.deserialize_any(Visitor)
        }
    }

    #[doc(hidden)]
    impl serde::ser::Serialize for FeatureSupport {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
        {
            use serde::ser::SerializeMap;
            #[allow(unused_imports)]
            use std::option::Option::Some;
            let mut state = serializer.serialize_map(std::option::Option::None)?;
            if !wkt::internal::is_default(&self.edition_introduced) {
                state.serialize_entry("editionIntroduced", &self.edition_introduced)?;
            }
            if !wkt::internal::is_default(&self.edition_deprecated) {
                state.serialize_entry("editionDeprecated", &self.edition_deprecated)?;
            }
            if !self.deprecation_warning.is_empty() {
                state.serialize_entry("deprecationWarning", &self.deprecation_warning)?;
            }
            if !wkt::internal::is_default(&self.edition_removed) {
                state.serialize_entry("editionRemoved", &self.edition_removed)?;
            }
            if !self._unknown_fields.is_empty() {
                for (key, value) in self._unknown_fields.iter() {
                    state.serialize_entry(key, &value)?;
                }
            }
            state.end()
        }
    }

    impl std::fmt::Debug for FeatureSupport {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut debug_struct = f.debug_struct("FeatureSupport");
            debug_struct.field("edition_introduced", &self.edition_introduced);
            debug_struct.field("edition_deprecated", &self.edition_deprecated);
            debug_struct.field("deprecation_warning", &self.deprecation_warning);
            debug_struct.field("edition_removed", &self.edition_removed);
            if !self._unknown_fields.is_empty() {
                debug_struct.field("_unknown_fields", &self._unknown_fields);
            }
            debug_struct.finish()
        }
    }

    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum CType {
        /// Default mode.
        String,
        /// The option [ctype=CORD] may be applied to a non-repeated field of type
        /// "bytes". It indicates that in C++, the data should be stored in a Cord
        /// instead of a string.  For very large strings, this may reduce memory
        /// fragmentation. It may also allow better performance when parsing from a
        /// Cord, or when parsing with aliasing enabled, as the parsed Cord may then
        /// alias the original buffer.
        Cord,
        StringPiece,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [CType::value] or
        /// [CType::name].
        UnknownValue(c_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod c_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl CType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::String => std::option::Option::Some(0),
                Self::Cord => std::option::Option::Some(1),
                Self::StringPiece => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::String => std::option::Option::Some("STRING"),
                Self::Cord => std::option::Option::Some("CORD"),
                Self::StringPiece => std::option::Option::Some("STRING_PIECE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for CType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for CType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for CType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::String,
                1 => Self::Cord,
                2 => Self::StringPiece,
                _ => Self::UnknownValue(c_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for CType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STRING" => Self::String,
                "CORD" => Self::Cord,
                "STRING_PIECE" => Self::StringPiece,
                _ => Self::UnknownValue(c_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for CType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::String => serializer.serialize_i32(0),
                Self::Cord => serializer.serialize_i32(1),
                Self::StringPiece => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for CType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<CType>::new(
                ".google.protobuf.FieldOptions.CType",
            ))
        }
    }

    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum JSType {
        /// Use the default type.
        JsNormal,
        /// Use JavaScript strings.
        JsString,
        /// Use JavaScript numbers.
        JsNumber,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [JSType::value] or
        /// [JSType::name].
        UnknownValue(js_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod js_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl JSType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::JsNormal => std::option::Option::Some(0),
                Self::JsString => std::option::Option::Some(1),
                Self::JsNumber => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::JsNormal => std::option::Option::Some("JS_NORMAL"),
                Self::JsString => std::option::Option::Some("JS_STRING"),
                Self::JsNumber => std::option::Option::Some("JS_NUMBER"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for JSType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for JSType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for JSType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::JsNormal,
                1 => Self::JsString,
                2 => Self::JsNumber,
                _ => Self::UnknownValue(js_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for JSType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "JS_NORMAL" => Self::JsNormal,
                "JS_STRING" => Self::JsString,
                "JS_NUMBER" => Self::JsNumber,
                _ => Self::UnknownValue(js_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for JSType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::JsNormal => serializer.serialize_i32(0),
                Self::JsString => serializer.serialize_i32(1),
                Self::JsNumber => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for JSType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<JSType>::new(
                ".google.protobuf.FieldOptions.JSType",
            ))
        }
    }

    /// If set to RETENTION_SOURCE, the option will be omitted from the binary.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum OptionRetention {
        RetentionUnknown,
        RetentionRuntime,
        RetentionSource,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [OptionRetention::value] or
        /// [OptionRetention::name].
        UnknownValue(option_retention::UnknownValue),
    }

    #[doc(hidden)]
    pub mod option_retention {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl OptionRetention {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::RetentionUnknown => std::option::Option::Some(0),
                Self::RetentionRuntime => std::option::Option::Some(1),
                Self::RetentionSource => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::RetentionUnknown => std::option::Option::Some("RETENTION_UNKNOWN"),
                Self::RetentionRuntime => std::option::Option::Some("RETENTION_RUNTIME"),
                Self::RetentionSource => std::option::Option::Some("RETENTION_SOURCE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for OptionRetention {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for OptionRetention {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for OptionRetention {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::RetentionUnknown,
                1 => Self::RetentionRuntime,
                2 => Self::RetentionSource,
                _ => Self::UnknownValue(option_retention::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for OptionRetention {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "RETENTION_UNKNOWN" => Self::RetentionUnknown,
                "RETENTION_RUNTIME" => Self::RetentionRuntime,
                "RETENTION_SOURCE" => Self::RetentionSource,
                _ => Self::UnknownValue(option_retention::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for OptionRetention {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::RetentionUnknown => serializer.serialize_i32(0),
                Self::RetentionRuntime => serializer.serialize_i32(1),
                Self::RetentionSource => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for OptionRetention {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<OptionRetention>::new(
                ".google.protobuf.FieldOptions.OptionRetention",
            ))
        }
    }

    /// This indicates the types of entities that the field may apply to when used
    /// as an option. If it is unset, then the field may be freely used as an
    /// option on any kind of entity.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum OptionTargetType {
        TargetTypeUnknown,
        TargetTypeFile,
        TargetTypeExtensionRange,
        TargetTypeMessage,
        TargetTypeField,
        TargetTypeOneof,
        TargetTypeEnum,
        TargetTypeEnumEntry,
        TargetTypeService,
        TargetTypeMethod,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [OptionTargetType::value] or
        /// [OptionTargetType::name].
        UnknownValue(option_target_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod option_target_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl OptionTargetType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::TargetTypeUnknown => std::option::Option::Some(0),
                Self::TargetTypeFile => std::option::Option::Some(1),
                Self::TargetTypeExtensionRange => std::option::Option::Some(2),
                Self::TargetTypeMessage => std::option::Option::Some(3),
                Self::TargetTypeField => std::option::Option::Some(4),
                Self::TargetTypeOneof => std::option::Option::Some(5),
                Self::TargetTypeEnum => std::option::Option::Some(6),
                Self::TargetTypeEnumEntry => std::option::Option::Some(7),
                Self::TargetTypeService => std::option::Option::Some(8),
                Self::TargetTypeMethod => std::option::Option::Some(9),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::TargetTypeUnknown => std::option::Option::Some("TARGET_TYPE_UNKNOWN"),
                Self::TargetTypeFile => std::option::Option::Some("TARGET_TYPE_FILE"),
                Self::TargetTypeExtensionRange => {
                    std::option::Option::Some("TARGET_TYPE_EXTENSION_RANGE")
                }
                Self::TargetTypeMessage => std::option::Option::Some("TARGET_TYPE_MESSAGE"),
                Self::TargetTypeField => std::option::Option::Some("TARGET_TYPE_FIELD"),
                Self::TargetTypeOneof => std::option::Option::Some("TARGET_TYPE_ONEOF"),
                Self::TargetTypeEnum => std::option::Option::Some("TARGET_TYPE_ENUM"),
                Self::TargetTypeEnumEntry => std::option::Option::Some("TARGET_TYPE_ENUM_ENTRY"),
                Self::TargetTypeService => std::option::Option::Some("TARGET_TYPE_SERVICE"),
                Self::TargetTypeMethod => std::option::Option::Some("TARGET_TYPE_METHOD"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for OptionTargetType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for OptionTargetType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for OptionTargetType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::TargetTypeUnknown,
                1 => Self::TargetTypeFile,
                2 => Self::TargetTypeExtensionRange,
                3 => Self::TargetTypeMessage,
                4 => Self::TargetTypeField,
                5 => Self::TargetTypeOneof,
                6 => Self::TargetTypeEnum,
                7 => Self::TargetTypeEnumEntry,
                8 => Self::TargetTypeService,
                9 => Self::TargetTypeMethod,
                _ => Self::UnknownValue(option_target_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for OptionTargetType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TARGET_TYPE_UNKNOWN" => Self::TargetTypeUnknown,
                "TARGET_TYPE_FILE" => Self::TargetTypeFile,
                "TARGET_TYPE_EXTENSION_RANGE" => Self::TargetTypeExtensionRange,
                "TARGET_TYPE_MESSAGE" => Self::TargetTypeMessage,
                "TARGET_TYPE_FIELD" => Self::TargetTypeField,
                "TARGET_TYPE_ONEOF" => Self::TargetTypeOneof,
                "TARGET_TYPE_ENUM" => Self::TargetTypeEnum,
                "TARGET_TYPE_ENUM_ENTRY" => Self::TargetTypeEnumEntry,
                "TARGET_TYPE_SERVICE" => Self::TargetTypeService,
                "TARGET_TYPE_METHOD" => Self::TargetTypeMethod,
                _ => Self::UnknownValue(option_target_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for OptionTargetType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::TargetTypeUnknown => serializer.serialize_i32(0),
                Self::TargetTypeFile => serializer.serialize_i32(1),
                Self::TargetTypeExtensionRange => serializer.serialize_i32(2),
                Self::TargetTypeMessage => serializer.serialize_i32(3),
                Self::TargetTypeField => serializer.serialize_i32(4),
                Self::TargetTypeOneof => serializer.serialize_i32(5),
                Self::TargetTypeEnum => serializer.serialize_i32(6),
                Self::TargetTypeEnumEntry => serializer.serialize_i32(7),
                Self::TargetTypeService => serializer.serialize_i32(8),
                Self::TargetTypeMethod => serializer.serialize_i32(9),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for OptionTargetType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<OptionTargetType>::new(
                ".google.protobuf.FieldOptions.OptionTargetType",
            ))
        }
    }
}

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OneofOptions {
    /// Any features defined in the specific edition.
    pub features: std::option::Option<crate::FeatureSet>,

    /// The parser stores options it doesn't recognize here. See above.
    pub uninterpreted_option: std::vec::Vec<crate::UninterpretedOption>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl OneofOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [features][crate::OneofOptions::features].
    pub fn set_features<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [features][crate::OneofOptions::features].
    pub fn set_or_clear_features<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = v.map(|x| x.into());
        self
    }

    /// Sets the value of [uninterpreted_option][crate::OneofOptions::uninterpreted_option].
    pub fn set_uninterpreted_option<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::UninterpretedOption>,
    {
        use std::iter::Iterator;
        self.uninterpreted_option = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for OneofOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.OneofOptions"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for OneofOptions {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __features,
            __uninterpreted_option,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for OneofOptions")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "features" => Ok(__FieldTag::__features),
                            "uninterpretedOption" => Ok(__FieldTag::__uninterpreted_option),
                            "uninterpreted_option" => Ok(__FieldTag::__uninterpreted_option),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = OneofOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct OneofOptions")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__features => {
                            if !fields.insert(__FieldTag::__features) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for features",
                                ));
                            }
                            result.features =
                                map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                        }
                        __FieldTag::__uninterpreted_option => {
                            if !fields.insert(__FieldTag::__uninterpreted_option) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for uninterpreted_option",
                                ));
                            }
                            result.uninterpreted_option = map.next_value::<std::option::Option<std::vec::Vec<crate::UninterpretedOption>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for OneofOptions {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.features.is_some() {
            state.serialize_entry("features", &self.features)?;
        }
        if !self.uninterpreted_option.is_empty() {
            state.serialize_entry("uninterpretedOption", &self.uninterpreted_option)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for OneofOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OneofOptions");
        debug_struct.field("features", &self.features);
        debug_struct.field("uninterpreted_option", &self.uninterpreted_option);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct EnumOptions {
    /// Set this option to true to allow mapping different tag names to the same
    /// value.
    pub allow_alias: bool,

    /// Is this enum deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for the enum, or it will be completely ignored; in the very least, this
    /// is a formalization for deprecating enums.
    pub deprecated: bool,

    /// Enable the legacy handling of JSON field name conflicts.  This lowercases
    /// and strips underscored from the fields before comparison in proto3 only.
    /// The new behavior takes `json_name` into account and applies to proto2 as
    /// well.
    /// TODO Remove this legacy behavior once downstream teams have
    /// had time to migrate.
    #[deprecated]
    pub deprecated_legacy_json_field_conflicts: bool,

    /// Any features defined in the specific edition.
    pub features: std::option::Option<crate::FeatureSet>,

    /// The parser stores options it doesn't recognize here. See above.
    pub uninterpreted_option: std::vec::Vec<crate::UninterpretedOption>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EnumOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [allow_alias][crate::EnumOptions::allow_alias].
    pub fn set_allow_alias<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.allow_alias = v.into();
        self
    }

    /// Sets the value of [deprecated][crate::EnumOptions::deprecated].
    pub fn set_deprecated<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.deprecated = v.into();
        self
    }

    /// Sets the value of [deprecated_legacy_json_field_conflicts][crate::EnumOptions::deprecated_legacy_json_field_conflicts].
    #[deprecated]
    pub fn set_deprecated_legacy_json_field_conflicts<T: std::convert::Into<bool>>(
        mut self,
        v: T,
    ) -> Self {
        self.deprecated_legacy_json_field_conflicts = v.into();
        self
    }

    /// Sets the value of [features][crate::EnumOptions::features].
    pub fn set_features<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [features][crate::EnumOptions::features].
    pub fn set_or_clear_features<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = v.map(|x| x.into());
        self
    }

    /// Sets the value of [uninterpreted_option][crate::EnumOptions::uninterpreted_option].
    pub fn set_uninterpreted_option<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::UninterpretedOption>,
    {
        use std::iter::Iterator;
        self.uninterpreted_option = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for EnumOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.EnumOptions"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for EnumOptions {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __allow_alias,
            __deprecated,
            __deprecated_legacy_json_field_conflicts,
            __features,
            __uninterpreted_option,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for EnumOptions")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "allowAlias" => Ok(__FieldTag::__allow_alias),
                            "allow_alias" => Ok(__FieldTag::__allow_alias),
                            "deprecated" => Ok(__FieldTag::__deprecated),
                            "deprecatedLegacyJsonFieldConflicts" => {
                                Ok(__FieldTag::__deprecated_legacy_json_field_conflicts)
                            }
                            "deprecated_legacy_json_field_conflicts" => {
                                Ok(__FieldTag::__deprecated_legacy_json_field_conflicts)
                            }
                            "features" => Ok(__FieldTag::__features),
                            "uninterpretedOption" => Ok(__FieldTag::__uninterpreted_option),
                            "uninterpreted_option" => Ok(__FieldTag::__uninterpreted_option),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = EnumOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct EnumOptions")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__allow_alias => {
                            if !fields.insert(__FieldTag::__allow_alias) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for allow_alias",
                                ));
                            }
                            result.allow_alias = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__deprecated => {
                            if !fields.insert(__FieldTag::__deprecated) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for deprecated",
                                ));
                            }
                            result.deprecated = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__deprecated_legacy_json_field_conflicts => {
                            if !fields.insert(__FieldTag::__deprecated_legacy_json_field_conflicts)
                            {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for deprecated_legacy_json_field_conflicts",
                                ));
                            }
                            result.deprecated_legacy_json_field_conflicts = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__features => {
                            if !fields.insert(__FieldTag::__features) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for features",
                                ));
                            }
                            result.features =
                                map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                        }
                        __FieldTag::__uninterpreted_option => {
                            if !fields.insert(__FieldTag::__uninterpreted_option) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for uninterpreted_option",
                                ));
                            }
                            result.uninterpreted_option = map.next_value::<std::option::Option<std::vec::Vec<crate::UninterpretedOption>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for EnumOptions {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.allow_alias) {
            state.serialize_entry("allowAlias", &self.allow_alias)?;
        }
        if !wkt::internal::is_default(&self.deprecated) {
            state.serialize_entry("deprecated", &self.deprecated)?;
        }
        if !wkt::internal::is_default(&self.deprecated_legacy_json_field_conflicts) {
            state.serialize_entry(
                "deprecatedLegacyJsonFieldConflicts",
                &self.deprecated_legacy_json_field_conflicts,
            )?;
        }
        if self.features.is_some() {
            state.serialize_entry("features", &self.features)?;
        }
        if !self.uninterpreted_option.is_empty() {
            state.serialize_entry("uninterpretedOption", &self.uninterpreted_option)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for EnumOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnumOptions");
        debug_struct.field("allow_alias", &self.allow_alias);
        debug_struct.field("deprecated", &self.deprecated);
        debug_struct.field(
            "deprecated_legacy_json_field_conflicts",
            &self.deprecated_legacy_json_field_conflicts,
        );
        debug_struct.field("features", &self.features);
        debug_struct.field("uninterpreted_option", &self.uninterpreted_option);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct EnumValueOptions {
    /// Is this enum value deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for the enum value, or it will be completely ignored; in the very least,
    /// this is a formalization for deprecating enum values.
    pub deprecated: bool,

    /// Any features defined in the specific edition.
    pub features: std::option::Option<crate::FeatureSet>,

    /// Indicate that fields annotated with this enum value should not be printed
    /// out when using debug formats, e.g. when the field contains sensitive
    /// credentials.
    pub debug_redact: bool,

    /// Information about the support window of a feature value.
    pub feature_support: std::option::Option<crate::field_options::FeatureSupport>,

    /// The parser stores options it doesn't recognize here. See above.
    pub uninterpreted_option: std::vec::Vec<crate::UninterpretedOption>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EnumValueOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [deprecated][crate::EnumValueOptions::deprecated].
    pub fn set_deprecated<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.deprecated = v.into();
        self
    }

    /// Sets the value of [features][crate::EnumValueOptions::features].
    pub fn set_features<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [features][crate::EnumValueOptions::features].
    pub fn set_or_clear_features<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = v.map(|x| x.into());
        self
    }

    /// Sets the value of [debug_redact][crate::EnumValueOptions::debug_redact].
    pub fn set_debug_redact<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.debug_redact = v.into();
        self
    }

    /// Sets the value of [feature_support][crate::EnumValueOptions::feature_support].
    pub fn set_feature_support<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::field_options::FeatureSupport>,
    {
        self.feature_support = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [feature_support][crate::EnumValueOptions::feature_support].
    pub fn set_or_clear_feature_support<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::field_options::FeatureSupport>,
    {
        self.feature_support = v.map(|x| x.into());
        self
    }

    /// Sets the value of [uninterpreted_option][crate::EnumValueOptions::uninterpreted_option].
    pub fn set_uninterpreted_option<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::UninterpretedOption>,
    {
        use std::iter::Iterator;
        self.uninterpreted_option = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for EnumValueOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.EnumValueOptions"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for EnumValueOptions {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __deprecated,
            __features,
            __debug_redact,
            __feature_support,
            __uninterpreted_option,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for EnumValueOptions")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "deprecated" => Ok(__FieldTag::__deprecated),
                            "features" => Ok(__FieldTag::__features),
                            "debugRedact" => Ok(__FieldTag::__debug_redact),
                            "debug_redact" => Ok(__FieldTag::__debug_redact),
                            "featureSupport" => Ok(__FieldTag::__feature_support),
                            "feature_support" => Ok(__FieldTag::__feature_support),
                            "uninterpretedOption" => Ok(__FieldTag::__uninterpreted_option),
                            "uninterpreted_option" => Ok(__FieldTag::__uninterpreted_option),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = EnumValueOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct EnumValueOptions")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__deprecated => {
                            if !fields.insert(__FieldTag::__deprecated) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for deprecated",
                                ));
                            }
                            result.deprecated = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__features => {
                            if !fields.insert(__FieldTag::__features) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for features",
                                ));
                            }
                            result.features =
                                map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                        }
                        __FieldTag::__debug_redact => {
                            if !fields.insert(__FieldTag::__debug_redact) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for debug_redact",
                                ));
                            }
                            result.debug_redact = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__feature_support => {
                            if !fields.insert(__FieldTag::__feature_support) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for feature_support",
                                ));
                            }
                            result.feature_support = map.next_value::<std::option::Option<crate::field_options::FeatureSupport>>()?
                                ;
                        }
                        __FieldTag::__uninterpreted_option => {
                            if !fields.insert(__FieldTag::__uninterpreted_option) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for uninterpreted_option",
                                ));
                            }
                            result.uninterpreted_option = map.next_value::<std::option::Option<std::vec::Vec<crate::UninterpretedOption>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for EnumValueOptions {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.deprecated) {
            state.serialize_entry("deprecated", &self.deprecated)?;
        }
        if self.features.is_some() {
            state.serialize_entry("features", &self.features)?;
        }
        if !wkt::internal::is_default(&self.debug_redact) {
            state.serialize_entry("debugRedact", &self.debug_redact)?;
        }
        if self.feature_support.is_some() {
            state.serialize_entry("featureSupport", &self.feature_support)?;
        }
        if !self.uninterpreted_option.is_empty() {
            state.serialize_entry("uninterpretedOption", &self.uninterpreted_option)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for EnumValueOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnumValueOptions");
        debug_struct.field("deprecated", &self.deprecated);
        debug_struct.field("features", &self.features);
        debug_struct.field("debug_redact", &self.debug_redact);
        debug_struct.field("feature_support", &self.feature_support);
        debug_struct.field("uninterpreted_option", &self.uninterpreted_option);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ServiceOptions {
    /// Any features defined in the specific edition.
    pub features: std::option::Option<crate::FeatureSet>,

    /// Is this service deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for the service, or it will be completely ignored; in the very least,
    /// this is a formalization for deprecating services.
    pub deprecated: bool,

    /// The parser stores options it doesn't recognize here. See above.
    pub uninterpreted_option: std::vec::Vec<crate::UninterpretedOption>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ServiceOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [features][crate::ServiceOptions::features].
    pub fn set_features<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [features][crate::ServiceOptions::features].
    pub fn set_or_clear_features<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = v.map(|x| x.into());
        self
    }

    /// Sets the value of [deprecated][crate::ServiceOptions::deprecated].
    pub fn set_deprecated<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.deprecated = v.into();
        self
    }

    /// Sets the value of [uninterpreted_option][crate::ServiceOptions::uninterpreted_option].
    pub fn set_uninterpreted_option<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::UninterpretedOption>,
    {
        use std::iter::Iterator;
        self.uninterpreted_option = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ServiceOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.ServiceOptions"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for ServiceOptions {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __features,
            __deprecated,
            __uninterpreted_option,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for ServiceOptions")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "features" => Ok(__FieldTag::__features),
                            "deprecated" => Ok(__FieldTag::__deprecated),
                            "uninterpretedOption" => Ok(__FieldTag::__uninterpreted_option),
                            "uninterpreted_option" => Ok(__FieldTag::__uninterpreted_option),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = ServiceOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ServiceOptions")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__features => {
                            if !fields.insert(__FieldTag::__features) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for features",
                                ));
                            }
                            result.features =
                                map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                        }
                        __FieldTag::__deprecated => {
                            if !fields.insert(__FieldTag::__deprecated) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for deprecated",
                                ));
                            }
                            result.deprecated = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__uninterpreted_option => {
                            if !fields.insert(__FieldTag::__uninterpreted_option) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for uninterpreted_option",
                                ));
                            }
                            result.uninterpreted_option = map.next_value::<std::option::Option<std::vec::Vec<crate::UninterpretedOption>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for ServiceOptions {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.features.is_some() {
            state.serialize_entry("features", &self.features)?;
        }
        if !wkt::internal::is_default(&self.deprecated) {
            state.serialize_entry("deprecated", &self.deprecated)?;
        }
        if !self.uninterpreted_option.is_empty() {
            state.serialize_entry("uninterpretedOption", &self.uninterpreted_option)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for ServiceOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ServiceOptions");
        debug_struct.field("features", &self.features);
        debug_struct.field("deprecated", &self.deprecated);
        debug_struct.field("uninterpreted_option", &self.uninterpreted_option);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MethodOptions {
    /// Is this method deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for the method, or it will be completely ignored; in the very least,
    /// this is a formalization for deprecating methods.
    pub deprecated: bool,

    pub idempotency_level: crate::method_options::IdempotencyLevel,

    /// Any features defined in the specific edition.
    pub features: std::option::Option<crate::FeatureSet>,

    /// The parser stores options it doesn't recognize here. See above.
    pub uninterpreted_option: std::vec::Vec<crate::UninterpretedOption>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MethodOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [deprecated][crate::MethodOptions::deprecated].
    pub fn set_deprecated<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.deprecated = v.into();
        self
    }

    /// Sets the value of [idempotency_level][crate::MethodOptions::idempotency_level].
    pub fn set_idempotency_level<T: std::convert::Into<crate::method_options::IdempotencyLevel>>(
        mut self,
        v: T,
    ) -> Self {
        self.idempotency_level = v.into();
        self
    }

    /// Sets the value of [features][crate::MethodOptions::features].
    pub fn set_features<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [features][crate::MethodOptions::features].
    pub fn set_or_clear_features<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::FeatureSet>,
    {
        self.features = v.map(|x| x.into());
        self
    }

    /// Sets the value of [uninterpreted_option][crate::MethodOptions::uninterpreted_option].
    pub fn set_uninterpreted_option<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::UninterpretedOption>,
    {
        use std::iter::Iterator;
        self.uninterpreted_option = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for MethodOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.MethodOptions"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for MethodOptions {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __deprecated,
            __idempotency_level,
            __features,
            __uninterpreted_option,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for MethodOptions")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "deprecated" => Ok(__FieldTag::__deprecated),
                            "idempotencyLevel" => Ok(__FieldTag::__idempotency_level),
                            "idempotency_level" => Ok(__FieldTag::__idempotency_level),
                            "features" => Ok(__FieldTag::__features),
                            "uninterpretedOption" => Ok(__FieldTag::__uninterpreted_option),
                            "uninterpreted_option" => Ok(__FieldTag::__uninterpreted_option),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = MethodOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct MethodOptions")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__deprecated => {
                            if !fields.insert(__FieldTag::__deprecated) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for deprecated",
                                ));
                            }
                            result.deprecated = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__idempotency_level => {
                            if !fields.insert(__FieldTag::__idempotency_level) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for idempotency_level",
                                ));
                            }
                            result.idempotency_level = map.next_value::<std::option::Option<crate::method_options::IdempotencyLevel>>()?.unwrap_or_default();
                        }
                        __FieldTag::__features => {
                            if !fields.insert(__FieldTag::__features) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for features",
                                ));
                            }
                            result.features =
                                map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                        }
                        __FieldTag::__uninterpreted_option => {
                            if !fields.insert(__FieldTag::__uninterpreted_option) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for uninterpreted_option",
                                ));
                            }
                            result.uninterpreted_option = map.next_value::<std::option::Option<std::vec::Vec<crate::UninterpretedOption>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for MethodOptions {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.deprecated) {
            state.serialize_entry("deprecated", &self.deprecated)?;
        }
        if !wkt::internal::is_default(&self.idempotency_level) {
            state.serialize_entry("idempotencyLevel", &self.idempotency_level)?;
        }
        if self.features.is_some() {
            state.serialize_entry("features", &self.features)?;
        }
        if !self.uninterpreted_option.is_empty() {
            state.serialize_entry("uninterpretedOption", &self.uninterpreted_option)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for MethodOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MethodOptions");
        debug_struct.field("deprecated", &self.deprecated);
        debug_struct.field("idempotency_level", &self.idempotency_level);
        debug_struct.field("features", &self.features);
        debug_struct.field("uninterpreted_option", &self.uninterpreted_option);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [MethodOptions].
pub mod method_options {
    #[allow(unused_imports)]
    use super::*;

    /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
    /// or neither? HTTP based RPC implementation may choose GET verb for safe
    /// methods, and PUT verb for idempotent methods instead of the default POST.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum IdempotencyLevel {
        IdempotencyUnknown,
        NoSideEffects,
        Idempotent,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [IdempotencyLevel::value] or
        /// [IdempotencyLevel::name].
        UnknownValue(idempotency_level::UnknownValue),
    }

    #[doc(hidden)]
    pub mod idempotency_level {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl IdempotencyLevel {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::IdempotencyUnknown => std::option::Option::Some(0),
                Self::NoSideEffects => std::option::Option::Some(1),
                Self::Idempotent => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::IdempotencyUnknown => std::option::Option::Some("IDEMPOTENCY_UNKNOWN"),
                Self::NoSideEffects => std::option::Option::Some("NO_SIDE_EFFECTS"),
                Self::Idempotent => std::option::Option::Some("IDEMPOTENT"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for IdempotencyLevel {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for IdempotencyLevel {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for IdempotencyLevel {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::IdempotencyUnknown,
                1 => Self::NoSideEffects,
                2 => Self::Idempotent,
                _ => Self::UnknownValue(idempotency_level::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for IdempotencyLevel {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "IDEMPOTENCY_UNKNOWN" => Self::IdempotencyUnknown,
                "NO_SIDE_EFFECTS" => Self::NoSideEffects,
                "IDEMPOTENT" => Self::Idempotent,
                _ => Self::UnknownValue(idempotency_level::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for IdempotencyLevel {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::IdempotencyUnknown => serializer.serialize_i32(0),
                Self::NoSideEffects => serializer.serialize_i32(1),
                Self::Idempotent => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for IdempotencyLevel {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<IdempotencyLevel>::new(
                ".google.protobuf.MethodOptions.IdempotencyLevel",
            ))
        }
    }
}

/// A message representing a option the parser does not recognize. This only
/// appears in options protos created by the compiler::Parser class.
/// DescriptorPool resolves these when building Descriptor objects. Therefore,
/// options protos in descriptor objects (e.g. returned by Descriptor::options(),
/// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
/// in them.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UninterpretedOption {
    pub name: std::vec::Vec<crate::uninterpreted_option::NamePart>,

    /// The value of the uninterpreted option, in whatever type the tokenizer
    /// identified it as during parsing. Exactly one of these should be set.
    pub identifier_value: std::string::String,

    pub positive_int_value: u64,

    pub negative_int_value: i64,

    pub double_value: f64,

    pub string_value: ::bytes::Bytes,

    pub aggregate_value: std::string::String,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UninterpretedOption {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::UninterpretedOption::name].
    pub fn set_name<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::uninterpreted_option::NamePart>,
    {
        use std::iter::Iterator;
        self.name = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [identifier_value][crate::UninterpretedOption::identifier_value].
    pub fn set_identifier_value<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.identifier_value = v.into();
        self
    }

    /// Sets the value of [positive_int_value][crate::UninterpretedOption::positive_int_value].
    pub fn set_positive_int_value<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.positive_int_value = v.into();
        self
    }

    /// Sets the value of [negative_int_value][crate::UninterpretedOption::negative_int_value].
    pub fn set_negative_int_value<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.negative_int_value = v.into();
        self
    }

    /// Sets the value of [double_value][crate::UninterpretedOption::double_value].
    pub fn set_double_value<T: std::convert::Into<f64>>(mut self, v: T) -> Self {
        self.double_value = v.into();
        self
    }

    /// Sets the value of [string_value][crate::UninterpretedOption::string_value].
    pub fn set_string_value<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.string_value = v.into();
        self
    }

    /// Sets the value of [aggregate_value][crate::UninterpretedOption::aggregate_value].
    pub fn set_aggregate_value<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.aggregate_value = v.into();
        self
    }
}

impl wkt::message::Message for UninterpretedOption {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.UninterpretedOption"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for UninterpretedOption {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __identifier_value,
            __positive_int_value,
            __negative_int_value,
            __double_value,
            __string_value,
            __aggregate_value,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for UninterpretedOption")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "identifierValue" => Ok(__FieldTag::__identifier_value),
                            "identifier_value" => Ok(__FieldTag::__identifier_value),
                            "positiveIntValue" => Ok(__FieldTag::__positive_int_value),
                            "positive_int_value" => Ok(__FieldTag::__positive_int_value),
                            "negativeIntValue" => Ok(__FieldTag::__negative_int_value),
                            "negative_int_value" => Ok(__FieldTag::__negative_int_value),
                            "doubleValue" => Ok(__FieldTag::__double_value),
                            "double_value" => Ok(__FieldTag::__double_value),
                            "stringValue" => Ok(__FieldTag::__string_value),
                            "string_value" => Ok(__FieldTag::__string_value),
                            "aggregateValue" => Ok(__FieldTag::__aggregate_value),
                            "aggregate_value" => Ok(__FieldTag::__aggregate_value),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = UninterpretedOption;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct UninterpretedOption")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::uninterpreted_option::NamePart>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__identifier_value => {
                            if !fields.insert(__FieldTag::__identifier_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for identifier_value",
                                ));
                            }
                            result.identifier_value = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__positive_int_value => {
                            if !fields.insert(__FieldTag::__positive_int_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for positive_int_value",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.positive_int_value =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__negative_int_value => {
                            if !fields.insert(__FieldTag::__negative_int_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for negative_int_value",
                                ));
                            }
                            struct __With(std::option::Option<i64>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.negative_int_value =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__double_value => {
                            if !fields.insert(__FieldTag::__double_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for double_value",
                                ));
                            }
                            struct __With(std::option::Option<f64>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.double_value = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__string_value => {
                            if !fields.insert(__FieldTag::__string_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for string_value",
                                ));
                            }
                            struct __With(std::option::Option<::bytes::Bytes>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<serde_with::base64::Base64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.string_value = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__aggregate_value => {
                            if !fields.insert(__FieldTag::__aggregate_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for aggregate_value",
                                ));
                            }
                            result.aggregate_value = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for UninterpretedOption {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.identifier_value.is_empty() {
            state.serialize_entry("identifierValue", &self.identifier_value)?;
        }
        if !wkt::internal::is_default(&self.positive_int_value) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("positiveIntValue", &__With(&self.positive_int_value))?;
        }
        if !wkt::internal::is_default(&self.negative_int_value) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("negativeIntValue", &__With(&self.negative_int_value))?;
        }
        if !wkt::internal::is_default(&self.double_value) {
            struct __With<'a>(&'a f64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("doubleValue", &__With(&self.double_value))?;
        }
        if !self.string_value.is_empty() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("stringValue", &__With(&self.string_value))?;
        }
        if !self.aggregate_value.is_empty() {
            state.serialize_entry("aggregateValue", &self.aggregate_value)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for UninterpretedOption {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UninterpretedOption");
        debug_struct.field("name", &self.name);
        debug_struct.field("identifier_value", &self.identifier_value);
        debug_struct.field("positive_int_value", &self.positive_int_value);
        debug_struct.field("negative_int_value", &self.negative_int_value);
        debug_struct.field("double_value", &self.double_value);
        debug_struct.field("string_value", &self.string_value);
        debug_struct.field("aggregate_value", &self.aggregate_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [UninterpretedOption].
pub mod uninterpreted_option {
    #[allow(unused_imports)]
    use super::*;

    /// The name of the uninterpreted option.  Each string represents a segment in
    /// a dot-separated name.  is_extension is true iff a segment represents an
    /// extension (denoted with parentheses in options specs in .proto files).
    /// E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents
    /// "foo.(bar.baz).moo".
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct NamePart {
        pub name_part: std::string::String,

        pub is_extension: bool,

        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl NamePart {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [name_part][crate::uninterpreted_option::NamePart::name_part].
        pub fn set_name_part<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.name_part = v.into();
            self
        }

        /// Sets the value of [is_extension][crate::uninterpreted_option::NamePart::is_extension].
        pub fn set_is_extension<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.is_extension = v.into();
            self
        }
    }

    impl wkt::message::Message for NamePart {
        fn typename() -> &'static str {
            "type.googleapis.com/google.protobuf.UninterpretedOption.NamePart"
        }
    }

    #[doc(hidden)]
    impl<'de> serde::de::Deserialize<'de> for NamePart {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            #[allow(non_camel_case_types)]
            #[doc(hidden)]
            #[derive(PartialEq, Eq, Hash)]
            enum __FieldTag {
                __name_part,
                __is_extension,
                Unknown(std::string::String),
            }
            impl<'de> serde::de::Deserialize<'de> for __FieldTag {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    struct Visitor;
                    impl<'de> serde::de::Visitor<'de> for Visitor {
                        type Value = __FieldTag;
                        fn expecting(
                            &self,
                            formatter: &mut std::fmt::Formatter,
                        ) -> std::fmt::Result {
                            formatter.write_str("a field name for NamePart")
                        }
                        fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                        where
                            E: serde::de::Error,
                        {
                            use std::result::Result::Ok;
                            use std::string::ToString;
                            match value {
                                "namePart" => Ok(__FieldTag::__name_part),
                                "name_part" => Ok(__FieldTag::__name_part),
                                "isExtension" => Ok(__FieldTag::__is_extension),
                                "is_extension" => Ok(__FieldTag::__is_extension),
                                _ => Ok(__FieldTag::Unknown(value.to_string())),
                            }
                        }
                    }
                    deserializer.deserialize_identifier(Visitor)
                }
            }
            struct Visitor;
            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = NamePart;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct NamePart")
                }
                fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
                where
                    A: serde::de::MapAccess<'de>,
                {
                    #[allow(unused_imports)]
                    use serde::de::Error;
                    use std::option::Option::Some;
                    let mut fields = std::collections::HashSet::new();
                    let mut result = Self::Value::new();
                    while let Some(tag) = map.next_key::<__FieldTag>()? {
                        #[allow(clippy::match_single_binding)]
                        match tag {
                            __FieldTag::__name_part => {
                                if !fields.insert(__FieldTag::__name_part) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for name_part",
                                    ));
                                }
                                result.name_part = map
                                    .next_value::<std::option::Option<std::string::String>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__is_extension => {
                                if !fields.insert(__FieldTag::__is_extension) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for is_extension",
                                    ));
                                }
                                result.is_extension = map
                                    .next_value::<std::option::Option<bool>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::Unknown(key) => {
                                let value = map.next_value::<serde_json::Value>()?;
                                result._unknown_fields.insert(key, value);
                            }
                        }
                    }
                    std::result::Result::Ok(result)
                }
            }
            deserializer.deserialize_any(Visitor)
        }
    }

    #[doc(hidden)]
    impl serde::ser::Serialize for NamePart {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
        {
            use serde::ser::SerializeMap;
            #[allow(unused_imports)]
            use std::option::Option::Some;
            let mut state = serializer.serialize_map(std::option::Option::None)?;
            if !self.name_part.is_empty() {
                state.serialize_entry("namePart", &self.name_part)?;
            }
            if !wkt::internal::is_default(&self.is_extension) {
                state.serialize_entry("isExtension", &self.is_extension)?;
            }
            if !self._unknown_fields.is_empty() {
                for (key, value) in self._unknown_fields.iter() {
                    state.serialize_entry(key, &value)?;
                }
            }
            state.end()
        }
    }

    impl std::fmt::Debug for NamePart {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut debug_struct = f.debug_struct("NamePart");
            debug_struct.field("name_part", &self.name_part);
            debug_struct.field("is_extension", &self.is_extension);
            if !self._unknown_fields.is_empty() {
                debug_struct.field("_unknown_fields", &self._unknown_fields);
            }
            debug_struct.finish()
        }
    }
}

/// TODO Enums in C++ gencode (and potentially other languages) are
/// not well scoped.  This means that each of the feature enums below can clash
/// with each other.  The short names we've chosen maximize call-site
/// readability, but leave us very open to this scenario.  A future feature will
/// be designed and implemented to handle this, hopefully before we ever hit a
/// conflict here.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FeatureSet {
    pub field_presence: crate::feature_set::FieldPresence,

    pub enum_type: crate::feature_set::EnumType,

    pub repeated_field_encoding: crate::feature_set::RepeatedFieldEncoding,

    pub utf8_validation: crate::feature_set::Utf8Validation,

    pub message_encoding: crate::feature_set::MessageEncoding,

    pub json_format: crate::feature_set::JsonFormat,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FeatureSet {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [field_presence][crate::FeatureSet::field_presence].
    pub fn set_field_presence<T: std::convert::Into<crate::feature_set::FieldPresence>>(
        mut self,
        v: T,
    ) -> Self {
        self.field_presence = v.into();
        self
    }

    /// Sets the value of [enum_type][crate::FeatureSet::enum_type].
    pub fn set_enum_type<T: std::convert::Into<crate::feature_set::EnumType>>(
        mut self,
        v: T,
    ) -> Self {
        self.enum_type = v.into();
        self
    }

    /// Sets the value of [repeated_field_encoding][crate::FeatureSet::repeated_field_encoding].
    pub fn set_repeated_field_encoding<
        T: std::convert::Into<crate::feature_set::RepeatedFieldEncoding>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.repeated_field_encoding = v.into();
        self
    }

    /// Sets the value of [utf8_validation][crate::FeatureSet::utf8_validation].
    pub fn set_utf8_validation<T: std::convert::Into<crate::feature_set::Utf8Validation>>(
        mut self,
        v: T,
    ) -> Self {
        self.utf8_validation = v.into();
        self
    }

    /// Sets the value of [message_encoding][crate::FeatureSet::message_encoding].
    pub fn set_message_encoding<T: std::convert::Into<crate::feature_set::MessageEncoding>>(
        mut self,
        v: T,
    ) -> Self {
        self.message_encoding = v.into();
        self
    }

    /// Sets the value of [json_format][crate::FeatureSet::json_format].
    pub fn set_json_format<T: std::convert::Into<crate::feature_set::JsonFormat>>(
        mut self,
        v: T,
    ) -> Self {
        self.json_format = v.into();
        self
    }
}

impl wkt::message::Message for FeatureSet {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.FeatureSet"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for FeatureSet {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __field_presence,
            __enum_type,
            __repeated_field_encoding,
            __utf8_validation,
            __message_encoding,
            __json_format,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for FeatureSet")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "fieldPresence" => Ok(__FieldTag::__field_presence),
                            "field_presence" => Ok(__FieldTag::__field_presence),
                            "enumType" => Ok(__FieldTag::__enum_type),
                            "enum_type" => Ok(__FieldTag::__enum_type),
                            "repeatedFieldEncoding" => Ok(__FieldTag::__repeated_field_encoding),
                            "repeated_field_encoding" => Ok(__FieldTag::__repeated_field_encoding),
                            "utf8Validation" => Ok(__FieldTag::__utf8_validation),
                            "utf8_validation" => Ok(__FieldTag::__utf8_validation),
                            "messageEncoding" => Ok(__FieldTag::__message_encoding),
                            "message_encoding" => Ok(__FieldTag::__message_encoding),
                            "jsonFormat" => Ok(__FieldTag::__json_format),
                            "json_format" => Ok(__FieldTag::__json_format),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = FeatureSet;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct FeatureSet")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__field_presence => {
                            if !fields.insert(__FieldTag::__field_presence) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for field_presence",
                                ));
                            }
                            result.field_presence = map.next_value::<std::option::Option<crate::feature_set::FieldPresence>>()?.unwrap_or_default();
                        }
                        __FieldTag::__enum_type => {
                            if !fields.insert(__FieldTag::__enum_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for enum_type",
                                ));
                            }
                            result.enum_type = map
                                .next_value::<std::option::Option<crate::feature_set::EnumType>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__repeated_field_encoding => {
                            if !fields.insert(__FieldTag::__repeated_field_encoding) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for repeated_field_encoding",
                                ));
                            }
                            result.repeated_field_encoding = map.next_value::<std::option::Option<crate::feature_set::RepeatedFieldEncoding>>()?.unwrap_or_default();
                        }
                        __FieldTag::__utf8_validation => {
                            if !fields.insert(__FieldTag::__utf8_validation) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for utf8_validation",
                                ));
                            }
                            result.utf8_validation = map.next_value::<std::option::Option<crate::feature_set::Utf8Validation>>()?.unwrap_or_default();
                        }
                        __FieldTag::__message_encoding => {
                            if !fields.insert(__FieldTag::__message_encoding) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for message_encoding",
                                ));
                            }
                            result.message_encoding = map.next_value::<std::option::Option<crate::feature_set::MessageEncoding>>()?.unwrap_or_default();
                        }
                        __FieldTag::__json_format => {
                            if !fields.insert(__FieldTag::__json_format) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for json_format",
                                ));
                            }
                            result.json_format = map
                                .next_value::<std::option::Option<crate::feature_set::JsonFormat>>(
                                )?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for FeatureSet {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.field_presence) {
            state.serialize_entry("fieldPresence", &self.field_presence)?;
        }
        if !wkt::internal::is_default(&self.enum_type) {
            state.serialize_entry("enumType", &self.enum_type)?;
        }
        if !wkt::internal::is_default(&self.repeated_field_encoding) {
            state.serialize_entry("repeatedFieldEncoding", &self.repeated_field_encoding)?;
        }
        if !wkt::internal::is_default(&self.utf8_validation) {
            state.serialize_entry("utf8Validation", &self.utf8_validation)?;
        }
        if !wkt::internal::is_default(&self.message_encoding) {
            state.serialize_entry("messageEncoding", &self.message_encoding)?;
        }
        if !wkt::internal::is_default(&self.json_format) {
            state.serialize_entry("jsonFormat", &self.json_format)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for FeatureSet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureSet");
        debug_struct.field("field_presence", &self.field_presence);
        debug_struct.field("enum_type", &self.enum_type);
        debug_struct.field("repeated_field_encoding", &self.repeated_field_encoding);
        debug_struct.field("utf8_validation", &self.utf8_validation);
        debug_struct.field("message_encoding", &self.message_encoding);
        debug_struct.field("json_format", &self.json_format);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [FeatureSet].
pub mod feature_set {
    #[allow(unused_imports)]
    use super::*;

    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum FieldPresence {
        Unknown,
        Explicit,
        Implicit,
        LegacyRequired,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [FieldPresence::value] or
        /// [FieldPresence::name].
        UnknownValue(field_presence::UnknownValue),
    }

    #[doc(hidden)]
    pub mod field_presence {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl FieldPresence {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Explicit => std::option::Option::Some(1),
                Self::Implicit => std::option::Option::Some(2),
                Self::LegacyRequired => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("FIELD_PRESENCE_UNKNOWN"),
                Self::Explicit => std::option::Option::Some("EXPLICIT"),
                Self::Implicit => std::option::Option::Some("IMPLICIT"),
                Self::LegacyRequired => std::option::Option::Some("LEGACY_REQUIRED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for FieldPresence {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for FieldPresence {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for FieldPresence {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::Explicit,
                2 => Self::Implicit,
                3 => Self::LegacyRequired,
                _ => Self::UnknownValue(field_presence::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for FieldPresence {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "FIELD_PRESENCE_UNKNOWN" => Self::Unknown,
                "EXPLICIT" => Self::Explicit,
                "IMPLICIT" => Self::Implicit,
                "LEGACY_REQUIRED" => Self::LegacyRequired,
                _ => Self::UnknownValue(field_presence::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for FieldPresence {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Explicit => serializer.serialize_i32(1),
                Self::Implicit => serializer.serialize_i32(2),
                Self::LegacyRequired => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for FieldPresence {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<FieldPresence>::new(
                ".google.protobuf.FeatureSet.FieldPresence",
            ))
        }
    }

    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum EnumType {
        Unknown,
        Open,
        Closed,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [EnumType::value] or
        /// [EnumType::name].
        UnknownValue(enum_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod enum_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl EnumType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Open => std::option::Option::Some(1),
                Self::Closed => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("ENUM_TYPE_UNKNOWN"),
                Self::Open => std::option::Option::Some("OPEN"),
                Self::Closed => std::option::Option::Some("CLOSED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for EnumType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for EnumType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for EnumType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::Open,
                2 => Self::Closed,
                _ => Self::UnknownValue(enum_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for EnumType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "ENUM_TYPE_UNKNOWN" => Self::Unknown,
                "OPEN" => Self::Open,
                "CLOSED" => Self::Closed,
                _ => Self::UnknownValue(enum_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for EnumType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Open => serializer.serialize_i32(1),
                Self::Closed => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for EnumType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<EnumType>::new(
                ".google.protobuf.FeatureSet.EnumType",
            ))
        }
    }

    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum RepeatedFieldEncoding {
        Unknown,
        Packed,
        Expanded,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [RepeatedFieldEncoding::value] or
        /// [RepeatedFieldEncoding::name].
        UnknownValue(repeated_field_encoding::UnknownValue),
    }

    #[doc(hidden)]
    pub mod repeated_field_encoding {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl RepeatedFieldEncoding {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Packed => std::option::Option::Some(1),
                Self::Expanded => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("REPEATED_FIELD_ENCODING_UNKNOWN"),
                Self::Packed => std::option::Option::Some("PACKED"),
                Self::Expanded => std::option::Option::Some("EXPANDED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for RepeatedFieldEncoding {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for RepeatedFieldEncoding {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for RepeatedFieldEncoding {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::Packed,
                2 => Self::Expanded,
                _ => Self::UnknownValue(repeated_field_encoding::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for RepeatedFieldEncoding {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "REPEATED_FIELD_ENCODING_UNKNOWN" => Self::Unknown,
                "PACKED" => Self::Packed,
                "EXPANDED" => Self::Expanded,
                _ => Self::UnknownValue(repeated_field_encoding::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for RepeatedFieldEncoding {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Packed => serializer.serialize_i32(1),
                Self::Expanded => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for RepeatedFieldEncoding {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<RepeatedFieldEncoding>::new(
                ".google.protobuf.FeatureSet.RepeatedFieldEncoding",
            ))
        }
    }

    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Utf8Validation {
        Unknown,
        Verify,
        None,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Utf8Validation::value] or
        /// [Utf8Validation::name].
        UnknownValue(utf_8_validation::UnknownValue),
    }

    #[doc(hidden)]
    pub mod utf_8_validation {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Utf8Validation {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Verify => std::option::Option::Some(2),
                Self::None => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("UTF8_VALIDATION_UNKNOWN"),
                Self::Verify => std::option::Option::Some("VERIFY"),
                Self::None => std::option::Option::Some("NONE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Utf8Validation {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Utf8Validation {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Utf8Validation {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                2 => Self::Verify,
                3 => Self::None,
                _ => Self::UnknownValue(utf_8_validation::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Utf8Validation {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UTF8_VALIDATION_UNKNOWN" => Self::Unknown,
                "VERIFY" => Self::Verify,
                "NONE" => Self::None,
                _ => Self::UnknownValue(utf_8_validation::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Utf8Validation {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Verify => serializer.serialize_i32(2),
                Self::None => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Utf8Validation {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Utf8Validation>::new(
                ".google.protobuf.FeatureSet.Utf8Validation",
            ))
        }
    }

    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum MessageEncoding {
        Unknown,
        LengthPrefixed,
        Delimited,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [MessageEncoding::value] or
        /// [MessageEncoding::name].
        UnknownValue(message_encoding::UnknownValue),
    }

    #[doc(hidden)]
    pub mod message_encoding {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl MessageEncoding {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::LengthPrefixed => std::option::Option::Some(1),
                Self::Delimited => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("MESSAGE_ENCODING_UNKNOWN"),
                Self::LengthPrefixed => std::option::Option::Some("LENGTH_PREFIXED"),
                Self::Delimited => std::option::Option::Some("DELIMITED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for MessageEncoding {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for MessageEncoding {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for MessageEncoding {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::LengthPrefixed,
                2 => Self::Delimited,
                _ => Self::UnknownValue(message_encoding::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for MessageEncoding {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MESSAGE_ENCODING_UNKNOWN" => Self::Unknown,
                "LENGTH_PREFIXED" => Self::LengthPrefixed,
                "DELIMITED" => Self::Delimited,
                _ => Self::UnknownValue(message_encoding::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for MessageEncoding {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::LengthPrefixed => serializer.serialize_i32(1),
                Self::Delimited => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for MessageEncoding {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<MessageEncoding>::new(
                ".google.protobuf.FeatureSet.MessageEncoding",
            ))
        }
    }

    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum JsonFormat {
        Unknown,
        Allow,
        LegacyBestEffort,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [JsonFormat::value] or
        /// [JsonFormat::name].
        UnknownValue(json_format::UnknownValue),
    }

    #[doc(hidden)]
    pub mod json_format {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl JsonFormat {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Allow => std::option::Option::Some(1),
                Self::LegacyBestEffort => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("JSON_FORMAT_UNKNOWN"),
                Self::Allow => std::option::Option::Some("ALLOW"),
                Self::LegacyBestEffort => std::option::Option::Some("LEGACY_BEST_EFFORT"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for JsonFormat {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for JsonFormat {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for JsonFormat {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::Allow,
                2 => Self::LegacyBestEffort,
                _ => Self::UnknownValue(json_format::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for JsonFormat {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "JSON_FORMAT_UNKNOWN" => Self::Unknown,
                "ALLOW" => Self::Allow,
                "LEGACY_BEST_EFFORT" => Self::LegacyBestEffort,
                _ => Self::UnknownValue(json_format::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for JsonFormat {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Allow => serializer.serialize_i32(1),
                Self::LegacyBestEffort => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for JsonFormat {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<JsonFormat>::new(
                ".google.protobuf.FeatureSet.JsonFormat",
            ))
        }
    }
}

/// A compiled specification for the defaults of a set of features.  These
/// messages are generated from FeatureSet extensions and can be used to seed
/// feature resolution. The resolution with this object becomes a simple search
/// for the closest matching edition, followed by proto merges.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FeatureSetDefaults {
    pub defaults: std::vec::Vec<crate::feature_set_defaults::FeatureSetEditionDefault>,

    /// The minimum supported edition (inclusive) when this was constructed.
    /// Editions before this will not have defaults.
    pub minimum_edition: crate::Edition,

    /// The maximum known edition (inclusive) when this was constructed. Editions
    /// after this will not have reliable defaults.
    pub maximum_edition: crate::Edition,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FeatureSetDefaults {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [defaults][crate::FeatureSetDefaults::defaults].
    pub fn set_defaults<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::feature_set_defaults::FeatureSetEditionDefault>,
    {
        use std::iter::Iterator;
        self.defaults = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [minimum_edition][crate::FeatureSetDefaults::minimum_edition].
    pub fn set_minimum_edition<T: std::convert::Into<crate::Edition>>(mut self, v: T) -> Self {
        self.minimum_edition = v.into();
        self
    }

    /// Sets the value of [maximum_edition][crate::FeatureSetDefaults::maximum_edition].
    pub fn set_maximum_edition<T: std::convert::Into<crate::Edition>>(mut self, v: T) -> Self {
        self.maximum_edition = v.into();
        self
    }
}

impl wkt::message::Message for FeatureSetDefaults {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.FeatureSetDefaults"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for FeatureSetDefaults {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __defaults,
            __minimum_edition,
            __maximum_edition,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for FeatureSetDefaults")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "defaults" => Ok(__FieldTag::__defaults),
                            "minimumEdition" => Ok(__FieldTag::__minimum_edition),
                            "minimum_edition" => Ok(__FieldTag::__minimum_edition),
                            "maximumEdition" => Ok(__FieldTag::__maximum_edition),
                            "maximum_edition" => Ok(__FieldTag::__maximum_edition),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = FeatureSetDefaults;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct FeatureSetDefaults")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__defaults => {
                            if !fields.insert(__FieldTag::__defaults) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for defaults",
                                ));
                            }
                            result.defaults = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<
                                        crate::feature_set_defaults::FeatureSetEditionDefault,
                                    >,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__minimum_edition => {
                            if !fields.insert(__FieldTag::__minimum_edition) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for minimum_edition",
                                ));
                            }
                            result.minimum_edition = map
                                .next_value::<std::option::Option<crate::Edition>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__maximum_edition => {
                            if !fields.insert(__FieldTag::__maximum_edition) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for maximum_edition",
                                ));
                            }
                            result.maximum_edition = map
                                .next_value::<std::option::Option<crate::Edition>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for FeatureSetDefaults {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.defaults.is_empty() {
            state.serialize_entry("defaults", &self.defaults)?;
        }
        if !wkt::internal::is_default(&self.minimum_edition) {
            state.serialize_entry("minimumEdition", &self.minimum_edition)?;
        }
        if !wkt::internal::is_default(&self.maximum_edition) {
            state.serialize_entry("maximumEdition", &self.maximum_edition)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for FeatureSetDefaults {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FeatureSetDefaults");
        debug_struct.field("defaults", &self.defaults);
        debug_struct.field("minimum_edition", &self.minimum_edition);
        debug_struct.field("maximum_edition", &self.maximum_edition);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [FeatureSetDefaults].
pub mod feature_set_defaults {
    #[allow(unused_imports)]
    use super::*;

    /// A map from every known edition with a unique set of defaults to its
    /// defaults. Not all editions may be contained here.  For a given edition,
    /// the defaults at the closest matching edition ordered at or before it should
    /// be used.  This field must be in strict ascending order by edition.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct FeatureSetEditionDefault {
        pub edition: crate::Edition,

        /// Defaults of features that can be overridden in this edition.
        pub overridable_features: std::option::Option<crate::FeatureSet>,

        /// Defaults of features that can't be overridden in this edition.
        pub fixed_features: std::option::Option<crate::FeatureSet>,

        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl FeatureSetEditionDefault {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [edition][crate::feature_set_defaults::FeatureSetEditionDefault::edition].
        pub fn set_edition<T: std::convert::Into<crate::Edition>>(mut self, v: T) -> Self {
            self.edition = v.into();
            self
        }

        /// Sets the value of [overridable_features][crate::feature_set_defaults::FeatureSetEditionDefault::overridable_features].
        pub fn set_overridable_features<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::FeatureSet>,
        {
            self.overridable_features = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [overridable_features][crate::feature_set_defaults::FeatureSetEditionDefault::overridable_features].
        pub fn set_or_clear_overridable_features<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::FeatureSet>,
        {
            self.overridable_features = v.map(|x| x.into());
            self
        }

        /// Sets the value of [fixed_features][crate::feature_set_defaults::FeatureSetEditionDefault::fixed_features].
        pub fn set_fixed_features<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::FeatureSet>,
        {
            self.fixed_features = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [fixed_features][crate::feature_set_defaults::FeatureSetEditionDefault::fixed_features].
        pub fn set_or_clear_fixed_features<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::FeatureSet>,
        {
            self.fixed_features = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for FeatureSetEditionDefault {
        fn typename() -> &'static str {
            "type.googleapis.com/google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault"
        }
    }

    #[doc(hidden)]
    impl<'de> serde::de::Deserialize<'de> for FeatureSetEditionDefault {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            #[allow(non_camel_case_types)]
            #[doc(hidden)]
            #[derive(PartialEq, Eq, Hash)]
            enum __FieldTag {
                __edition,
                __overridable_features,
                __fixed_features,
                Unknown(std::string::String),
            }
            impl<'de> serde::de::Deserialize<'de> for __FieldTag {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    struct Visitor;
                    impl<'de> serde::de::Visitor<'de> for Visitor {
                        type Value = __FieldTag;
                        fn expecting(
                            &self,
                            formatter: &mut std::fmt::Formatter,
                        ) -> std::fmt::Result {
                            formatter.write_str("a field name for FeatureSetEditionDefault")
                        }
                        fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                        where
                            E: serde::de::Error,
                        {
                            use std::result::Result::Ok;
                            use std::string::ToString;
                            match value {
                                "edition" => Ok(__FieldTag::__edition),
                                "overridableFeatures" => Ok(__FieldTag::__overridable_features),
                                "overridable_features" => Ok(__FieldTag::__overridable_features),
                                "fixedFeatures" => Ok(__FieldTag::__fixed_features),
                                "fixed_features" => Ok(__FieldTag::__fixed_features),
                                _ => Ok(__FieldTag::Unknown(value.to_string())),
                            }
                        }
                    }
                    deserializer.deserialize_identifier(Visitor)
                }
            }
            struct Visitor;
            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = FeatureSetEditionDefault;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct FeatureSetEditionDefault")
                }
                fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
                where
                    A: serde::de::MapAccess<'de>,
                {
                    #[allow(unused_imports)]
                    use serde::de::Error;
                    use std::option::Option::Some;
                    let mut fields = std::collections::HashSet::new();
                    let mut result = Self::Value::new();
                    while let Some(tag) = map.next_key::<__FieldTag>()? {
                        #[allow(clippy::match_single_binding)]
                        match tag {
                            __FieldTag::__edition => {
                                if !fields.insert(__FieldTag::__edition) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for edition",
                                    ));
                                }
                                result.edition = map
                                    .next_value::<std::option::Option<crate::Edition>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__overridable_features => {
                                if !fields.insert(__FieldTag::__overridable_features) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for overridable_features",
                                    ));
                                }
                                result.overridable_features =
                                    map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                            }
                            __FieldTag::__fixed_features => {
                                if !fields.insert(__FieldTag::__fixed_features) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for fixed_features",
                                    ));
                                }
                                result.fixed_features =
                                    map.next_value::<std::option::Option<crate::FeatureSet>>()?;
                            }
                            __FieldTag::Unknown(key) => {
                                let value = map.next_value::<serde_json::Value>()?;
                                result._unknown_fields.insert(key, value);
                            }
                        }
                    }
                    std::result::Result::Ok(result)
                }
            }
            deserializer.deserialize_any(Visitor)
        }
    }

    #[doc(hidden)]
    impl serde::ser::Serialize for FeatureSetEditionDefault {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
        {
            use serde::ser::SerializeMap;
            #[allow(unused_imports)]
            use std::option::Option::Some;
            let mut state = serializer.serialize_map(std::option::Option::None)?;
            if !wkt::internal::is_default(&self.edition) {
                state.serialize_entry("edition", &self.edition)?;
            }
            if self.overridable_features.is_some() {
                state.serialize_entry("overridableFeatures", &self.overridable_features)?;
            }
            if self.fixed_features.is_some() {
                state.serialize_entry("fixedFeatures", &self.fixed_features)?;
            }
            if !self._unknown_fields.is_empty() {
                for (key, value) in self._unknown_fields.iter() {
                    state.serialize_entry(key, &value)?;
                }
            }
            state.end()
        }
    }

    impl std::fmt::Debug for FeatureSetEditionDefault {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut debug_struct = f.debug_struct("FeatureSetEditionDefault");
            debug_struct.field("edition", &self.edition);
            debug_struct.field("overridable_features", &self.overridable_features);
            debug_struct.field("fixed_features", &self.fixed_features);
            if !self._unknown_fields.is_empty() {
                debug_struct.field("_unknown_fields", &self._unknown_fields);
            }
            debug_struct.finish()
        }
    }
}

/// Encapsulates information about the original source file from which a
/// FileDescriptorProto was generated.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SourceCodeInfo {
    /// A Location identifies a piece of source code in a .proto file which
    /// corresponds to a particular definition.  This information is intended
    /// to be useful to IDEs, code indexers, documentation generators, and similar
    /// tools.
    ///
    /// For example, say we have a file like:
    /// message Foo {
    /// optional string foo = 1;
    /// }
    /// Let's look at just the field definition:
    /// optional string foo = 1;
    /// ^       ^^     ^^  ^  ^^^
    /// a       bc     de  f  ghi
    /// We have the following locations:
    /// span   path               represents
    /// [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
    /// [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
    /// [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
    /// [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
    /// [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
    ///
    /// Notes:
    ///
    /// - A location may refer to a repeated field itself (i.e. not to any
    ///   particular index within it).  This is used whenever a set of elements are
    ///   logically enclosed in a single code segment.  For example, an entire
    ///   extend block (possibly containing multiple extension definitions) will
    ///   have an outer location whose path refers to the "extensions" repeated
    ///   field without an index.
    /// - Multiple locations may have the same path.  This happens when a single
    ///   logical declaration is spread out across multiple places.  The most
    ///   obvious example is the "extend" block again -- there may be multiple
    ///   extend blocks in the same scope, each of which will have the same path.
    /// - A location's span is not always a subset of its parent's span.  For
    ///   example, the "extendee" of an extension declaration appears at the
    ///   beginning of the "extend" block and is shared by all extensions within
    ///   the block.
    /// - Just because a location's span is a subset of some other location's span
    ///   does not mean that it is a descendant.  For example, a "group" defines
    ///   both a type and a field in a single declaration.  Thus, the locations
    ///   corresponding to the type and field and their components will overlap.
    /// - Code which tries to interpret locations should probably be designed to
    ///   ignore those that it doesn't understand, as more types of locations could
    ///   be recorded in the future.
    pub location: std::vec::Vec<crate::source_code_info::Location>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SourceCodeInfo {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [location][crate::SourceCodeInfo::location].
    pub fn set_location<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::source_code_info::Location>,
    {
        use std::iter::Iterator;
        self.location = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for SourceCodeInfo {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.SourceCodeInfo"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for SourceCodeInfo {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __location,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for SourceCodeInfo")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "location" => Ok(__FieldTag::__location),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = SourceCodeInfo;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct SourceCodeInfo")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__location => {
                            if !fields.insert(__FieldTag::__location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for location",
                                ));
                            }
                            result.location = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::source_code_info::Location>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for SourceCodeInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.location.is_empty() {
            state.serialize_entry("location", &self.location)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for SourceCodeInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SourceCodeInfo");
        debug_struct.field("location", &self.location);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [SourceCodeInfo].
pub mod source_code_info {
    #[allow(unused_imports)]
    use super::*;

    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Location {
        /// Identifies which part of the FileDescriptorProto was defined at this
        /// location.
        ///
        /// Each element is a field number or an index.  They form a path from
        /// the root FileDescriptorProto to the place where the definition appears.
        /// For example, this path:
        /// [ 4, 3, 2, 7, 1 ]
        /// refers to:
        /// file.message_type(3)  // 4, 3
        /// .field(7)         // 2, 7
        /// .name()           // 1
        /// This is because FileDescriptorProto.message_type has field number 4:
        /// repeated DescriptorProto message_type = 4;
        /// and DescriptorProto.field has field number 2:
        /// repeated FieldDescriptorProto field = 2;
        /// and FieldDescriptorProto.name has field number 1:
        /// optional string name = 1;
        ///
        /// Thus, the above path gives the location of a field name.  If we removed
        /// the last element:
        /// [ 4, 3, 2, 7 ]
        /// this path refers to the whole field declaration (from the beginning
        /// of the label to the terminating semicolon).
        pub path: std::vec::Vec<i32>,

        /// Always has exactly three or four elements: start line, start column,
        /// end line (optional, otherwise assumed same as start line), end column.
        /// These are packed into a single field for efficiency.  Note that line
        /// and column numbers are zero-based -- typically you will want to add
        /// 1 to each before displaying to a user.
        pub span: std::vec::Vec<i32>,

        /// If this SourceCodeInfo represents a complete declaration, these are any
        /// comments appearing before and after the declaration which appear to be
        /// attached to the declaration.
        ///
        /// A series of line comments appearing on consecutive lines, with no other
        /// tokens appearing on those lines, will be treated as a single comment.
        ///
        /// leading_detached_comments will keep paragraphs of comments that appear
        /// before (but not connected to) the current element. Each paragraph,
        /// separated by empty lines, will be one comment element in the repeated
        /// field.
        ///
        /// Only the comment content is provided; comment markers (e.g. //) are
        /// stripped out.  For block comments, leading whitespace and an asterisk
        /// will be stripped from the beginning of each line other than the first.
        /// Newlines are included in the output.
        ///
        /// Examples:
        ///
        /// optional int32 foo = 1;  // Comment attached to foo.
        /// // Comment attached to bar.
        /// optional int32 bar = 2;
        ///
        /// optional string baz = 3;
        /// // Comment attached to baz.
        /// // Another line attached to baz.
        ///
        /// // Comment attached to moo.
        /// //
        /// // Another line attached to moo.
        /// optional double moo = 4;
        ///
        /// // Detached comment for corge. This is not leading or trailing comments
        /// // to moo or corge because there are blank lines separating it from
        /// // both.
        ///
        /// // Detached comment for corge paragraph 2.
        ///
        /// optional string corge = 5;
        /// /* Block comment attached
        ///
        /// * to corge.  Leading asterisks
        /// * will be removed. */
        ///   /* Block comment attached to
        /// * grault. */
        ///   optional int32 grault = 6;
        ///
        /// // ignored detached comments.
        pub leading_comments: std::string::String,

        pub trailing_comments: std::string::String,

        pub leading_detached_comments: std::vec::Vec<std::string::String>,

        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl Location {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [path][crate::source_code_info::Location::path].
        pub fn set_path<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<i32>,
        {
            use std::iter::Iterator;
            self.path = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [span][crate::source_code_info::Location::span].
        pub fn set_span<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<i32>,
        {
            use std::iter::Iterator;
            self.span = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [leading_comments][crate::source_code_info::Location::leading_comments].
        pub fn set_leading_comments<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.leading_comments = v.into();
            self
        }

        /// Sets the value of [trailing_comments][crate::source_code_info::Location::trailing_comments].
        pub fn set_trailing_comments<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.trailing_comments = v.into();
            self
        }

        /// Sets the value of [leading_detached_comments][crate::source_code_info::Location::leading_detached_comments].
        pub fn set_leading_detached_comments<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<std::string::String>,
        {
            use std::iter::Iterator;
            self.leading_detached_comments = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for Location {
        fn typename() -> &'static str {
            "type.googleapis.com/google.protobuf.SourceCodeInfo.Location"
        }
    }

    #[doc(hidden)]
    impl<'de> serde::de::Deserialize<'de> for Location {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            #[allow(non_camel_case_types)]
            #[doc(hidden)]
            #[derive(PartialEq, Eq, Hash)]
            enum __FieldTag {
                __path,
                __span,
                __leading_comments,
                __trailing_comments,
                __leading_detached_comments,
                Unknown(std::string::String),
            }
            impl<'de> serde::de::Deserialize<'de> for __FieldTag {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    struct Visitor;
                    impl<'de> serde::de::Visitor<'de> for Visitor {
                        type Value = __FieldTag;
                        fn expecting(
                            &self,
                            formatter: &mut std::fmt::Formatter,
                        ) -> std::fmt::Result {
                            formatter.write_str("a field name for Location")
                        }
                        fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                        where
                            E: serde::de::Error,
                        {
                            use std::result::Result::Ok;
                            use std::string::ToString;
                            match value {
                                "path" => Ok(__FieldTag::__path),
                                "span" => Ok(__FieldTag::__span),
                                "leadingComments" => Ok(__FieldTag::__leading_comments),
                                "leading_comments" => Ok(__FieldTag::__leading_comments),
                                "trailingComments" => Ok(__FieldTag::__trailing_comments),
                                "trailing_comments" => Ok(__FieldTag::__trailing_comments),
                                "leadingDetachedComments" => {
                                    Ok(__FieldTag::__leading_detached_comments)
                                }
                                "leading_detached_comments" => {
                                    Ok(__FieldTag::__leading_detached_comments)
                                }
                                _ => Ok(__FieldTag::Unknown(value.to_string())),
                            }
                        }
                    }
                    deserializer.deserialize_identifier(Visitor)
                }
            }
            struct Visitor;
            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = Location;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct Location")
                }
                fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
                where
                    A: serde::de::MapAccess<'de>,
                {
                    #[allow(unused_imports)]
                    use serde::de::Error;
                    use std::option::Option::Some;
                    let mut fields = std::collections::HashSet::new();
                    let mut result = Self::Value::new();
                    while let Some(tag) = map.next_key::<__FieldTag>()? {
                        #[allow(clippy::match_single_binding)]
                        match tag {
                            __FieldTag::__path => {
                                if !fields.insert(__FieldTag::__path) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for path",
                                    ));
                                }
                                struct __With(std::option::Option<std::vec::Vec<i32>>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::<
                                            std::option::Option<std::vec::Vec<wkt::internal::I32>>,
                                        >::deserialize(
                                            deserializer
                                        )
                                        .map(__With)
                                    }
                                }
                                result.path = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::__span => {
                                if !fields.insert(__FieldTag::__span) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for span",
                                    ));
                                }
                                struct __With(std::option::Option<std::vec::Vec<i32>>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::<
                                            std::option::Option<std::vec::Vec<wkt::internal::I32>>,
                                        >::deserialize(
                                            deserializer
                                        )
                                        .map(__With)
                                    }
                                }
                                result.span = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::__leading_comments => {
                                if !fields.insert(__FieldTag::__leading_comments) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for leading_comments",
                                    ));
                                }
                                result.leading_comments = map
                                    .next_value::<std::option::Option<std::string::String>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__trailing_comments => {
                                if !fields.insert(__FieldTag::__trailing_comments) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for trailing_comments",
                                    ));
                                }
                                result.trailing_comments = map
                                    .next_value::<std::option::Option<std::string::String>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__leading_detached_comments => {
                                if !fields.insert(__FieldTag::__leading_detached_comments) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for leading_detached_comments",
                                    ));
                                }
                                result.leading_detached_comments = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
                            }
                            __FieldTag::Unknown(key) => {
                                let value = map.next_value::<serde_json::Value>()?;
                                result._unknown_fields.insert(key, value);
                            }
                        }
                    }
                    std::result::Result::Ok(result)
                }
            }
            deserializer.deserialize_any(Visitor)
        }
    }

    #[doc(hidden)]
    impl serde::ser::Serialize for Location {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
        {
            use serde::ser::SerializeMap;
            #[allow(unused_imports)]
            use std::option::Option::Some;
            let mut state = serializer.serialize_map(std::option::Option::None)?;
            if !self.path.is_empty() {
                struct __With<'a>(&'a std::vec::Vec<i32>);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<std::vec::Vec<wkt::internal::I32>>::serialize(
                            self.0, serializer,
                        )
                    }
                }
                state.serialize_entry("path", &__With(&self.path))?;
            }
            if !self.span.is_empty() {
                struct __With<'a>(&'a std::vec::Vec<i32>);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<std::vec::Vec<wkt::internal::I32>>::serialize(
                            self.0, serializer,
                        )
                    }
                }
                state.serialize_entry("span", &__With(&self.span))?;
            }
            if !self.leading_comments.is_empty() {
                state.serialize_entry("leadingComments", &self.leading_comments)?;
            }
            if !self.trailing_comments.is_empty() {
                state.serialize_entry("trailingComments", &self.trailing_comments)?;
            }
            if !self.leading_detached_comments.is_empty() {
                state
                    .serialize_entry("leadingDetachedComments", &self.leading_detached_comments)?;
            }
            if !self._unknown_fields.is_empty() {
                for (key, value) in self._unknown_fields.iter() {
                    state.serialize_entry(key, &value)?;
                }
            }
            state.end()
        }
    }

    impl std::fmt::Debug for Location {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut debug_struct = f.debug_struct("Location");
            debug_struct.field("path", &self.path);
            debug_struct.field("span", &self.span);
            debug_struct.field("leading_comments", &self.leading_comments);
            debug_struct.field("trailing_comments", &self.trailing_comments);
            debug_struct.field("leading_detached_comments", &self.leading_detached_comments);
            if !self._unknown_fields.is_empty() {
                debug_struct.field("_unknown_fields", &self._unknown_fields);
            }
            debug_struct.finish()
        }
    }
}

/// Describes the relationship between generated code and its original source
/// file. A GeneratedCodeInfo message is associated with only one generated
/// source file, but may contain references to different source .proto files.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GeneratedCodeInfo {
    /// An Annotation connects some span of text in generated code to an element
    /// of its generating .proto file.
    pub annotation: std::vec::Vec<crate::generated_code_info::Annotation>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GeneratedCodeInfo {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [annotation][crate::GeneratedCodeInfo::annotation].
    pub fn set_annotation<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::generated_code_info::Annotation>,
    {
        use std::iter::Iterator;
        self.annotation = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for GeneratedCodeInfo {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.GeneratedCodeInfo"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for GeneratedCodeInfo {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __annotation,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for GeneratedCodeInfo")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "annotation" => Ok(__FieldTag::__annotation),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = GeneratedCodeInfo;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct GeneratedCodeInfo")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__annotation => {
                            if !fields.insert(__FieldTag::__annotation) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for annotation",
                                ));
                            }
                            result.annotation = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::generated_code_info::Annotation>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for GeneratedCodeInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.annotation.is_empty() {
            state.serialize_entry("annotation", &self.annotation)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for GeneratedCodeInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GeneratedCodeInfo");
        debug_struct.field("annotation", &self.annotation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [GeneratedCodeInfo].
pub mod generated_code_info {
    #[allow(unused_imports)]
    use super::*;

    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Annotation {
        /// Identifies the element in the original source .proto file. This field
        /// is formatted the same as SourceCodeInfo.Location.path.
        pub path: std::vec::Vec<i32>,

        /// Identifies the filesystem path to the original source .proto.
        pub source_file: std::string::String,

        /// Identifies the starting offset in bytes in the generated code
        /// that relates to the identified object.
        pub begin: i32,

        /// Identifies the ending offset in bytes in the generated code that
        /// relates to the identified object. The end offset should be one past
        /// the last relevant byte (so the length of the text = end - begin).
        pub end: i32,

        pub semantic: crate::generated_code_info::annotation::Semantic,

        _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl Annotation {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [path][crate::generated_code_info::Annotation::path].
        pub fn set_path<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<i32>,
        {
            use std::iter::Iterator;
            self.path = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [source_file][crate::generated_code_info::Annotation::source_file].
        pub fn set_source_file<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.source_file = v.into();
            self
        }

        /// Sets the value of [begin][crate::generated_code_info::Annotation::begin].
        pub fn set_begin<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.begin = v.into();
            self
        }

        /// Sets the value of [end][crate::generated_code_info::Annotation::end].
        pub fn set_end<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.end = v.into();
            self
        }

        /// Sets the value of [semantic][crate::generated_code_info::Annotation::semantic].
        pub fn set_semantic<
            T: std::convert::Into<crate::generated_code_info::annotation::Semantic>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.semantic = v.into();
            self
        }
    }

    impl wkt::message::Message for Annotation {
        fn typename() -> &'static str {
            "type.googleapis.com/google.protobuf.GeneratedCodeInfo.Annotation"
        }
    }

    #[doc(hidden)]
    impl<'de> serde::de::Deserialize<'de> for Annotation {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            #[allow(non_camel_case_types)]
            #[doc(hidden)]
            #[derive(PartialEq, Eq, Hash)]
            enum __FieldTag {
                __path,
                __source_file,
                __begin,
                __end,
                __semantic,
                Unknown(std::string::String),
            }
            impl<'de> serde::de::Deserialize<'de> for __FieldTag {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    struct Visitor;
                    impl<'de> serde::de::Visitor<'de> for Visitor {
                        type Value = __FieldTag;
                        fn expecting(
                            &self,
                            formatter: &mut std::fmt::Formatter,
                        ) -> std::fmt::Result {
                            formatter.write_str("a field name for Annotation")
                        }
                        fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                        where
                            E: serde::de::Error,
                        {
                            use std::result::Result::Ok;
                            use std::string::ToString;
                            match value {
                                "path" => Ok(__FieldTag::__path),
                                "sourceFile" => Ok(__FieldTag::__source_file),
                                "source_file" => Ok(__FieldTag::__source_file),
                                "begin" => Ok(__FieldTag::__begin),
                                "end" => Ok(__FieldTag::__end),
                                "semantic" => Ok(__FieldTag::__semantic),
                                _ => Ok(__FieldTag::Unknown(value.to_string())),
                            }
                        }
                    }
                    deserializer.deserialize_identifier(Visitor)
                }
            }
            struct Visitor;
            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = Annotation;
                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("struct Annotation")
                }
                fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
                where
                    A: serde::de::MapAccess<'de>,
                {
                    #[allow(unused_imports)]
                    use serde::de::Error;
                    use std::option::Option::Some;
                    let mut fields = std::collections::HashSet::new();
                    let mut result = Self::Value::new();
                    while let Some(tag) = map.next_key::<__FieldTag>()? {
                        #[allow(clippy::match_single_binding)]
                        match tag {
                            __FieldTag::__path => {
                                if !fields.insert(__FieldTag::__path) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for path",
                                    ));
                                }
                                struct __With(std::option::Option<std::vec::Vec<i32>>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::<
                                            std::option::Option<std::vec::Vec<wkt::internal::I32>>,
                                        >::deserialize(
                                            deserializer
                                        )
                                        .map(__With)
                                    }
                                }
                                result.path = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::__source_file => {
                                if !fields.insert(__FieldTag::__source_file) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for source_file",
                                    ));
                                }
                                result.source_file = map
                                    .next_value::<std::option::Option<std::string::String>>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::__begin => {
                                if !fields.insert(__FieldTag::__begin) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for begin",
                                    ));
                                }
                                struct __With(std::option::Option<i32>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                    }
                                }
                                result.begin = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::__end => {
                                if !fields.insert(__FieldTag::__end) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for end",
                                    ));
                                }
                                struct __With(std::option::Option<i32>);
                                impl<'de> serde::de::Deserialize<'de> for __With {
                                    fn deserialize<D>(
                                        deserializer: D,
                                    ) -> std::result::Result<Self, D::Error>
                                    where
                                        D: serde::de::Deserializer<'de>,
                                    {
                                        serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                    }
                                }
                                result.end = map.next_value::<__With>()?.0.unwrap_or_default();
                            }
                            __FieldTag::__semantic => {
                                if !fields.insert(__FieldTag::__semantic) {
                                    return std::result::Result::Err(A::Error::duplicate_field(
                                        "multiple values for semantic",
                                    ));
                                }
                                result.semantic = map
                                    .next_value::<std::option::Option<
                                        crate::generated_code_info::annotation::Semantic,
                                    >>()?
                                    .unwrap_or_default();
                            }
                            __FieldTag::Unknown(key) => {
                                let value = map.next_value::<serde_json::Value>()?;
                                result._unknown_fields.insert(key, value);
                            }
                        }
                    }
                    std::result::Result::Ok(result)
                }
            }
            deserializer.deserialize_any(Visitor)
        }
    }

    #[doc(hidden)]
    impl serde::ser::Serialize for Annotation {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::ser::Serializer,
        {
            use serde::ser::SerializeMap;
            #[allow(unused_imports)]
            use std::option::Option::Some;
            let mut state = serializer.serialize_map(std::option::Option::None)?;
            if !self.path.is_empty() {
                struct __With<'a>(&'a std::vec::Vec<i32>);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<std::vec::Vec<wkt::internal::I32>>::serialize(
                            self.0, serializer,
                        )
                    }
                }
                state.serialize_entry("path", &__With(&self.path))?;
            }
            if !self.source_file.is_empty() {
                state.serialize_entry("sourceFile", &self.source_file)?;
            }
            if !wkt::internal::is_default(&self.begin) {
                struct __With<'a>(&'a i32);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                    }
                }
                state.serialize_entry("begin", &__With(&self.begin))?;
            }
            if !wkt::internal::is_default(&self.end) {
                struct __With<'a>(&'a i32);
                impl<'a> serde::ser::Serialize for __With<'a> {
                    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                    where
                        S: serde::ser::Serializer,
                    {
                        serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                    }
                }
                state.serialize_entry("end", &__With(&self.end))?;
            }
            if !wkt::internal::is_default(&self.semantic) {
                state.serialize_entry("semantic", &self.semantic)?;
            }
            if !self._unknown_fields.is_empty() {
                for (key, value) in self._unknown_fields.iter() {
                    state.serialize_entry(key, &value)?;
                }
            }
            state.end()
        }
    }

    impl std::fmt::Debug for Annotation {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            let mut debug_struct = f.debug_struct("Annotation");
            debug_struct.field("path", &self.path);
            debug_struct.field("source_file", &self.source_file);
            debug_struct.field("begin", &self.begin);
            debug_struct.field("end", &self.end);
            debug_struct.field("semantic", &self.semantic);
            if !self._unknown_fields.is_empty() {
                debug_struct.field("_unknown_fields", &self._unknown_fields);
            }
            debug_struct.finish()
        }
    }

    /// Defines additional types related to [Annotation].
    pub mod annotation {
        #[allow(unused_imports)]
        use super::*;

        /// Represents the identified object's effect on the element in the original
        /// .proto file.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Semantic {
            /// There is no effect or the effect is indescribable.
            None,
            /// The element is set or otherwise mutated.
            Set,
            /// An alias to the element is returned.
            Alias,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Semantic::value] or
            /// [Semantic::name].
            UnknownValue(semantic::UnknownValue),
        }

        #[doc(hidden)]
        pub mod semantic {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl Semantic {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::None => std::option::Option::Some(0),
                    Self::Set => std::option::Option::Some(1),
                    Self::Alias => std::option::Option::Some(2),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::None => std::option::Option::Some("NONE"),
                    Self::Set => std::option::Option::Some("SET"),
                    Self::Alias => std::option::Option::Some("ALIAS"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for Semantic {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for Semantic {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for Semantic {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::None,
                    1 => Self::Set,
                    2 => Self::Alias,
                    _ => Self::UnknownValue(semantic::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Semantic {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "NONE" => Self::None,
                    "SET" => Self::Set,
                    "ALIAS" => Self::Alias,
                    _ => Self::UnknownValue(semantic::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for Semantic {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::None => serializer.serialize_i32(0),
                    Self::Set => serializer.serialize_i32(1),
                    Self::Alias => serializer.serialize_i32(2),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for Semantic {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<Semantic>::new(
                    ".google.protobuf.GeneratedCodeInfo.Annotation.Semantic",
                ))
            }
        }
    }
}

/// `SourceContext` represents information about the source of a
/// protobuf element, like the file in which it is defined.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SourceContext {
    /// The path-qualified name of the .proto file that contained the associated
    /// protobuf element.  For example: `"google/protobuf/source_context.proto"`.
    pub file_name: std::string::String,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SourceContext {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [file_name][crate::SourceContext::file_name].
    pub fn set_file_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.file_name = v.into();
        self
    }
}

impl wkt::message::Message for SourceContext {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.SourceContext"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for SourceContext {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __file_name,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for SourceContext")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "fileName" => Ok(__FieldTag::__file_name),
                            "file_name" => Ok(__FieldTag::__file_name),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = SourceContext;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct SourceContext")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__file_name => {
                            if !fields.insert(__FieldTag::__file_name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for file_name",
                                ));
                            }
                            result.file_name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for SourceContext {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.file_name.is_empty() {
            state.serialize_entry("fileName", &self.file_name)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for SourceContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SourceContext");
        debug_struct.field("file_name", &self.file_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// A protocol buffer message type.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Type {
    /// The fully qualified message name.
    pub name: std::string::String,

    /// The list of fields.
    pub fields: std::vec::Vec<crate::Field>,

    /// The list of types appearing in `oneof` definitions in this type.
    pub oneofs: std::vec::Vec<std::string::String>,

    /// The protocol buffer options.
    pub options: std::vec::Vec<crate::Option>,

    /// The source context.
    pub source_context: std::option::Option<crate::SourceContext>,

    /// The source syntax.
    pub syntax: crate::Syntax,

    /// The source edition string, only valid when syntax is SYNTAX_EDITIONS.
    pub edition: std::string::String,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Type {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::Type::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [fields][crate::Type::fields].
    pub fn set_fields<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::Field>,
    {
        use std::iter::Iterator;
        self.fields = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [oneofs][crate::Type::oneofs].
    pub fn set_oneofs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.oneofs = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [options][crate::Type::options].
    pub fn set_options<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::Option>,
    {
        use std::iter::Iterator;
        self.options = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [source_context][crate::Type::source_context].
    pub fn set_source_context<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::SourceContext>,
    {
        self.source_context = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [source_context][crate::Type::source_context].
    pub fn set_or_clear_source_context<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::SourceContext>,
    {
        self.source_context = v.map(|x| x.into());
        self
    }

    /// Sets the value of [syntax][crate::Type::syntax].
    pub fn set_syntax<T: std::convert::Into<crate::Syntax>>(mut self, v: T) -> Self {
        self.syntax = v.into();
        self
    }

    /// Sets the value of [edition][crate::Type::edition].
    pub fn set_edition<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.edition = v.into();
        self
    }
}

impl wkt::message::Message for Type {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.Type"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for Type {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __fields,
            __oneofs,
            __options,
            __source_context,
            __syntax,
            __edition,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for Type")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "fields" => Ok(__FieldTag::__fields),
                            "oneofs" => Ok(__FieldTag::__oneofs),
                            "options" => Ok(__FieldTag::__options),
                            "sourceContext" => Ok(__FieldTag::__source_context),
                            "source_context" => Ok(__FieldTag::__source_context),
                            "syntax" => Ok(__FieldTag::__syntax),
                            "edition" => Ok(__FieldTag::__edition),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = Type;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Type")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__fields => {
                            if !fields.insert(__FieldTag::__fields) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for fields",
                                ));
                            }
                            result.fields = map
                                .next_value::<std::option::Option<std::vec::Vec<crate::Field>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__oneofs => {
                            if !fields.insert(__FieldTag::__oneofs) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for oneofs",
                                ));
                            }
                            result.oneofs = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options = map
                                .next_value::<std::option::Option<std::vec::Vec<crate::Option>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__source_context => {
                            if !fields.insert(__FieldTag::__source_context) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for source_context",
                                ));
                            }
                            result.source_context =
                                map.next_value::<std::option::Option<crate::SourceContext>>()?;
                        }
                        __FieldTag::__syntax => {
                            if !fields.insert(__FieldTag::__syntax) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for syntax",
                                ));
                            }
                            result.syntax = map
                                .next_value::<std::option::Option<crate::Syntax>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__edition => {
                            if !fields.insert(__FieldTag::__edition) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for edition",
                                ));
                            }
                            result.edition = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for Type {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.fields.is_empty() {
            state.serialize_entry("fields", &self.fields)?;
        }
        if !self.oneofs.is_empty() {
            state.serialize_entry("oneofs", &self.oneofs)?;
        }
        if !self.options.is_empty() {
            state.serialize_entry("options", &self.options)?;
        }
        if self.source_context.is_some() {
            state.serialize_entry("sourceContext", &self.source_context)?;
        }
        if !wkt::internal::is_default(&self.syntax) {
            state.serialize_entry("syntax", &self.syntax)?;
        }
        if !self.edition.is_empty() {
            state.serialize_entry("edition", &self.edition)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for Type {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Type");
        debug_struct.field("name", &self.name);
        debug_struct.field("fields", &self.fields);
        debug_struct.field("oneofs", &self.oneofs);
        debug_struct.field("options", &self.options);
        debug_struct.field("source_context", &self.source_context);
        debug_struct.field("syntax", &self.syntax);
        debug_struct.field("edition", &self.edition);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// A single field of a message type.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Field {
    /// The field type.
    pub kind: crate::field::Kind,

    /// The field cardinality.
    pub cardinality: crate::field::Cardinality,

    /// The field number.
    pub number: i32,

    /// The field name.
    pub name: std::string::String,

    /// The field type URL, without the scheme, for message or enumeration
    /// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
    pub type_url: std::string::String,

    /// The index of the field type in `Type.oneofs`, for message or enumeration
    /// types. The first type has index 1; zero means the type is not in the list.
    pub oneof_index: i32,

    /// Whether to use alternative packed wire representation.
    pub packed: bool,

    /// The protocol buffer options.
    pub options: std::vec::Vec<crate::Option>,

    /// The field JSON name.
    pub json_name: std::string::String,

    /// The string value of the default value of this field. Proto2 syntax only.
    pub default_value: std::string::String,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Field {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [kind][crate::Field::kind].
    pub fn set_kind<T: std::convert::Into<crate::field::Kind>>(mut self, v: T) -> Self {
        self.kind = v.into();
        self
    }

    /// Sets the value of [cardinality][crate::Field::cardinality].
    pub fn set_cardinality<T: std::convert::Into<crate::field::Cardinality>>(
        mut self,
        v: T,
    ) -> Self {
        self.cardinality = v.into();
        self
    }

    /// Sets the value of [number][crate::Field::number].
    pub fn set_number<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.number = v.into();
        self
    }

    /// Sets the value of [name][crate::Field::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [type_url][crate::Field::type_url].
    pub fn set_type_url<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.type_url = v.into();
        self
    }

    /// Sets the value of [oneof_index][crate::Field::oneof_index].
    pub fn set_oneof_index<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.oneof_index = v.into();
        self
    }

    /// Sets the value of [packed][crate::Field::packed].
    pub fn set_packed<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.packed = v.into();
        self
    }

    /// Sets the value of [options][crate::Field::options].
    pub fn set_options<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::Option>,
    {
        use std::iter::Iterator;
        self.options = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [json_name][crate::Field::json_name].
    pub fn set_json_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.json_name = v.into();
        self
    }

    /// Sets the value of [default_value][crate::Field::default_value].
    pub fn set_default_value<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.default_value = v.into();
        self
    }
}

impl wkt::message::Message for Field {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.Field"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for Field {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __kind,
            __cardinality,
            __number,
            __name,
            __type_url,
            __oneof_index,
            __packed,
            __options,
            __json_name,
            __default_value,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for Field")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "kind" => Ok(__FieldTag::__kind),
                            "cardinality" => Ok(__FieldTag::__cardinality),
                            "number" => Ok(__FieldTag::__number),
                            "name" => Ok(__FieldTag::__name),
                            "typeUrl" => Ok(__FieldTag::__type_url),
                            "type_url" => Ok(__FieldTag::__type_url),
                            "oneofIndex" => Ok(__FieldTag::__oneof_index),
                            "oneof_index" => Ok(__FieldTag::__oneof_index),
                            "packed" => Ok(__FieldTag::__packed),
                            "options" => Ok(__FieldTag::__options),
                            "jsonName" => Ok(__FieldTag::__json_name),
                            "json_name" => Ok(__FieldTag::__json_name),
                            "defaultValue" => Ok(__FieldTag::__default_value),
                            "default_value" => Ok(__FieldTag::__default_value),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = Field;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Field")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__kind => {
                            if !fields.insert(__FieldTag::__kind) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for kind",
                                ));
                            }
                            result.kind = map
                                .next_value::<std::option::Option<crate::field::Kind>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__cardinality => {
                            if !fields.insert(__FieldTag::__cardinality) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for cardinality",
                                ));
                            }
                            result.cardinality = map
                                .next_value::<std::option::Option<crate::field::Cardinality>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__number => {
                            if !fields.insert(__FieldTag::__number) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for number",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.number = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__type_url => {
                            if !fields.insert(__FieldTag::__type_url) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for type_url",
                                ));
                            }
                            result.type_url = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__oneof_index => {
                            if !fields.insert(__FieldTag::__oneof_index) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for oneof_index",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.oneof_index = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__packed => {
                            if !fields.insert(__FieldTag::__packed) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for packed",
                                ));
                            }
                            result.packed = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options = map
                                .next_value::<std::option::Option<std::vec::Vec<crate::Option>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__json_name => {
                            if !fields.insert(__FieldTag::__json_name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for json_name",
                                ));
                            }
                            result.json_name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__default_value => {
                            if !fields.insert(__FieldTag::__default_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for default_value",
                                ));
                            }
                            result.default_value = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for Field {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.kind) {
            state.serialize_entry("kind", &self.kind)?;
        }
        if !wkt::internal::is_default(&self.cardinality) {
            state.serialize_entry("cardinality", &self.cardinality)?;
        }
        if !wkt::internal::is_default(&self.number) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("number", &__With(&self.number))?;
        }
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.type_url.is_empty() {
            state.serialize_entry("typeUrl", &self.type_url)?;
        }
        if !wkt::internal::is_default(&self.oneof_index) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("oneofIndex", &__With(&self.oneof_index))?;
        }
        if !wkt::internal::is_default(&self.packed) {
            state.serialize_entry("packed", &self.packed)?;
        }
        if !self.options.is_empty() {
            state.serialize_entry("options", &self.options)?;
        }
        if !self.json_name.is_empty() {
            state.serialize_entry("jsonName", &self.json_name)?;
        }
        if !self.default_value.is_empty() {
            state.serialize_entry("defaultValue", &self.default_value)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for Field {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Field");
        debug_struct.field("kind", &self.kind);
        debug_struct.field("cardinality", &self.cardinality);
        debug_struct.field("number", &self.number);
        debug_struct.field("name", &self.name);
        debug_struct.field("type_url", &self.type_url);
        debug_struct.field("oneof_index", &self.oneof_index);
        debug_struct.field("packed", &self.packed);
        debug_struct.field("options", &self.options);
        debug_struct.field("json_name", &self.json_name);
        debug_struct.field("default_value", &self.default_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Defines additional types related to [Field].
pub mod field {
    #[allow(unused_imports)]
    use super::*;

    /// Basic field types.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Kind {
        /// Field type unknown.
        TypeUnknown,
        /// Field type double.
        TypeDouble,
        /// Field type float.
        TypeFloat,
        /// Field type int64.
        TypeInt64,
        /// Field type uint64.
        TypeUint64,
        /// Field type int32.
        TypeInt32,
        /// Field type fixed64.
        TypeFixed64,
        /// Field type fixed32.
        TypeFixed32,
        /// Field type bool.
        TypeBool,
        /// Field type string.
        TypeString,
        /// Field type group. Proto2 syntax only, and deprecated.
        TypeGroup,
        /// Field type message.
        TypeMessage,
        /// Field type bytes.
        TypeBytes,
        /// Field type uint32.
        TypeUint32,
        /// Field type enum.
        TypeEnum,
        /// Field type sfixed32.
        TypeSfixed32,
        /// Field type sfixed64.
        TypeSfixed64,
        /// Field type sint32.
        TypeSint32,
        /// Field type sint64.
        TypeSint64,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Kind::value] or
        /// [Kind::name].
        UnknownValue(kind::UnknownValue),
    }

    #[doc(hidden)]
    pub mod kind {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Kind {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::TypeUnknown => std::option::Option::Some(0),
                Self::TypeDouble => std::option::Option::Some(1),
                Self::TypeFloat => std::option::Option::Some(2),
                Self::TypeInt64 => std::option::Option::Some(3),
                Self::TypeUint64 => std::option::Option::Some(4),
                Self::TypeInt32 => std::option::Option::Some(5),
                Self::TypeFixed64 => std::option::Option::Some(6),
                Self::TypeFixed32 => std::option::Option::Some(7),
                Self::TypeBool => std::option::Option::Some(8),
                Self::TypeString => std::option::Option::Some(9),
                Self::TypeGroup => std::option::Option::Some(10),
                Self::TypeMessage => std::option::Option::Some(11),
                Self::TypeBytes => std::option::Option::Some(12),
                Self::TypeUint32 => std::option::Option::Some(13),
                Self::TypeEnum => std::option::Option::Some(14),
                Self::TypeSfixed32 => std::option::Option::Some(15),
                Self::TypeSfixed64 => std::option::Option::Some(16),
                Self::TypeSint32 => std::option::Option::Some(17),
                Self::TypeSint64 => std::option::Option::Some(18),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::TypeUnknown => std::option::Option::Some("TYPE_UNKNOWN"),
                Self::TypeDouble => std::option::Option::Some("TYPE_DOUBLE"),
                Self::TypeFloat => std::option::Option::Some("TYPE_FLOAT"),
                Self::TypeInt64 => std::option::Option::Some("TYPE_INT64"),
                Self::TypeUint64 => std::option::Option::Some("TYPE_UINT64"),
                Self::TypeInt32 => std::option::Option::Some("TYPE_INT32"),
                Self::TypeFixed64 => std::option::Option::Some("TYPE_FIXED64"),
                Self::TypeFixed32 => std::option::Option::Some("TYPE_FIXED32"),
                Self::TypeBool => std::option::Option::Some("TYPE_BOOL"),
                Self::TypeString => std::option::Option::Some("TYPE_STRING"),
                Self::TypeGroup => std::option::Option::Some("TYPE_GROUP"),
                Self::TypeMessage => std::option::Option::Some("TYPE_MESSAGE"),
                Self::TypeBytes => std::option::Option::Some("TYPE_BYTES"),
                Self::TypeUint32 => std::option::Option::Some("TYPE_UINT32"),
                Self::TypeEnum => std::option::Option::Some("TYPE_ENUM"),
                Self::TypeSfixed32 => std::option::Option::Some("TYPE_SFIXED32"),
                Self::TypeSfixed64 => std::option::Option::Some("TYPE_SFIXED64"),
                Self::TypeSint32 => std::option::Option::Some("TYPE_SINT32"),
                Self::TypeSint64 => std::option::Option::Some("TYPE_SINT64"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Kind {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Kind {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Kind {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::TypeUnknown,
                1 => Self::TypeDouble,
                2 => Self::TypeFloat,
                3 => Self::TypeInt64,
                4 => Self::TypeUint64,
                5 => Self::TypeInt32,
                6 => Self::TypeFixed64,
                7 => Self::TypeFixed32,
                8 => Self::TypeBool,
                9 => Self::TypeString,
                10 => Self::TypeGroup,
                11 => Self::TypeMessage,
                12 => Self::TypeBytes,
                13 => Self::TypeUint32,
                14 => Self::TypeEnum,
                15 => Self::TypeSfixed32,
                16 => Self::TypeSfixed64,
                17 => Self::TypeSint32,
                18 => Self::TypeSint64,
                _ => Self::UnknownValue(kind::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Kind {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TYPE_UNKNOWN" => Self::TypeUnknown,
                "TYPE_DOUBLE" => Self::TypeDouble,
                "TYPE_FLOAT" => Self::TypeFloat,
                "TYPE_INT64" => Self::TypeInt64,
                "TYPE_UINT64" => Self::TypeUint64,
                "TYPE_INT32" => Self::TypeInt32,
                "TYPE_FIXED64" => Self::TypeFixed64,
                "TYPE_FIXED32" => Self::TypeFixed32,
                "TYPE_BOOL" => Self::TypeBool,
                "TYPE_STRING" => Self::TypeString,
                "TYPE_GROUP" => Self::TypeGroup,
                "TYPE_MESSAGE" => Self::TypeMessage,
                "TYPE_BYTES" => Self::TypeBytes,
                "TYPE_UINT32" => Self::TypeUint32,
                "TYPE_ENUM" => Self::TypeEnum,
                "TYPE_SFIXED32" => Self::TypeSfixed32,
                "TYPE_SFIXED64" => Self::TypeSfixed64,
                "TYPE_SINT32" => Self::TypeSint32,
                "TYPE_SINT64" => Self::TypeSint64,
                _ => Self::UnknownValue(kind::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Kind {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::TypeUnknown => serializer.serialize_i32(0),
                Self::TypeDouble => serializer.serialize_i32(1),
                Self::TypeFloat => serializer.serialize_i32(2),
                Self::TypeInt64 => serializer.serialize_i32(3),
                Self::TypeUint64 => serializer.serialize_i32(4),
                Self::TypeInt32 => serializer.serialize_i32(5),
                Self::TypeFixed64 => serializer.serialize_i32(6),
                Self::TypeFixed32 => serializer.serialize_i32(7),
                Self::TypeBool => serializer.serialize_i32(8),
                Self::TypeString => serializer.serialize_i32(9),
                Self::TypeGroup => serializer.serialize_i32(10),
                Self::TypeMessage => serializer.serialize_i32(11),
                Self::TypeBytes => serializer.serialize_i32(12),
                Self::TypeUint32 => serializer.serialize_i32(13),
                Self::TypeEnum => serializer.serialize_i32(14),
                Self::TypeSfixed32 => serializer.serialize_i32(15),
                Self::TypeSfixed64 => serializer.serialize_i32(16),
                Self::TypeSint32 => serializer.serialize_i32(17),
                Self::TypeSint64 => serializer.serialize_i32(18),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Kind {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Kind>::new(
                ".google.protobuf.Field.Kind",
            ))
        }
    }

    /// Whether a field is optional, required, or repeated.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Cardinality {
        /// For fields with unknown cardinality.
        Unknown,
        /// For optional fields.
        Optional,
        /// For required fields. Proto2 syntax only.
        Required,
        /// For repeated fields.
        Repeated,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Cardinality::value] or
        /// [Cardinality::name].
        UnknownValue(cardinality::UnknownValue),
    }

    #[doc(hidden)]
    pub mod cardinality {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Cardinality {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Optional => std::option::Option::Some(1),
                Self::Required => std::option::Option::Some(2),
                Self::Repeated => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("CARDINALITY_UNKNOWN"),
                Self::Optional => std::option::Option::Some("CARDINALITY_OPTIONAL"),
                Self::Required => std::option::Option::Some("CARDINALITY_REQUIRED"),
                Self::Repeated => std::option::Option::Some("CARDINALITY_REPEATED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Cardinality {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Cardinality {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Cardinality {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::Optional,
                2 => Self::Required,
                3 => Self::Repeated,
                _ => Self::UnknownValue(cardinality::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Cardinality {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "CARDINALITY_UNKNOWN" => Self::Unknown,
                "CARDINALITY_OPTIONAL" => Self::Optional,
                "CARDINALITY_REQUIRED" => Self::Required,
                "CARDINALITY_REPEATED" => Self::Repeated,
                _ => Self::UnknownValue(cardinality::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Cardinality {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Optional => serializer.serialize_i32(1),
                Self::Required => serializer.serialize_i32(2),
                Self::Repeated => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Cardinality {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Cardinality>::new(
                ".google.protobuf.Field.Cardinality",
            ))
        }
    }
}

/// Enum type definition.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Enum {
    /// Enum type name.
    pub name: std::string::String,

    /// Enum value definitions.
    pub enumvalue: std::vec::Vec<crate::EnumValue>,

    /// Protocol buffer options.
    pub options: std::vec::Vec<crate::Option>,

    /// The source context.
    pub source_context: std::option::Option<crate::SourceContext>,

    /// The source syntax.
    pub syntax: crate::Syntax,

    /// The source edition string, only valid when syntax is SYNTAX_EDITIONS.
    pub edition: std::string::String,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Enum {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::Enum::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [enumvalue][crate::Enum::enumvalue].
    pub fn set_enumvalue<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::EnumValue>,
    {
        use std::iter::Iterator;
        self.enumvalue = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [options][crate::Enum::options].
    pub fn set_options<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::Option>,
    {
        use std::iter::Iterator;
        self.options = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [source_context][crate::Enum::source_context].
    pub fn set_source_context<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::SourceContext>,
    {
        self.source_context = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [source_context][crate::Enum::source_context].
    pub fn set_or_clear_source_context<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::SourceContext>,
    {
        self.source_context = v.map(|x| x.into());
        self
    }

    /// Sets the value of [syntax][crate::Enum::syntax].
    pub fn set_syntax<T: std::convert::Into<crate::Syntax>>(mut self, v: T) -> Self {
        self.syntax = v.into();
        self
    }

    /// Sets the value of [edition][crate::Enum::edition].
    pub fn set_edition<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.edition = v.into();
        self
    }
}

impl wkt::message::Message for Enum {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.Enum"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for Enum {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __enumvalue,
            __options,
            __source_context,
            __syntax,
            __edition,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for Enum")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "enumvalue" => Ok(__FieldTag::__enumvalue),
                            "options" => Ok(__FieldTag::__options),
                            "sourceContext" => Ok(__FieldTag::__source_context),
                            "source_context" => Ok(__FieldTag::__source_context),
                            "syntax" => Ok(__FieldTag::__syntax),
                            "edition" => Ok(__FieldTag::__edition),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = Enum;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Enum")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__enumvalue => {
                            if !fields.insert(__FieldTag::__enumvalue) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for enumvalue",
                                ));
                            }
                            result.enumvalue = map
                                .next_value::<std::option::Option<std::vec::Vec<crate::EnumValue>>>(
                                )?
                                .unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options = map
                                .next_value::<std::option::Option<std::vec::Vec<crate::Option>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__source_context => {
                            if !fields.insert(__FieldTag::__source_context) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for source_context",
                                ));
                            }
                            result.source_context =
                                map.next_value::<std::option::Option<crate::SourceContext>>()?;
                        }
                        __FieldTag::__syntax => {
                            if !fields.insert(__FieldTag::__syntax) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for syntax",
                                ));
                            }
                            result.syntax = map
                                .next_value::<std::option::Option<crate::Syntax>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__edition => {
                            if !fields.insert(__FieldTag::__edition) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for edition",
                                ));
                            }
                            result.edition = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for Enum {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.enumvalue.is_empty() {
            state.serialize_entry("enumvalue", &self.enumvalue)?;
        }
        if !self.options.is_empty() {
            state.serialize_entry("options", &self.options)?;
        }
        if self.source_context.is_some() {
            state.serialize_entry("sourceContext", &self.source_context)?;
        }
        if !wkt::internal::is_default(&self.syntax) {
            state.serialize_entry("syntax", &self.syntax)?;
        }
        if !self.edition.is_empty() {
            state.serialize_entry("edition", &self.edition)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for Enum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Enum");
        debug_struct.field("name", &self.name);
        debug_struct.field("enumvalue", &self.enumvalue);
        debug_struct.field("options", &self.options);
        debug_struct.field("source_context", &self.source_context);
        debug_struct.field("syntax", &self.syntax);
        debug_struct.field("edition", &self.edition);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// Enum value definition.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct EnumValue {
    /// Enum value name.
    pub name: std::string::String,

    /// Enum value number.
    pub number: i32,

    /// Protocol buffer options.
    pub options: std::vec::Vec<crate::Option>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EnumValue {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::EnumValue::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [number][crate::EnumValue::number].
    pub fn set_number<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.number = v.into();
        self
    }

    /// Sets the value of [options][crate::EnumValue::options].
    pub fn set_options<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::Option>,
    {
        use std::iter::Iterator;
        self.options = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for EnumValue {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.EnumValue"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for EnumValue {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __number,
            __options,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for EnumValue")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "number" => Ok(__FieldTag::__number),
                            "options" => Ok(__FieldTag::__options),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = EnumValue;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct EnumValue")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__number => {
                            if !fields.insert(__FieldTag::__number) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for number",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.number = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options = map
                                .next_value::<std::option::Option<std::vec::Vec<crate::Option>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for EnumValue {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !wkt::internal::is_default(&self.number) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("number", &__With(&self.number))?;
        }
        if !self.options.is_empty() {
            state.serialize_entry("options", &self.options)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for EnumValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnumValue");
        debug_struct.field("name", &self.name);
        debug_struct.field("number", &self.number);
        debug_struct.field("options", &self.options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// A protocol buffer option, which can be attached to a message, field,
/// enumeration, etc.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Option {
    /// The option's name. For protobuf built-in options (options defined in
    /// descriptor.proto), this is the short name. For example, `"map_entry"`.
    /// For custom options, it should be the fully-qualified name. For example,
    /// `"google.api.http"`.
    pub name: std::string::String,

    /// The option's value packed in an Any message. If the value is a primitive,
    /// the corresponding wrapper type defined in google/protobuf/wrappers.proto
    /// should be used. If the value is an enum, it should be stored as an int32
    /// value using the google.protobuf.Int32Value type.
    pub value: std::option::Option<crate::Any>,

    _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Option {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::Option::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [value][crate::Option::value].
    pub fn set_value<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::Any>,
    {
        self.value = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [value][crate::Option::value].
    pub fn set_or_clear_value<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::Any>,
    {
        self.value = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for Option {
    fn typename() -> &'static str {
        "type.googleapis.com/google.protobuf.Option"
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for Option {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __value,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for Option")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "value" => Ok(__FieldTag::__value),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = Option;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Option")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__value => {
                            if !fields.insert(__FieldTag::__value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for value",
                                ));
                            }
                            result.value = map.next_value::<std::option::Option<crate::Any>>()?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for Option {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if self.value.is_some() {
            state.serialize_entry("value", &self.value)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

impl std::fmt::Debug for Option {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Option");
        debug_struct.field("name", &self.name);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

/// The full set of known editions.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum Edition {
    /// A placeholder for an unknown edition value.
    Unknown,
    /// A placeholder edition for specifying default behaviors *before* a feature
    /// was first introduced.  This is effectively an "infinite past".
    Legacy,
    /// Legacy syntax "editions".  These pre-date editions, but behave much like
    /// distinct editions.  These can't be used to specify the edition of proto
    /// files, but feature definitions must supply proto2/proto3 defaults for
    /// backwards compatibility.
    Proto2,
    Proto3,
    /// Editions that have been released.  The specific values are arbitrary and
    /// should not be depended on, but they will always be time-ordered for easy
    /// comparison.
    Edition2023,
    Edition2024,
    /// Placeholder editions for testing feature resolution.  These should not be
    /// used or relied on outside of tests.
    Edition1TestOnly,
    Edition2TestOnly,
    Edition99997TestOnly,
    Edition99998TestOnly,
    Edition99999TestOnly,
    /// Placeholder for specifying unbounded edition support.  This should only
    /// ever be used by plugins that can expect to never require any changes to
    /// support a new edition.
    Max,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [Edition::value] or
    /// [Edition::name].
    UnknownValue(edition::UnknownValue),
}

#[doc(hidden)]
pub mod edition {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl Edition {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unknown => std::option::Option::Some(0),
            Self::Legacy => std::option::Option::Some(900),
            Self::Proto2 => std::option::Option::Some(998),
            Self::Proto3 => std::option::Option::Some(999),
            Self::Edition2023 => std::option::Option::Some(1000),
            Self::Edition2024 => std::option::Option::Some(1001),
            Self::Edition1TestOnly => std::option::Option::Some(1),
            Self::Edition2TestOnly => std::option::Option::Some(2),
            Self::Edition99997TestOnly => std::option::Option::Some(99997),
            Self::Edition99998TestOnly => std::option::Option::Some(99998),
            Self::Edition99999TestOnly => std::option::Option::Some(99999),
            Self::Max => std::option::Option::Some(2147483647),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unknown => std::option::Option::Some("EDITION_UNKNOWN"),
            Self::Legacy => std::option::Option::Some("EDITION_LEGACY"),
            Self::Proto2 => std::option::Option::Some("EDITION_PROTO2"),
            Self::Proto3 => std::option::Option::Some("EDITION_PROTO3"),
            Self::Edition2023 => std::option::Option::Some("EDITION_2023"),
            Self::Edition2024 => std::option::Option::Some("EDITION_2024"),
            Self::Edition1TestOnly => std::option::Option::Some("EDITION_1_TEST_ONLY"),
            Self::Edition2TestOnly => std::option::Option::Some("EDITION_2_TEST_ONLY"),
            Self::Edition99997TestOnly => std::option::Option::Some("EDITION_99997_TEST_ONLY"),
            Self::Edition99998TestOnly => std::option::Option::Some("EDITION_99998_TEST_ONLY"),
            Self::Edition99999TestOnly => std::option::Option::Some("EDITION_99999_TEST_ONLY"),
            Self::Max => std::option::Option::Some("EDITION_MAX"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for Edition {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for Edition {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for Edition {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unknown,
            1 => Self::Edition1TestOnly,
            2 => Self::Edition2TestOnly,
            900 => Self::Legacy,
            998 => Self::Proto2,
            999 => Self::Proto3,
            1000 => Self::Edition2023,
            1001 => Self::Edition2024,
            99997 => Self::Edition99997TestOnly,
            99998 => Self::Edition99998TestOnly,
            99999 => Self::Edition99999TestOnly,
            2147483647 => Self::Max,
            _ => Self::UnknownValue(edition::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for Edition {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "EDITION_UNKNOWN" => Self::Unknown,
            "EDITION_LEGACY" => Self::Legacy,
            "EDITION_PROTO2" => Self::Proto2,
            "EDITION_PROTO3" => Self::Proto3,
            "EDITION_2023" => Self::Edition2023,
            "EDITION_2024" => Self::Edition2024,
            "EDITION_1_TEST_ONLY" => Self::Edition1TestOnly,
            "EDITION_2_TEST_ONLY" => Self::Edition2TestOnly,
            "EDITION_99997_TEST_ONLY" => Self::Edition99997TestOnly,
            "EDITION_99998_TEST_ONLY" => Self::Edition99998TestOnly,
            "EDITION_99999_TEST_ONLY" => Self::Edition99999TestOnly,
            "EDITION_MAX" => Self::Max,
            _ => Self::UnknownValue(edition::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for Edition {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unknown => serializer.serialize_i32(0),
            Self::Legacy => serializer.serialize_i32(900),
            Self::Proto2 => serializer.serialize_i32(998),
            Self::Proto3 => serializer.serialize_i32(999),
            Self::Edition2023 => serializer.serialize_i32(1000),
            Self::Edition2024 => serializer.serialize_i32(1001),
            Self::Edition1TestOnly => serializer.serialize_i32(1),
            Self::Edition2TestOnly => serializer.serialize_i32(2),
            Self::Edition99997TestOnly => serializer.serialize_i32(99997),
            Self::Edition99998TestOnly => serializer.serialize_i32(99998),
            Self::Edition99999TestOnly => serializer.serialize_i32(99999),
            Self::Max => serializer.serialize_i32(2147483647),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for Edition {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<Edition>::new(
            ".google.protobuf.Edition",
        ))
    }
}

/// The syntax in which a protocol buffer element is defined.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum Syntax {
    /// Syntax `proto2`.
    Proto2,
    /// Syntax `proto3`.
    Proto3,
    /// Syntax `editions`.
    Editions,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [Syntax::value] or
    /// [Syntax::name].
    UnknownValue(syntax::UnknownValue),
}

#[doc(hidden)]
pub mod syntax {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl Syntax {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Proto2 => std::option::Option::Some(0),
            Self::Proto3 => std::option::Option::Some(1),
            Self::Editions => std::option::Option::Some(2),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Proto2 => std::option::Option::Some("SYNTAX_PROTO2"),
            Self::Proto3 => std::option::Option::Some("SYNTAX_PROTO3"),
            Self::Editions => std::option::Option::Some("SYNTAX_EDITIONS"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for Syntax {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for Syntax {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for Syntax {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Proto2,
            1 => Self::Proto3,
            2 => Self::Editions,
            _ => Self::UnknownValue(syntax::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for Syntax {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "SYNTAX_PROTO2" => Self::Proto2,
            "SYNTAX_PROTO3" => Self::Proto3,
            "SYNTAX_EDITIONS" => Self::Editions,
            _ => Self::UnknownValue(syntax::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for Syntax {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Proto2 => serializer.serialize_i32(0),
            Self::Proto3 => serializer.serialize_i32(1),
            Self::Editions => serializer.serialize_i32(2),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for Syntax {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<Syntax>::new(
            ".google.protobuf.Syntax",
        ))
    }
}