nominal_api/proto/

google.protobuf.rs

// This file is @generated by prost-build.
/// A Timestamp represents a point in time independent of any time zone or local
/// calendar, encoded as a count of seconds and fractions of seconds at
/// nanosecond resolution. The count is relative to an epoch at UTC midnight on
/// January 1, 1970, in the proleptic Gregorian calendar which extends the
/// Gregorian calendar backwards to year one.
///
/// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
/// second table is needed for interpretation, using a [24-hour linear
/// smear](<https://developers.google.com/time/smear>).
///
/// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
/// restricting to that range, we ensure that we can convert to and from [RFC
/// 3339](<https://www.ietf.org/rfc/rfc3339.txt>) date strings.
///
/// # Examples
///
/// Example 1: Compute Timestamp from POSIX `time()`.
///
///      Timestamp timestamp;
///      timestamp.set_seconds(time(NULL));
///      timestamp.set_nanos(0);
///
/// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
///
///      struct timeval tv;
///      gettimeofday(&tv, NULL);
///
///      Timestamp timestamp;
///      timestamp.set_seconds(tv.tv_sec);
///      timestamp.set_nanos(tv.tv_usec * 1000);
///
/// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
///
///      FILETIME ft;
///      GetSystemTimeAsFileTime(&ft);
///      UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
///
///      // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
///      // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
///      Timestamp timestamp;
///      timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
///      timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
///
/// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
///
///      long millis = System.currentTimeMillis();
///
///      Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
///          .setNanos((int) ((millis % 1000) * 1000000)).build();
///
/// Example 5: Compute Timestamp from Java `Instant.now()`.
///
///      Instant now = Instant.now();
///
///      Timestamp timestamp =
///          Timestamp.newBuilder().setSeconds(now.getEpochSecond())
///              .setNanos(now.getNano()).build();
///
/// Example 6: Compute Timestamp from current time in Python.
///
///      timestamp = Timestamp()
///      timestamp.GetCurrentTime()
///
/// # JSON Mapping
///
/// In JSON format, the Timestamp type is encoded as a string in the
/// [RFC 3339](<https://www.ietf.org/rfc/rfc3339.txt>) format. That is, the
/// format is "{year}-{month}-{day}T{hour}:{min}:{sec}\[.{frac_sec}\]Z"
/// where {year} is always expressed using four digits while {month}, {day},
/// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
/// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
/// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
/// is required. A proto3 JSON serializer should always use UTC (as indicated by
/// "Z") when printing the Timestamp type and a proto3 JSON parser should be
/// able to accept both UTC and other timezones (as indicated by an offset).
///
/// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
/// 01:30 UTC on January 15, 2017.
///
/// In JavaScript, one can convert a Date object to this format using the
/// standard
/// [toISOString()](<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>)
/// method. In Python, a standard `datetime.datetime` object can be converted
/// to this format using
/// [`strftime`](<https://docs.python.org/2/library/time.html#time.strftime>) with
/// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
/// the Joda Time's [`ISODateTimeFormat.dateTime()`](
/// <http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime(>)
/// ) to obtain a formatter capable of generating timestamps in this format.
///
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct Timestamp {
    /// Represents seconds of UTC time since Unix epoch
    /// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
    /// 9999-12-31T23:59:59Z inclusive.
    #[prost(int64, tag = "1")]
    pub seconds: i64,
    /// Non-negative fractions of a second at nanosecond resolution. Negative
    /// second values with fractions must still have non-negative nanos values
    /// that count forward in time. Must be from 0 to 999,999,999
    /// inclusive.
    #[prost(int32, tag = "2")]
    pub nanos: i32,
}
/// The protocol compiler can output a FileDescriptorSet containing the .proto
/// files it parses.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileDescriptorSet {
    #[prost(message, repeated, tag = "1")]
    pub file: ::prost::alloc::vec::Vec<FileDescriptorProto>,
}
/// Describes a complete .proto file.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FileDescriptorProto {
    /// file name, relative to root of source tree
    #[prost(string, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    /// e.g. "foo", "foo.bar", etc.
    #[prost(string, optional, tag = "2")]
    pub package: ::core::option::Option<::prost::alloc::string::String>,
    /// Names of files imported by this file.
    #[prost(string, repeated, tag = "3")]
    pub dependency: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Indexes of the public imported files in the dependency list above.
    #[prost(int32, repeated, packed = "false", tag = "10")]
    pub public_dependency: ::prost::alloc::vec::Vec<i32>,
    /// Indexes of the weak imported files in the dependency list.
    /// For Google-internal migration only. Do not use.
    #[prost(int32, repeated, packed = "false", tag = "11")]
    pub weak_dependency: ::prost::alloc::vec::Vec<i32>,
    /// Names of files imported by this file purely for the purpose of providing
    /// option extensions. These are excluded from the dependency list above.
    #[prost(string, repeated, tag = "15")]
    pub option_dependency: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// All top-level definitions in this file.
    #[prost(message, repeated, tag = "4")]
    pub message_type: ::prost::alloc::vec::Vec<DescriptorProto>,
    #[prost(message, repeated, tag = "5")]
    pub enum_type: ::prost::alloc::vec::Vec<EnumDescriptorProto>,
    #[prost(message, repeated, tag = "6")]
    pub service: ::prost::alloc::vec::Vec<ServiceDescriptorProto>,
    #[prost(message, repeated, tag = "7")]
    pub extension: ::prost::alloc::vec::Vec<FieldDescriptorProto>,
    #[prost(message, optional, tag = "8")]
    pub options: ::core::option::Option<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.
    #[prost(message, optional, tag = "9")]
    pub source_code_info: ::core::option::Option<SourceCodeInfo>,
    /// The syntax of the proto file.
    /// The supported values are "proto2", "proto3", and "editions".
    ///
    /// If `edition` is present, this value must be "editions".
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    #[prost(string, optional, tag = "12")]
    pub syntax: ::core::option::Option<::prost::alloc::string::String>,
    /// The edition of the proto file.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    #[prost(enumeration = "Edition", optional, tag = "14")]
    pub edition: ::core::option::Option<i32>,
}
/// Describes a message type.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DescriptorProto {
    #[prost(string, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "2")]
    pub field: ::prost::alloc::vec::Vec<FieldDescriptorProto>,
    #[prost(message, repeated, tag = "6")]
    pub extension: ::prost::alloc::vec::Vec<FieldDescriptorProto>,
    #[prost(message, repeated, tag = "3")]
    pub nested_type: ::prost::alloc::vec::Vec<DescriptorProto>,
    #[prost(message, repeated, tag = "4")]
    pub enum_type: ::prost::alloc::vec::Vec<EnumDescriptorProto>,
    #[prost(message, repeated, tag = "5")]
    pub extension_range: ::prost::alloc::vec::Vec<descriptor_proto::ExtensionRange>,
    #[prost(message, repeated, tag = "8")]
    pub oneof_decl: ::prost::alloc::vec::Vec<OneofDescriptorProto>,
    #[prost(message, optional, tag = "7")]
    pub options: ::core::option::Option<MessageOptions>,
    #[prost(message, repeated, tag = "9")]
    pub reserved_range: ::prost::alloc::vec::Vec<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.
    #[prost(string, repeated, tag = "10")]
    pub reserved_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Support for `export` and `local` keywords on enums.
    #[prost(enumeration = "SymbolVisibility", optional, tag = "11")]
    pub visibility: ::core::option::Option<i32>,
}
/// Nested message and enum types in `DescriptorProto`.
pub mod descriptor_proto {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ExtensionRange {
        /// Inclusive.
        #[prost(int32, optional, tag = "1")]
        pub start: ::core::option::Option<i32>,
        /// Exclusive.
        #[prost(int32, optional, tag = "2")]
        pub end: ::core::option::Option<i32>,
        #[prost(message, optional, tag = "3")]
        pub options: ::core::option::Option<super::ExtensionRangeOptions>,
    }
    /// 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, Copy, PartialEq, ::prost::Message)]
    pub struct ReservedRange {
        /// Inclusive.
        #[prost(int32, optional, tag = "1")]
        pub start: ::core::option::Option<i32>,
        /// Exclusive.
        #[prost(int32, optional, tag = "2")]
        pub end: ::core::option::Option<i32>,
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExtensionRangeOptions {
    /// The parser stores options it doesn't recognize here. See above.
    #[prost(message, repeated, tag = "999")]
    pub uninterpreted_option: ::prost::alloc::vec::Vec<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.
    #[prost(message, repeated, tag = "2")]
    pub declaration: ::prost::alloc::vec::Vec<extension_range_options::Declaration>,
    /// Any features defined in the specific edition.
    #[prost(message, optional, tag = "50")]
    pub features: ::core::option::Option<FeatureSet>,
    /// The verification state of the range.
    /// TODO: flip the default to DECLARATION once all empty ranges
    /// are marked as UNVERIFIED.
    #[prost(
        enumeration = "extension_range_options::VerificationState",
        optional,
        tag = "3",
        default = "Unverified"
    )]
    pub verification: ::core::option::Option<i32>,
}
/// Nested message and enum types in `ExtensionRangeOptions`.
pub mod extension_range_options {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Declaration {
        /// The extension number declared within the extension range.
        #[prost(int32, optional, tag = "1")]
        pub number: ::core::option::Option<i32>,
        /// The fully-qualified name of the extension field. There must be a leading
        /// dot in front of the full name.
        #[prost(string, optional, tag = "2")]
        pub full_name: ::core::option::Option<::prost::alloc::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.
        #[prost(string, optional, tag = "3")]
        pub r#type: ::core::option::Option<::prost::alloc::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.
        #[prost(bool, optional, tag = "5")]
        pub reserved: ::core::option::Option<bool>,
        /// If true, indicates that the extension must be defined as repeated.
        /// Otherwise the extension must be defined as optional.
        #[prost(bool, optional, tag = "6")]
        pub repeated: ::core::option::Option<bool>,
    }
    /// The verification state of the extension range.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum VerificationState {
        /// All the extensions of the range must be declared.
        Declaration = 0,
        Unverified = 1,
    }
    impl VerificationState {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Declaration => "DECLARATION",
                Self::Unverified => "UNVERIFIED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DECLARATION" => Some(Self::Declaration),
                "UNVERIFIED" => Some(Self::Unverified),
                _ => None,
            }
        }
    }
}
/// Describes a field within a message.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FieldDescriptorProto {
    #[prost(string, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "3")]
    pub number: ::core::option::Option<i32>,
    #[prost(enumeration = "field_descriptor_proto::Label", optional, tag = "4")]
    pub label: ::core::option::Option<i32>,
    /// 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.
    #[prost(enumeration = "field_descriptor_proto::Type", optional, tag = "5")]
    pub r#type: ::core::option::Option<i32>,
    /// 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).
    #[prost(string, optional, tag = "6")]
    pub type_name: ::core::option::Option<::prost::alloc::string::String>,
    /// For extensions, this is the name of the type being extended.  It is
    /// resolved in the same manner as type_name.
    #[prost(string, optional, tag = "2")]
    pub extendee: ::core::option::Option<::prost::alloc::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.
    #[prost(string, optional, tag = "7")]
    pub default_value: ::core::option::Option<::prost::alloc::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.
    #[prost(int32, optional, tag = "9")]
    pub oneof_index: ::core::option::Option<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.
    #[prost(string, optional, tag = "10")]
    pub json_name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "8")]
    pub options: ::core::option::Option<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`.
    #[prost(bool, optional, tag = "17")]
    pub proto3_optional: ::core::option::Option<bool>,
}
/// Nested message and enum types in `FieldDescriptorProto`.
pub mod field_descriptor_proto {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// 0 is reserved for errors.
        /// Order is weird for historical reasons.
        Double = 1,
        Float = 2,
        /// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
        /// negative values are likely.
        Int64 = 3,
        Uint64 = 4,
        /// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
        /// negative values are likely.
        Int32 = 5,
        Fixed64 = 6,
        Fixed32 = 7,
        Bool = 8,
        String = 9,
        /// 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 = 10,
        /// Length-delimited aggregate.
        Message = 11,
        /// New in version 2.
        Bytes = 12,
        Uint32 = 13,
        Enum = 14,
        Sfixed32 = 15,
        Sfixed64 = 16,
        /// Uses ZigZag encoding.
        Sint32 = 17,
        /// Uses ZigZag encoding.
        Sint64 = 18,
    }
    impl Type {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Double => "TYPE_DOUBLE",
                Self::Float => "TYPE_FLOAT",
                Self::Int64 => "TYPE_INT64",
                Self::Uint64 => "TYPE_UINT64",
                Self::Int32 => "TYPE_INT32",
                Self::Fixed64 => "TYPE_FIXED64",
                Self::Fixed32 => "TYPE_FIXED32",
                Self::Bool => "TYPE_BOOL",
                Self::String => "TYPE_STRING",
                Self::Group => "TYPE_GROUP",
                Self::Message => "TYPE_MESSAGE",
                Self::Bytes => "TYPE_BYTES",
                Self::Uint32 => "TYPE_UINT32",
                Self::Enum => "TYPE_ENUM",
                Self::Sfixed32 => "TYPE_SFIXED32",
                Self::Sfixed64 => "TYPE_SFIXED64",
                Self::Sint32 => "TYPE_SINT32",
                Self::Sint64 => "TYPE_SINT64",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_DOUBLE" => Some(Self::Double),
                "TYPE_FLOAT" => Some(Self::Float),
                "TYPE_INT64" => Some(Self::Int64),
                "TYPE_UINT64" => Some(Self::Uint64),
                "TYPE_INT32" => Some(Self::Int32),
                "TYPE_FIXED64" => Some(Self::Fixed64),
                "TYPE_FIXED32" => Some(Self::Fixed32),
                "TYPE_BOOL" => Some(Self::Bool),
                "TYPE_STRING" => Some(Self::String),
                "TYPE_GROUP" => Some(Self::Group),
                "TYPE_MESSAGE" => Some(Self::Message),
                "TYPE_BYTES" => Some(Self::Bytes),
                "TYPE_UINT32" => Some(Self::Uint32),
                "TYPE_ENUM" => Some(Self::Enum),
                "TYPE_SFIXED32" => Some(Self::Sfixed32),
                "TYPE_SFIXED64" => Some(Self::Sfixed64),
                "TYPE_SINT32" => Some(Self::Sint32),
                "TYPE_SINT64" => Some(Self::Sint64),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Label {
        /// 0 is reserved for errors
        Optional = 1,
        Repeated = 3,
        /// 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 = 2,
    }
    impl Label {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Optional => "LABEL_OPTIONAL",
                Self::Repeated => "LABEL_REPEATED",
                Self::Required => "LABEL_REQUIRED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "LABEL_OPTIONAL" => Some(Self::Optional),
                "LABEL_REPEATED" => Some(Self::Repeated),
                "LABEL_REQUIRED" => Some(Self::Required),
                _ => None,
            }
        }
    }
}
/// Describes a oneof.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OneofDescriptorProto {
    #[prost(string, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub options: ::core::option::Option<OneofOptions>,
}
/// Describes an enum type.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EnumDescriptorProto {
    #[prost(string, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "2")]
    pub value: ::prost::alloc::vec::Vec<EnumValueDescriptorProto>,
    #[prost(message, optional, tag = "3")]
    pub options: ::core::option::Option<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.
    #[prost(message, repeated, tag = "4")]
    pub reserved_range: ::prost::alloc::vec::Vec<
        enum_descriptor_proto::EnumReservedRange,
    >,
    /// Reserved enum value names, which may not be reused. A given name may only
    /// be reserved once.
    #[prost(string, repeated, tag = "5")]
    pub reserved_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Support for `export` and `local` keywords on enums.
    #[prost(enumeration = "SymbolVisibility", optional, tag = "6")]
    pub visibility: ::core::option::Option<i32>,
}
/// Nested message and enum types in `EnumDescriptorProto`.
pub mod enum_descriptor_proto {
    /// 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, Copy, PartialEq, ::prost::Message)]
    pub struct EnumReservedRange {
        /// Inclusive.
        #[prost(int32, optional, tag = "1")]
        pub start: ::core::option::Option<i32>,
        /// Inclusive.
        #[prost(int32, optional, tag = "2")]
        pub end: ::core::option::Option<i32>,
    }
}
/// Describes a value within an enum.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EnumValueDescriptorProto {
    #[prost(string, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int32, optional, tag = "2")]
    pub number: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "3")]
    pub options: ::core::option::Option<EnumValueOptions>,
}
/// Describes a service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceDescriptorProto {
    #[prost(string, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "2")]
    pub method: ::prost::alloc::vec::Vec<MethodDescriptorProto>,
    #[prost(message, optional, tag = "3")]
    pub options: ::core::option::Option<ServiceOptions>,
}
/// Describes a method of a service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MethodDescriptorProto {
    #[prost(string, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::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.
    #[prost(string, optional, tag = "2")]
    pub input_type: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, optional, tag = "3")]
    pub output_type: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub options: ::core::option::Option<MethodOptions>,
    /// Identifies if client streams multiple client messages
    #[prost(bool, optional, tag = "5", default = "false")]
    pub client_streaming: ::core::option::Option<bool>,
    /// Identifies if server streams multiple server messages
    #[prost(bool, optional, tag = "6", default = "false")]
    pub server_streaming: ::core::option::Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
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.
    #[prost(string, optional, tag = "1")]
    pub java_package: ::core::option::Option<::prost::alloc::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.
    #[prost(string, optional, tag = "8")]
    pub java_outer_classname: ::core::option::Option<::prost::alloc::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.
    #[prost(bool, optional, tag = "10", default = "false")]
    pub java_multiple_files: ::core::option::Option<bool>,
    /// This option does nothing.
    #[deprecated]
    #[prost(bool, optional, tag = "20")]
    pub java_generate_equals_and_hash: ::core::option::Option<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.
    #[prost(bool, optional, tag = "27", default = "false")]
    pub java_string_check_utf8: ::core::option::Option<bool>,
    #[prost(
        enumeration = "file_options::OptimizeMode",
        optional,
        tag = "9",
        default = "Speed"
    )]
    pub optimize_for: ::core::option::Option<i32>,
    /// 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.
    #[prost(string, optional, tag = "11")]
    pub go_package: ::core::option::Option<::prost::alloc::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.
    #[prost(bool, optional, tag = "16", default = "false")]
    pub cc_generic_services: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "17", default = "false")]
    pub java_generic_services: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "18", default = "false")]
    pub py_generic_services: ::core::option::Option<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.
    #[prost(bool, optional, tag = "23", default = "false")]
    pub deprecated: ::core::option::Option<bool>,
    /// Enables the use of arenas for the proto messages in this file. This applies
    /// only to generated classes for C++.
    #[prost(bool, optional, tag = "31", default = "true")]
    pub cc_enable_arenas: ::core::option::Option<bool>,
    /// Sets the objective c class prefix which is prepended to all objective c
    /// generated classes from this .proto. There is no default.
    #[prost(string, optional, tag = "36")]
    pub objc_class_prefix: ::core::option::Option<::prost::alloc::string::String>,
    /// Namespace for generated classes; defaults to the package.
    #[prost(string, optional, tag = "37")]
    pub csharp_namespace: ::core::option::Option<::prost::alloc::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.
    #[prost(string, optional, tag = "39")]
    pub swift_prefix: ::core::option::Option<::prost::alloc::string::String>,
    /// Sets the php class prefix which is prepended to all php generated classes
    /// from this .proto. Default is empty.
    #[prost(string, optional, tag = "40")]
    pub php_class_prefix: ::core::option::Option<::prost::alloc::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.
    #[prost(string, optional, tag = "41")]
    pub php_namespace: ::core::option::Option<::prost::alloc::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.
    #[prost(string, optional, tag = "44")]
    pub php_metadata_namespace: ::core::option::Option<::prost::alloc::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.
    #[prost(string, optional, tag = "45")]
    pub ruby_package: ::core::option::Option<::prost::alloc::string::String>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    #[prost(message, optional, tag = "50")]
    pub features: ::core::option::Option<FeatureSet>,
    /// The parser stores options it doesn't recognize here.
    /// See the documentation for the "Options" section above.
    #[prost(message, repeated, tag = "999")]
    pub uninterpreted_option: ::prost::alloc::vec::Vec<UninterpretedOption>,
}
/// Nested message and enum types in `FileOptions`.
pub mod file_options {
    /// Generated classes can be optimized for speed or code size.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum OptimizeMode {
        /// Generate complete code for parsing, serialization,
        Speed = 1,
        /// etc.
        ///
        /// Use ReflectionOps to implement these methods.
        CodeSize = 2,
        /// Generate code using MessageLite and the lite runtime.
        LiteRuntime = 3,
    }
    impl OptimizeMode {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Speed => "SPEED",
                Self::CodeSize => "CODE_SIZE",
                Self::LiteRuntime => "LITE_RUNTIME",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SPEED" => Some(Self::Speed),
                "CODE_SIZE" => Some(Self::CodeSize),
                "LITE_RUNTIME" => Some(Self::LiteRuntime),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
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.
    #[prost(bool, optional, tag = "1", default = "false")]
    pub message_set_wire_format: ::core::option::Option<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".
    #[prost(bool, optional, tag = "2", default = "false")]
    pub no_standard_descriptor_accessor: ::core::option::Option<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.
    #[prost(bool, optional, tag = "3", default = "false")]
    pub deprecated: ::core::option::Option<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.
    #[prost(bool, optional, tag = "7")]
    pub map_entry: ::core::option::Option<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]
    #[prost(bool, optional, tag = "11")]
    pub deprecated_legacy_json_field_conflicts: ::core::option::Option<bool>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    #[prost(message, optional, tag = "12")]
    pub features: ::core::option::Option<FeatureSet>,
    /// The parser stores options it doesn't recognize here. See above.
    #[prost(message, repeated, tag = "999")]
    pub uninterpreted_option: ::prost::alloc::vec::Vec<UninterpretedOption>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
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.
    #[prost(
        enumeration = "field_options::CType",
        optional,
        tag = "1",
        default = "String"
    )]
    pub ctype: ::core::option::Option<i32>,
    /// 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.
    #[prost(bool, optional, tag = "2")]
    pub packed: ::core::option::Option<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.
    #[prost(
        enumeration = "field_options::JsType",
        optional,
        tag = "6",
        default = "JsNormal"
    )]
    pub jstype: ::core::option::Option<i32>,
    /// 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).
    #[prost(bool, optional, tag = "5", default = "false")]
    pub lazy: ::core::option::Option<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.
    #[prost(bool, optional, tag = "15", default = "false")]
    pub unverified_lazy: ::core::option::Option<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.
    #[prost(bool, optional, tag = "3", default = "false")]
    pub deprecated: ::core::option::Option<bool>,
    /// For Google-internal migration only. Do not use.
    #[prost(bool, optional, tag = "10", default = "false")]
    pub weak: ::core::option::Option<bool>,
    /// Indicate that the field value should not be printed out when using debug
    /// formats, e.g. when the field contains sensitive credentials.
    #[prost(bool, optional, tag = "16", default = "false")]
    pub debug_redact: ::core::option::Option<bool>,
    #[prost(enumeration = "field_options::OptionRetention", optional, tag = "17")]
    pub retention: ::core::option::Option<i32>,
    #[prost(
        enumeration = "field_options::OptionTargetType",
        repeated,
        packed = "false",
        tag = "19"
    )]
    pub targets: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, repeated, tag = "20")]
    pub edition_defaults: ::prost::alloc::vec::Vec<field_options::EditionDefault>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    #[prost(message, optional, tag = "21")]
    pub features: ::core::option::Option<FeatureSet>,
    #[prost(message, optional, tag = "22")]
    pub feature_support: ::core::option::Option<field_options::FeatureSupport>,
    /// The parser stores options it doesn't recognize here. See above.
    #[prost(message, repeated, tag = "999")]
    pub uninterpreted_option: ::prost::alloc::vec::Vec<UninterpretedOption>,
}
/// Nested message and enum types in `FieldOptions`.
pub mod field_options {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EditionDefault {
        #[prost(enumeration = "super::Edition", optional, tag = "3")]
        pub edition: ::core::option::Option<i32>,
        /// Textproto value.
        #[prost(string, optional, tag = "2")]
        pub value: ::core::option::Option<::prost::alloc::string::String>,
    }
    /// Information about the support window of a feature.
    #[derive(Clone, PartialEq, ::prost::Message)]
    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.
        #[prost(enumeration = "super::Edition", optional, tag = "1")]
        pub edition_introduced: ::core::option::Option<i32>,
        /// The edition this feature becomes deprecated in.  Using this after this
        /// edition may trigger warnings.
        #[prost(enumeration = "super::Edition", optional, tag = "2")]
        pub edition_deprecated: ::core::option::Option<i32>,
        /// The deprecation warning text if this feature is used after the edition it
        /// was marked deprecated in.
        #[prost(string, optional, tag = "3")]
        pub deprecation_warning: ::core::option::Option<::prost::alloc::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.
        #[prost(enumeration = "super::Edition", optional, tag = "4")]
        pub edition_removed: ::core::option::Option<i32>,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum CType {
        /// Default mode.
        String = 0,
        /// 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 = 1,
        StringPiece = 2,
    }
    impl CType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::String => "STRING",
                Self::Cord => "CORD",
                Self::StringPiece => "STRING_PIECE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STRING" => Some(Self::String),
                "CORD" => Some(Self::Cord),
                "STRING_PIECE" => Some(Self::StringPiece),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum JsType {
        /// Use the default type.
        JsNormal = 0,
        /// Use JavaScript strings.
        JsString = 1,
        /// Use JavaScript numbers.
        JsNumber = 2,
    }
    impl JsType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::JsNormal => "JS_NORMAL",
                Self::JsString => "JS_STRING",
                Self::JsNumber => "JS_NUMBER",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "JS_NORMAL" => Some(Self::JsNormal),
                "JS_STRING" => Some(Self::JsString),
                "JS_NUMBER" => Some(Self::JsNumber),
                _ => None,
            }
        }
    }
    /// If set to RETENTION_SOURCE, the option will be omitted from the binary.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum OptionRetention {
        RetentionUnknown = 0,
        RetentionRuntime = 1,
        RetentionSource = 2,
    }
    impl OptionRetention {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::RetentionUnknown => "RETENTION_UNKNOWN",
                Self::RetentionRuntime => "RETENTION_RUNTIME",
                Self::RetentionSource => "RETENTION_SOURCE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RETENTION_UNKNOWN" => Some(Self::RetentionUnknown),
                "RETENTION_RUNTIME" => Some(Self::RetentionRuntime),
                "RETENTION_SOURCE" => Some(Self::RetentionSource),
                _ => None,
            }
        }
    }
    /// 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.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum OptionTargetType {
        TargetTypeUnknown = 0,
        TargetTypeFile = 1,
        TargetTypeExtensionRange = 2,
        TargetTypeMessage = 3,
        TargetTypeField = 4,
        TargetTypeOneof = 5,
        TargetTypeEnum = 6,
        TargetTypeEnumEntry = 7,
        TargetTypeService = 8,
        TargetTypeMethod = 9,
    }
    impl OptionTargetType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::TargetTypeUnknown => "TARGET_TYPE_UNKNOWN",
                Self::TargetTypeFile => "TARGET_TYPE_FILE",
                Self::TargetTypeExtensionRange => "TARGET_TYPE_EXTENSION_RANGE",
                Self::TargetTypeMessage => "TARGET_TYPE_MESSAGE",
                Self::TargetTypeField => "TARGET_TYPE_FIELD",
                Self::TargetTypeOneof => "TARGET_TYPE_ONEOF",
                Self::TargetTypeEnum => "TARGET_TYPE_ENUM",
                Self::TargetTypeEnumEntry => "TARGET_TYPE_ENUM_ENTRY",
                Self::TargetTypeService => "TARGET_TYPE_SERVICE",
                Self::TargetTypeMethod => "TARGET_TYPE_METHOD",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TARGET_TYPE_UNKNOWN" => Some(Self::TargetTypeUnknown),
                "TARGET_TYPE_FILE" => Some(Self::TargetTypeFile),
                "TARGET_TYPE_EXTENSION_RANGE" => Some(Self::TargetTypeExtensionRange),
                "TARGET_TYPE_MESSAGE" => Some(Self::TargetTypeMessage),
                "TARGET_TYPE_FIELD" => Some(Self::TargetTypeField),
                "TARGET_TYPE_ONEOF" => Some(Self::TargetTypeOneof),
                "TARGET_TYPE_ENUM" => Some(Self::TargetTypeEnum),
                "TARGET_TYPE_ENUM_ENTRY" => Some(Self::TargetTypeEnumEntry),
                "TARGET_TYPE_SERVICE" => Some(Self::TargetTypeService),
                "TARGET_TYPE_METHOD" => Some(Self::TargetTypeMethod),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OneofOptions {
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    #[prost(message, optional, tag = "1")]
    pub features: ::core::option::Option<FeatureSet>,
    /// The parser stores options it doesn't recognize here. See above.
    #[prost(message, repeated, tag = "999")]
    pub uninterpreted_option: ::prost::alloc::vec::Vec<UninterpretedOption>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EnumOptions {
    /// Set this option to true to allow mapping different tag names to the same
    /// value.
    #[prost(bool, optional, tag = "2")]
    pub allow_alias: ::core::option::Option<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.
    #[prost(bool, optional, tag = "3", default = "false")]
    pub deprecated: ::core::option::Option<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]
    #[prost(bool, optional, tag = "6")]
    pub deprecated_legacy_json_field_conflicts: ::core::option::Option<bool>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    #[prost(message, optional, tag = "7")]
    pub features: ::core::option::Option<FeatureSet>,
    /// The parser stores options it doesn't recognize here. See above.
    #[prost(message, repeated, tag = "999")]
    pub uninterpreted_option: ::prost::alloc::vec::Vec<UninterpretedOption>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
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.
    #[prost(bool, optional, tag = "1", default = "false")]
    pub deprecated: ::core::option::Option<bool>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    #[prost(message, optional, tag = "2")]
    pub features: ::core::option::Option<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.
    #[prost(bool, optional, tag = "3", default = "false")]
    pub debug_redact: ::core::option::Option<bool>,
    /// Information about the support window of a feature value.
    #[prost(message, optional, tag = "4")]
    pub feature_support: ::core::option::Option<field_options::FeatureSupport>,
    /// The parser stores options it doesn't recognize here. See above.
    #[prost(message, repeated, tag = "999")]
    pub uninterpreted_option: ::prost::alloc::vec::Vec<UninterpretedOption>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceOptions {
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    #[prost(message, optional, tag = "34")]
    pub features: ::core::option::Option<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.
    #[prost(bool, optional, tag = "33", default = "false")]
    pub deprecated: ::core::option::Option<bool>,
    /// The parser stores options it doesn't recognize here. See above.
    #[prost(message, repeated, tag = "999")]
    pub uninterpreted_option: ::prost::alloc::vec::Vec<UninterpretedOption>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
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.
    #[prost(bool, optional, tag = "33", default = "false")]
    pub deprecated: ::core::option::Option<bool>,
    #[prost(
        enumeration = "method_options::IdempotencyLevel",
        optional,
        tag = "34",
        default = "IdempotencyUnknown"
    )]
    pub idempotency_level: ::core::option::Option<i32>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    #[prost(message, optional, tag = "35")]
    pub features: ::core::option::Option<FeatureSet>,
    /// The parser stores options it doesn't recognize here. See above.
    #[prost(message, repeated, tag = "999")]
    pub uninterpreted_option: ::prost::alloc::vec::Vec<UninterpretedOption>,
}
/// Nested message and enum types in `MethodOptions`.
pub mod method_options {
    /// 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.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum IdempotencyLevel {
        IdempotencyUnknown = 0,
        /// implies idempotent
        NoSideEffects = 1,
        /// idempotent, but may have side effects
        Idempotent = 2,
    }
    impl IdempotencyLevel {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::IdempotencyUnknown => "IDEMPOTENCY_UNKNOWN",
                Self::NoSideEffects => "NO_SIDE_EFFECTS",
                Self::Idempotent => "IDEMPOTENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "IDEMPOTENCY_UNKNOWN" => Some(Self::IdempotencyUnknown),
                "NO_SIDE_EFFECTS" => Some(Self::NoSideEffects),
                "IDEMPOTENT" => Some(Self::Idempotent),
                _ => None,
            }
        }
    }
}
/// 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, PartialEq, ::prost::Message)]
pub struct UninterpretedOption {
    #[prost(message, repeated, tag = "2")]
    pub name: ::prost::alloc::vec::Vec<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.
    #[prost(string, optional, tag = "3")]
    pub identifier_value: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(uint64, optional, tag = "4")]
    pub positive_int_value: ::core::option::Option<u64>,
    #[prost(int64, optional, tag = "5")]
    pub negative_int_value: ::core::option::Option<i64>,
    #[prost(double, optional, tag = "6")]
    pub double_value: ::core::option::Option<f64>,
    #[prost(bytes = "vec", optional, tag = "7")]
    pub string_value: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
    #[prost(string, optional, tag = "8")]
    pub aggregate_value: ::core::option::Option<::prost::alloc::string::String>,
}
/// Nested message and enum types in `UninterpretedOption`.
pub mod uninterpreted_option {
    /// 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, PartialEq, ::prost::Message)]
    pub struct NamePart {
        #[prost(string, required, tag = "1")]
        pub name_part: ::prost::alloc::string::String,
        #[prost(bool, required, tag = "2")]
        pub is_extension: bool,
    }
}
/// 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, Copy, PartialEq, ::prost::Message)]
pub struct FeatureSet {
    #[prost(enumeration = "feature_set::FieldPresence", optional, tag = "1")]
    pub field_presence: ::core::option::Option<i32>,
    #[prost(enumeration = "feature_set::EnumType", optional, tag = "2")]
    pub enum_type: ::core::option::Option<i32>,
    #[prost(enumeration = "feature_set::RepeatedFieldEncoding", optional, tag = "3")]
    pub repeated_field_encoding: ::core::option::Option<i32>,
    #[prost(enumeration = "feature_set::Utf8Validation", optional, tag = "4")]
    pub utf8_validation: ::core::option::Option<i32>,
    #[prost(enumeration = "feature_set::MessageEncoding", optional, tag = "5")]
    pub message_encoding: ::core::option::Option<i32>,
    #[prost(enumeration = "feature_set::JsonFormat", optional, tag = "6")]
    pub json_format: ::core::option::Option<i32>,
    #[prost(enumeration = "feature_set::EnforceNamingStyle", optional, tag = "7")]
    pub enforce_naming_style: ::core::option::Option<i32>,
    #[prost(
        enumeration = "feature_set::visibility_feature::DefaultSymbolVisibility",
        optional,
        tag = "8"
    )]
    pub default_symbol_visibility: ::core::option::Option<i32>,
}
/// Nested message and enum types in `FeatureSet`.
pub mod feature_set {
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct VisibilityFeature {}
    /// Nested message and enum types in `VisibilityFeature`.
    pub mod visibility_feature {
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum DefaultSymbolVisibility {
            Unknown = 0,
            /// Default pre-EDITION_2024, all UNSET visibility are export.
            ExportAll = 1,
            /// All top-level symbols default to export, nested default to local.
            ExportTopLevel = 2,
            /// All symbols default to local.
            LocalAll = 3,
            /// All symbols local by default. Nested types cannot be exported.
            /// With special case caveat for message { enum {} reserved 1 to max; }
            /// This is the recommended setting for new protos.
            Strict = 4,
        }
        impl DefaultSymbolVisibility {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unknown => "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN",
                    Self::ExportAll => "EXPORT_ALL",
                    Self::ExportTopLevel => "EXPORT_TOP_LEVEL",
                    Self::LocalAll => "LOCAL_ALL",
                    Self::Strict => "STRICT",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN" => Some(Self::Unknown),
                    "EXPORT_ALL" => Some(Self::ExportAll),
                    "EXPORT_TOP_LEVEL" => Some(Self::ExportTopLevel),
                    "LOCAL_ALL" => Some(Self::LocalAll),
                    "STRICT" => Some(Self::Strict),
                    _ => None,
                }
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum FieldPresence {
        Unknown = 0,
        Explicit = 1,
        Implicit = 2,
        LegacyRequired = 3,
    }
    impl FieldPresence {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "FIELD_PRESENCE_UNKNOWN",
                Self::Explicit => "EXPLICIT",
                Self::Implicit => "IMPLICIT",
                Self::LegacyRequired => "LEGACY_REQUIRED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "FIELD_PRESENCE_UNKNOWN" => Some(Self::Unknown),
                "EXPLICIT" => Some(Self::Explicit),
                "IMPLICIT" => Some(Self::Implicit),
                "LEGACY_REQUIRED" => Some(Self::LegacyRequired),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EnumType {
        Unknown = 0,
        Open = 1,
        Closed = 2,
    }
    impl EnumType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "ENUM_TYPE_UNKNOWN",
                Self::Open => "OPEN",
                Self::Closed => "CLOSED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ENUM_TYPE_UNKNOWN" => Some(Self::Unknown),
                "OPEN" => Some(Self::Open),
                "CLOSED" => Some(Self::Closed),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RepeatedFieldEncoding {
        Unknown = 0,
        Packed = 1,
        Expanded = 2,
    }
    impl RepeatedFieldEncoding {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "REPEATED_FIELD_ENCODING_UNKNOWN",
                Self::Packed => "PACKED",
                Self::Expanded => "EXPANDED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REPEATED_FIELD_ENCODING_UNKNOWN" => Some(Self::Unknown),
                "PACKED" => Some(Self::Packed),
                "EXPANDED" => Some(Self::Expanded),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Utf8Validation {
        Unknown = 0,
        Verify = 2,
        None = 3,
    }
    impl Utf8Validation {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "UTF8_VALIDATION_UNKNOWN",
                Self::Verify => "VERIFY",
                Self::None => "NONE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UTF8_VALIDATION_UNKNOWN" => Some(Self::Unknown),
                "VERIFY" => Some(Self::Verify),
                "NONE" => Some(Self::None),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MessageEncoding {
        Unknown = 0,
        LengthPrefixed = 1,
        Delimited = 2,
    }
    impl MessageEncoding {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "MESSAGE_ENCODING_UNKNOWN",
                Self::LengthPrefixed => "LENGTH_PREFIXED",
                Self::Delimited => "DELIMITED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MESSAGE_ENCODING_UNKNOWN" => Some(Self::Unknown),
                "LENGTH_PREFIXED" => Some(Self::LengthPrefixed),
                "DELIMITED" => Some(Self::Delimited),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum JsonFormat {
        Unknown = 0,
        Allow = 1,
        LegacyBestEffort = 2,
    }
    impl JsonFormat {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "JSON_FORMAT_UNKNOWN",
                Self::Allow => "ALLOW",
                Self::LegacyBestEffort => "LEGACY_BEST_EFFORT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "JSON_FORMAT_UNKNOWN" => Some(Self::Unknown),
                "ALLOW" => Some(Self::Allow),
                "LEGACY_BEST_EFFORT" => Some(Self::LegacyBestEffort),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EnforceNamingStyle {
        Unknown = 0,
        Style2024 = 1,
        StyleLegacy = 2,
    }
    impl EnforceNamingStyle {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "ENFORCE_NAMING_STYLE_UNKNOWN",
                Self::Style2024 => "STYLE2024",
                Self::StyleLegacy => "STYLE_LEGACY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ENFORCE_NAMING_STYLE_UNKNOWN" => Some(Self::Unknown),
                "STYLE2024" => Some(Self::Style2024),
                "STYLE_LEGACY" => Some(Self::StyleLegacy),
                _ => None,
            }
        }
    }
}
/// 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, PartialEq, ::prost::Message)]
pub struct FeatureSetDefaults {
    #[prost(message, repeated, tag = "1")]
    pub defaults: ::prost::alloc::vec::Vec<
        feature_set_defaults::FeatureSetEditionDefault,
    >,
    /// The minimum supported edition (inclusive) when this was constructed.
    /// Editions before this will not have defaults.
    #[prost(enumeration = "Edition", optional, tag = "4")]
    pub minimum_edition: ::core::option::Option<i32>,
    /// The maximum known edition (inclusive) when this was constructed. Editions
    /// after this will not have reliable defaults.
    #[prost(enumeration = "Edition", optional, tag = "5")]
    pub maximum_edition: ::core::option::Option<i32>,
}
/// Nested message and enum types in `FeatureSetDefaults`.
pub mod feature_set_defaults {
    /// 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, Copy, PartialEq, ::prost::Message)]
    pub struct FeatureSetEditionDefault {
        #[prost(enumeration = "super::Edition", optional, tag = "3")]
        pub edition: ::core::option::Option<i32>,
        /// Defaults of features that can be overridden in this edition.
        #[prost(message, optional, tag = "4")]
        pub overridable_features: ::core::option::Option<super::FeatureSet>,
        /// Defaults of features that can't be overridden in this edition.
        #[prost(message, optional, tag = "5")]
        pub fixed_features: ::core::option::Option<super::FeatureSet>,
    }
}
/// Encapsulates information about the original source file from which a
/// FileDescriptorProto was generated.
#[derive(Clone, PartialEq, ::prost::Message)]
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.
    #[prost(message, repeated, tag = "1")]
    pub location: ::prost::alloc::vec::Vec<source_code_info::Location>,
}
/// Nested message and enum types in `SourceCodeInfo`.
pub mod source_code_info {
    #[derive(Clone, PartialEq, ::prost::Message)]
    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).
        #[prost(int32, repeated, tag = "1")]
        pub path: ::prost::alloc::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.
        #[prost(int32, repeated, tag = "2")]
        pub span: ::prost::alloc::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.
        #[prost(string, optional, tag = "3")]
        pub leading_comments: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(string, optional, tag = "4")]
        pub trailing_comments: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(string, repeated, tag = "6")]
        pub leading_detached_comments: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
    }
}
/// 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, PartialEq, ::prost::Message)]
pub struct GeneratedCodeInfo {
    /// An Annotation connects some span of text in generated code to an element
    /// of its generating .proto file.
    #[prost(message, repeated, tag = "1")]
    pub annotation: ::prost::alloc::vec::Vec<generated_code_info::Annotation>,
}
/// Nested message and enum types in `GeneratedCodeInfo`.
pub mod generated_code_info {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Annotation {
        /// Identifies the element in the original source .proto file. This field
        /// is formatted the same as SourceCodeInfo.Location.path.
        #[prost(int32, repeated, tag = "1")]
        pub path: ::prost::alloc::vec::Vec<i32>,
        /// Identifies the filesystem path to the original source .proto.
        #[prost(string, optional, tag = "2")]
        pub source_file: ::core::option::Option<::prost::alloc::string::String>,
        /// Identifies the starting offset in bytes in the generated code
        /// that relates to the identified object.
        #[prost(int32, optional, tag = "3")]
        pub begin: ::core::option::Option<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).
        #[prost(int32, optional, tag = "4")]
        pub end: ::core::option::Option<i32>,
        #[prost(enumeration = "annotation::Semantic", optional, tag = "5")]
        pub semantic: ::core::option::Option<i32>,
    }
    /// Nested message and enum types in `Annotation`.
    pub mod annotation {
        /// Represents the identified object's effect on the element in the original
        /// .proto file.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Semantic {
            /// There is no effect or the effect is indescribable.
            None = 0,
            /// The element is set or otherwise mutated.
            Set = 1,
            /// An alias to the element is returned.
            Alias = 2,
        }
        impl Semantic {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::None => "NONE",
                    Self::Set => "SET",
                    Self::Alias => "ALIAS",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "NONE" => Some(Self::None),
                    "SET" => Some(Self::Set),
                    "ALIAS" => Some(Self::Alias),
                    _ => None,
                }
            }
        }
    }
}
/// The full set of known editions.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Edition {
    /// A placeholder for an unknown edition value.
    Unknown = 0,
    /// A placeholder edition for specifying default behaviors *before* a feature
    /// was first introduced.  This is effectively an "infinite past".
    Legacy = 900,
    /// 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 = 998,
    Proto3 = 999,
    /// 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 = 1000,
    Edition2024 = 1001,
    /// Placeholder editions for testing feature resolution.  These should not be
    /// used or relied on outside of tests.
    Edition1TestOnly = 1,
    Edition2TestOnly = 2,
    Edition99997TestOnly = 99997,
    Edition99998TestOnly = 99998,
    Edition99999TestOnly = 99999,
    /// 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 = 2147483647,
}
impl Edition {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unknown => "EDITION_UNKNOWN",
            Self::Legacy => "EDITION_LEGACY",
            Self::Proto2 => "EDITION_PROTO2",
            Self::Proto3 => "EDITION_PROTO3",
            Self::Edition2023 => "EDITION_2023",
            Self::Edition2024 => "EDITION_2024",
            Self::Edition1TestOnly => "EDITION_1_TEST_ONLY",
            Self::Edition2TestOnly => "EDITION_2_TEST_ONLY",
            Self::Edition99997TestOnly => "EDITION_99997_TEST_ONLY",
            Self::Edition99998TestOnly => "EDITION_99998_TEST_ONLY",
            Self::Edition99999TestOnly => "EDITION_99999_TEST_ONLY",
            Self::Max => "EDITION_MAX",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EDITION_UNKNOWN" => Some(Self::Unknown),
            "EDITION_LEGACY" => Some(Self::Legacy),
            "EDITION_PROTO2" => Some(Self::Proto2),
            "EDITION_PROTO3" => Some(Self::Proto3),
            "EDITION_2023" => Some(Self::Edition2023),
            "EDITION_2024" => Some(Self::Edition2024),
            "EDITION_1_TEST_ONLY" => Some(Self::Edition1TestOnly),
            "EDITION_2_TEST_ONLY" => Some(Self::Edition2TestOnly),
            "EDITION_99997_TEST_ONLY" => Some(Self::Edition99997TestOnly),
            "EDITION_99998_TEST_ONLY" => Some(Self::Edition99998TestOnly),
            "EDITION_99999_TEST_ONLY" => Some(Self::Edition99999TestOnly),
            "EDITION_MAX" => Some(Self::Max),
            _ => None,
        }
    }
}
/// Describes the 'visibility' of a symbol with respect to the proto import
/// system. Symbols can only be imported when the visibility rules do not prevent
/// it (ex: local symbols cannot be imported).  Visibility modifiers can only set
/// on `message` and `enum` as they are the only types available to be referenced
/// from other files.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SymbolVisibility {
    VisibilityUnset = 0,
    VisibilityLocal = 1,
    VisibilityExport = 2,
}
impl SymbolVisibility {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::VisibilityUnset => "VISIBILITY_UNSET",
            Self::VisibilityLocal => "VISIBILITY_LOCAL",
            Self::VisibilityExport => "VISIBILITY_EXPORT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "VISIBILITY_UNSET" => Some(Self::VisibilityUnset),
            "VISIBILITY_LOCAL" => Some(Self::VisibilityLocal),
            "VISIBILITY_EXPORT" => Some(Self::VisibilityExport),
            _ => None,
        }
    }
}
/// A Duration represents a signed, fixed-length span of time represented
/// as a count of seconds and fractions of seconds at nanosecond
/// resolution. It is independent of any calendar and concepts like "day"
/// or "month". It is related to Timestamp in that the difference between
/// two Timestamp values is a Duration and it can be added or subtracted
/// from a Timestamp. Range is approximately +-10,000 years.
///
/// # Examples
///
/// Example 1: Compute Duration from two Timestamps in pseudo code.
///
///      Timestamp start = ...;
///      Timestamp end = ...;
///      Duration duration = ...;
///
///      duration.seconds = end.seconds - start.seconds;
///      duration.nanos = end.nanos - start.nanos;
///
///      if (duration.seconds < 0 && duration.nanos > 0) {
///        duration.seconds += 1;
///        duration.nanos -= 1000000000;
///      } else if (duration.seconds > 0 && duration.nanos < 0) {
///        duration.seconds -= 1;
///        duration.nanos += 1000000000;
///      }
///
/// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
///
///      Timestamp start = ...;
///      Duration duration = ...;
///      Timestamp end = ...;
///
///      end.seconds = start.seconds + duration.seconds;
///      end.nanos = start.nanos + duration.nanos;
///
///      if (end.nanos < 0) {
///        end.seconds -= 1;
///        end.nanos += 1000000000;
///      } else if (end.nanos >= 1000000000) {
///        end.seconds += 1;
///        end.nanos -= 1000000000;
///      }
///
/// Example 3: Compute Duration from datetime.timedelta in Python.
///
///      td = datetime.timedelta(days=3, minutes=10)
///      duration = Duration()
///      duration.FromTimedelta(td)
///
/// # JSON Mapping
///
/// In JSON format, the Duration type is encoded as a string rather than an
/// object, where the string ends in the suffix "s" (indicating seconds) and
/// is preceded by the number of seconds, with nanoseconds expressed as
/// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
/// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
/// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
/// microsecond should be expressed in JSON format as "3.000001s".
///
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct Duration {
    /// Signed seconds of the span of time. Must be from -315,576,000,000
    /// to +315,576,000,000 inclusive. Note: these bounds are computed from:
    /// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
    #[prost(int64, tag = "1")]
    pub seconds: i64,
    /// Signed fractions of a second at nanosecond resolution of the span
    /// of time. Durations less than one second are represented with a 0
    /// `seconds` field and a positive or negative `nanos` field. For durations
    /// of one second or more, a non-zero value for the `nanos` field must be
    /// of the same sign as the `seconds` field. Must be from -999,999,999
    /// to +999,999,999 inclusive.
    #[prost(int32, tag = "2")]
    pub nanos: i32,
}
/// A generic empty message that you can re-use to avoid defining duplicated
/// empty messages in your APIs. A typical example is to use it as the request
/// or the response type of an API method. For instance:
///
///      service Foo {
///        rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
///      }
///
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct Empty {}