spiffe 0.2.1

// This file is generated by rust-protobuf 2.24.1. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `workload.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_24_1;

#[derive(PartialEq,Clone,Default)]
pub struct X509SVIDRequest {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a X509SVIDRequest {
    fn default() -> &'a X509SVIDRequest {
        <X509SVIDRequest as ::protobuf::Message>::default_instance()
    }
}

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

impl ::protobuf::Message for X509SVIDRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> X509SVIDRequest {
        X509SVIDRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<X509SVIDRequest>(
                "X509SVIDRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static X509SVIDRequest {
        static instance: ::protobuf::rt::LazyV2<X509SVIDRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(X509SVIDRequest::new)
    }
}

impl ::protobuf::Clear for X509SVIDRequest {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for X509SVIDRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for X509SVIDRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct X509SVIDResponse {
    // message fields
    pub svids: ::protobuf::RepeatedField<X509SVID>,
    pub crl: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
    pub federated_bundles: ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a X509SVIDResponse {
    fn default() -> &'a X509SVIDResponse {
        <X509SVIDResponse as ::protobuf::Message>::default_instance()
    }
}

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

    // repeated .X509SVID svids = 1;


    pub fn get_svids(&self) -> &[X509SVID] {
        &self.svids
    }
    pub fn clear_svids(&mut self) {
        self.svids.clear();
    }

    // Param is passed by value, moved
    pub fn set_svids(&mut self, v: ::protobuf::RepeatedField<X509SVID>) {
        self.svids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_svids(&mut self) -> &mut ::protobuf::RepeatedField<X509SVID> {
        &mut self.svids
    }

    // Take field
    pub fn take_svids(&mut self) -> ::protobuf::RepeatedField<X509SVID> {
        ::std::mem::replace(&mut self.svids, ::protobuf::RepeatedField::new())
    }

    // repeated bytes crl = 2;


    pub fn get_crl(&self) -> &[::std::vec::Vec<u8>] {
        &self.crl
    }
    pub fn clear_crl(&mut self) {
        self.crl.clear();
    }

    // Param is passed by value, moved
    pub fn set_crl(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
        self.crl = v;
    }

    // Mutable pointer to the field.
    pub fn mut_crl(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        &mut self.crl
    }

    // Take field
    pub fn take_crl(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        ::std::mem::replace(&mut self.crl, ::protobuf::RepeatedField::new())
    }

    // repeated .X509SVIDResponse.FederatedBundlesEntry federated_bundles = 3;


    pub fn get_federated_bundles(&self) -> &::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>> {
        &self.federated_bundles
    }
    pub fn clear_federated_bundles(&mut self) {
        self.federated_bundles.clear();
    }

    // Param is passed by value, moved
    pub fn set_federated_bundles(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>>) {
        self.federated_bundles = v;
    }

    // Mutable pointer to the field.
    pub fn mut_federated_bundles(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>> {
        &mut self.federated_bundles
    }

    // Take field
    pub fn take_federated_bundles(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>> {
        ::std::mem::replace(&mut self.federated_bundles, ::std::collections::HashMap::new())
    }
}

impl ::protobuf::Message for X509SVIDResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.svids {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.svids)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.crl)?;
                },
                3 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(wire_type, is, &mut self.federated_bundles)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.svids {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.crl {
            my_size += ::protobuf::rt::bytes_size(2, &value);
        };
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(3, &self.federated_bundles);
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.svids {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.crl {
            os.write_bytes(2, &v)?;
        };
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(3, &self.federated_bundles, os)?;
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> X509SVIDResponse {
        X509SVIDResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<X509SVID>>(
                "svids",
                |m: &X509SVIDResponse| { &m.svids },
                |m: &mut X509SVIDResponse| { &mut m.svids },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "crl",
                |m: &X509SVIDResponse| { &m.crl },
                |m: &mut X509SVIDResponse| { &mut m.crl },
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(
                "federated_bundles",
                |m: &X509SVIDResponse| { &m.federated_bundles },
                |m: &mut X509SVIDResponse| { &mut m.federated_bundles },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<X509SVIDResponse>(
                "X509SVIDResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static X509SVIDResponse {
        static instance: ::protobuf::rt::LazyV2<X509SVIDResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(X509SVIDResponse::new)
    }
}

impl ::protobuf::Clear for X509SVIDResponse {
    fn clear(&mut self) {
        self.svids.clear();
        self.crl.clear();
        self.federated_bundles.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for X509SVIDResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for X509SVIDResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct X509SVID {
    // message fields
    pub spiffe_id: ::std::string::String,
    pub x509_svid: ::std::vec::Vec<u8>,
    pub x509_svid_key: ::std::vec::Vec<u8>,
    pub bundle: ::std::vec::Vec<u8>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a X509SVID {
    fn default() -> &'a X509SVID {
        <X509SVID as ::protobuf::Message>::default_instance()
    }
}

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

    // string spiffe_id = 1;


    pub fn get_spiffe_id(&self) -> &str {
        &self.spiffe_id
    }
    pub fn clear_spiffe_id(&mut self) {
        self.spiffe_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_spiffe_id(&mut self, v: ::std::string::String) {
        self.spiffe_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_spiffe_id(&mut self) -> &mut ::std::string::String {
        &mut self.spiffe_id
    }

    // Take field
    pub fn take_spiffe_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.spiffe_id, ::std::string::String::new())
    }

    // bytes x509_svid = 2;


    pub fn get_x509_svid(&self) -> &[u8] {
        &self.x509_svid
    }
    pub fn clear_x509_svid(&mut self) {
        self.x509_svid.clear();
    }

    // Param is passed by value, moved
    pub fn set_x509_svid(&mut self, v: ::std::vec::Vec<u8>) {
        self.x509_svid = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_x509_svid(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.x509_svid
    }

    // Take field
    pub fn take_x509_svid(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.x509_svid, ::std::vec::Vec::new())
    }

    // bytes x509_svid_key = 3;


    pub fn get_x509_svid_key(&self) -> &[u8] {
        &self.x509_svid_key
    }
    pub fn clear_x509_svid_key(&mut self) {
        self.x509_svid_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_x509_svid_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.x509_svid_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_x509_svid_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.x509_svid_key
    }

    // Take field
    pub fn take_x509_svid_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.x509_svid_key, ::std::vec::Vec::new())
    }

    // bytes bundle = 4;


    pub fn get_bundle(&self) -> &[u8] {
        &self.bundle
    }
    pub fn clear_bundle(&mut self) {
        self.bundle.clear();
    }

    // Param is passed by value, moved
    pub fn set_bundle(&mut self, v: ::std::vec::Vec<u8>) {
        self.bundle = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_bundle(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.bundle
    }

    // Take field
    pub fn take_bundle(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.bundle, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for X509SVID {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.spiffe_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.x509_svid)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.x509_svid_key)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.bundle)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.spiffe_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.spiffe_id);
        }
        if !self.x509_svid.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.x509_svid);
        }
        if !self.x509_svid_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.x509_svid_key);
        }
        if !self.bundle.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.bundle);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.spiffe_id.is_empty() {
            os.write_string(1, &self.spiffe_id)?;
        }
        if !self.x509_svid.is_empty() {
            os.write_bytes(2, &self.x509_svid)?;
        }
        if !self.x509_svid_key.is_empty() {
            os.write_bytes(3, &self.x509_svid_key)?;
        }
        if !self.bundle.is_empty() {
            os.write_bytes(4, &self.bundle)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> X509SVID {
        X509SVID::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "spiffe_id",
                |m: &X509SVID| { &m.spiffe_id },
                |m: &mut X509SVID| { &mut m.spiffe_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "x509_svid",
                |m: &X509SVID| { &m.x509_svid },
                |m: &mut X509SVID| { &mut m.x509_svid },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "x509_svid_key",
                |m: &X509SVID| { &m.x509_svid_key },
                |m: &mut X509SVID| { &mut m.x509_svid_key },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "bundle",
                |m: &X509SVID| { &m.bundle },
                |m: &mut X509SVID| { &mut m.bundle },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<X509SVID>(
                "X509SVID",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static X509SVID {
        static instance: ::protobuf::rt::LazyV2<X509SVID> = ::protobuf::rt::LazyV2::INIT;
        instance.get(X509SVID::new)
    }
}

impl ::protobuf::Clear for X509SVID {
    fn clear(&mut self) {
        self.spiffe_id.clear();
        self.x509_svid.clear();
        self.x509_svid_key.clear();
        self.bundle.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for X509SVID {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for X509SVID {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct X509BundlesRequest {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a X509BundlesRequest {
    fn default() -> &'a X509BundlesRequest {
        <X509BundlesRequest as ::protobuf::Message>::default_instance()
    }
}

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

impl ::protobuf::Message for X509BundlesRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> X509BundlesRequest {
        X509BundlesRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<X509BundlesRequest>(
                "X509BundlesRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static X509BundlesRequest {
        static instance: ::protobuf::rt::LazyV2<X509BundlesRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(X509BundlesRequest::new)
    }
}

impl ::protobuf::Clear for X509BundlesRequest {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for X509BundlesRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for X509BundlesRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct X509BundlesResponse {
    // message fields
    pub crl: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
    pub bundles: ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a X509BundlesResponse {
    fn default() -> &'a X509BundlesResponse {
        <X509BundlesResponse as ::protobuf::Message>::default_instance()
    }
}

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

    // repeated bytes crl = 1;


    pub fn get_crl(&self) -> &[::std::vec::Vec<u8>] {
        &self.crl
    }
    pub fn clear_crl(&mut self) {
        self.crl.clear();
    }

    // Param is passed by value, moved
    pub fn set_crl(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
        self.crl = v;
    }

    // Mutable pointer to the field.
    pub fn mut_crl(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        &mut self.crl
    }

    // Take field
    pub fn take_crl(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        ::std::mem::replace(&mut self.crl, ::protobuf::RepeatedField::new())
    }

    // repeated .X509BundlesResponse.BundlesEntry bundles = 2;


    pub fn get_bundles(&self) -> &::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>> {
        &self.bundles
    }
    pub fn clear_bundles(&mut self) {
        self.bundles.clear();
    }

    // Param is passed by value, moved
    pub fn set_bundles(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>>) {
        self.bundles = v;
    }

    // Mutable pointer to the field.
    pub fn mut_bundles(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>> {
        &mut self.bundles
    }

    // Take field
    pub fn take_bundles(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>> {
        ::std::mem::replace(&mut self.bundles, ::std::collections::HashMap::new())
    }
}

impl ::protobuf::Message for X509BundlesResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.crl)?;
                },
                2 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(wire_type, is, &mut self.bundles)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.crl {
            my_size += ::protobuf::rt::bytes_size(1, &value);
        };
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(2, &self.bundles);
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.crl {
            os.write_bytes(1, &v)?;
        };
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(2, &self.bundles, os)?;
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> X509BundlesResponse {
        X509BundlesResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "crl",
                |m: &X509BundlesResponse| { &m.crl },
                |m: &mut X509BundlesResponse| { &mut m.crl },
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(
                "bundles",
                |m: &X509BundlesResponse| { &m.bundles },
                |m: &mut X509BundlesResponse| { &mut m.bundles },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<X509BundlesResponse>(
                "X509BundlesResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static X509BundlesResponse {
        static instance: ::protobuf::rt::LazyV2<X509BundlesResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(X509BundlesResponse::new)
    }
}

impl ::protobuf::Clear for X509BundlesResponse {
    fn clear(&mut self) {
        self.crl.clear();
        self.bundles.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for X509BundlesResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for X509BundlesResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct JWTSVIDRequest {
    // message fields
    pub audience: ::protobuf::RepeatedField<::std::string::String>,
    pub spiffe_id: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a JWTSVIDRequest {
    fn default() -> &'a JWTSVIDRequest {
        <JWTSVIDRequest as ::protobuf::Message>::default_instance()
    }
}

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

    // repeated string audience = 1;


    pub fn get_audience(&self) -> &[::std::string::String] {
        &self.audience
    }
    pub fn clear_audience(&mut self) {
        self.audience.clear();
    }

    // Param is passed by value, moved
    pub fn set_audience(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.audience = v;
    }

    // Mutable pointer to the field.
    pub fn mut_audience(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.audience
    }

    // Take field
    pub fn take_audience(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.audience, ::protobuf::RepeatedField::new())
    }

    // string spiffe_id = 2;


    pub fn get_spiffe_id(&self) -> &str {
        &self.spiffe_id
    }
    pub fn clear_spiffe_id(&mut self) {
        self.spiffe_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_spiffe_id(&mut self, v: ::std::string::String) {
        self.spiffe_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_spiffe_id(&mut self) -> &mut ::std::string::String {
        &mut self.spiffe_id
    }

    // Take field
    pub fn take_spiffe_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.spiffe_id, ::std::string::String::new())
    }
}

impl ::protobuf::Message for JWTSVIDRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.audience)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.spiffe_id)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.audience {
            my_size += ::protobuf::rt::string_size(1, &value);
        };
        if !self.spiffe_id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.spiffe_id);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.audience {
            os.write_string(1, &v)?;
        };
        if !self.spiffe_id.is_empty() {
            os.write_string(2, &self.spiffe_id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> JWTSVIDRequest {
        JWTSVIDRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "audience",
                |m: &JWTSVIDRequest| { &m.audience },
                |m: &mut JWTSVIDRequest| { &mut m.audience },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "spiffe_id",
                |m: &JWTSVIDRequest| { &m.spiffe_id },
                |m: &mut JWTSVIDRequest| { &mut m.spiffe_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<JWTSVIDRequest>(
                "JWTSVIDRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static JWTSVIDRequest {
        static instance: ::protobuf::rt::LazyV2<JWTSVIDRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(JWTSVIDRequest::new)
    }
}

impl ::protobuf::Clear for JWTSVIDRequest {
    fn clear(&mut self) {
        self.audience.clear();
        self.spiffe_id.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for JWTSVIDRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for JWTSVIDRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct JWTSVIDResponse {
    // message fields
    pub svids: ::protobuf::RepeatedField<JWTSVID>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a JWTSVIDResponse {
    fn default() -> &'a JWTSVIDResponse {
        <JWTSVIDResponse as ::protobuf::Message>::default_instance()
    }
}

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

    // repeated .JWTSVID svids = 1;


    pub fn get_svids(&self) -> &[JWTSVID] {
        &self.svids
    }
    pub fn clear_svids(&mut self) {
        self.svids.clear();
    }

    // Param is passed by value, moved
    pub fn set_svids(&mut self, v: ::protobuf::RepeatedField<JWTSVID>) {
        self.svids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_svids(&mut self) -> &mut ::protobuf::RepeatedField<JWTSVID> {
        &mut self.svids
    }

    // Take field
    pub fn take_svids(&mut self) -> ::protobuf::RepeatedField<JWTSVID> {
        ::std::mem::replace(&mut self.svids, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for JWTSVIDResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.svids {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.svids)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.svids {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.svids {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> JWTSVIDResponse {
        JWTSVIDResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<JWTSVID>>(
                "svids",
                |m: &JWTSVIDResponse| { &m.svids },
                |m: &mut JWTSVIDResponse| { &mut m.svids },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<JWTSVIDResponse>(
                "JWTSVIDResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static JWTSVIDResponse {
        static instance: ::protobuf::rt::LazyV2<JWTSVIDResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(JWTSVIDResponse::new)
    }
}

impl ::protobuf::Clear for JWTSVIDResponse {
    fn clear(&mut self) {
        self.svids.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for JWTSVIDResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for JWTSVIDResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct JWTSVID {
    // message fields
    pub spiffe_id: ::std::string::String,
    pub svid: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a JWTSVID {
    fn default() -> &'a JWTSVID {
        <JWTSVID as ::protobuf::Message>::default_instance()
    }
}

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

    // string spiffe_id = 1;


    pub fn get_spiffe_id(&self) -> &str {
        &self.spiffe_id
    }
    pub fn clear_spiffe_id(&mut self) {
        self.spiffe_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_spiffe_id(&mut self, v: ::std::string::String) {
        self.spiffe_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_spiffe_id(&mut self) -> &mut ::std::string::String {
        &mut self.spiffe_id
    }

    // Take field
    pub fn take_spiffe_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.spiffe_id, ::std::string::String::new())
    }

    // string svid = 2;


    pub fn get_svid(&self) -> &str {
        &self.svid
    }
    pub fn clear_svid(&mut self) {
        self.svid.clear();
    }

    // Param is passed by value, moved
    pub fn set_svid(&mut self, v: ::std::string::String) {
        self.svid = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_svid(&mut self) -> &mut ::std::string::String {
        &mut self.svid
    }

    // Take field
    pub fn take_svid(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.svid, ::std::string::String::new())
    }
}

impl ::protobuf::Message for JWTSVID {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.spiffe_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.svid)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.spiffe_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.spiffe_id);
        }
        if !self.svid.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.svid);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.spiffe_id.is_empty() {
            os.write_string(1, &self.spiffe_id)?;
        }
        if !self.svid.is_empty() {
            os.write_string(2, &self.svid)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> JWTSVID {
        JWTSVID::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "spiffe_id",
                |m: &JWTSVID| { &m.spiffe_id },
                |m: &mut JWTSVID| { &mut m.spiffe_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "svid",
                |m: &JWTSVID| { &m.svid },
                |m: &mut JWTSVID| { &mut m.svid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<JWTSVID>(
                "JWTSVID",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static JWTSVID {
        static instance: ::protobuf::rt::LazyV2<JWTSVID> = ::protobuf::rt::LazyV2::INIT;
        instance.get(JWTSVID::new)
    }
}

impl ::protobuf::Clear for JWTSVID {
    fn clear(&mut self) {
        self.spiffe_id.clear();
        self.svid.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for JWTSVID {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for JWTSVID {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct JWTBundlesRequest {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a JWTBundlesRequest {
    fn default() -> &'a JWTBundlesRequest {
        <JWTBundlesRequest as ::protobuf::Message>::default_instance()
    }
}

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

impl ::protobuf::Message for JWTBundlesRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> JWTBundlesRequest {
        JWTBundlesRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<JWTBundlesRequest>(
                "JWTBundlesRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static JWTBundlesRequest {
        static instance: ::protobuf::rt::LazyV2<JWTBundlesRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(JWTBundlesRequest::new)
    }
}

impl ::protobuf::Clear for JWTBundlesRequest {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for JWTBundlesRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for JWTBundlesRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct JWTBundlesResponse {
    // message fields
    pub bundles: ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a JWTBundlesResponse {
    fn default() -> &'a JWTBundlesResponse {
        <JWTBundlesResponse as ::protobuf::Message>::default_instance()
    }
}

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

    // repeated .JWTBundlesResponse.BundlesEntry bundles = 1;


    pub fn get_bundles(&self) -> &::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>> {
        &self.bundles
    }
    pub fn clear_bundles(&mut self) {
        self.bundles.clear();
    }

    // Param is passed by value, moved
    pub fn set_bundles(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>>) {
        self.bundles = v;
    }

    // Mutable pointer to the field.
    pub fn mut_bundles(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>> {
        &mut self.bundles
    }

    // Take field
    pub fn take_bundles(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<u8>> {
        ::std::mem::replace(&mut self.bundles, ::std::collections::HashMap::new())
    }
}

impl ::protobuf::Message for JWTBundlesResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(wire_type, is, &mut self.bundles)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(1, &self.bundles);
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(1, &self.bundles, os)?;
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> JWTBundlesResponse {
        JWTBundlesResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeBytes>(
                "bundles",
                |m: &JWTBundlesResponse| { &m.bundles },
                |m: &mut JWTBundlesResponse| { &mut m.bundles },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<JWTBundlesResponse>(
                "JWTBundlesResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static JWTBundlesResponse {
        static instance: ::protobuf::rt::LazyV2<JWTBundlesResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(JWTBundlesResponse::new)
    }
}

impl ::protobuf::Clear for JWTBundlesResponse {
    fn clear(&mut self) {
        self.bundles.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for JWTBundlesResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for JWTBundlesResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ValidateJWTSVIDRequest {
    // message fields
    pub audience: ::std::string::String,
    pub svid: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ValidateJWTSVIDRequest {
    fn default() -> &'a ValidateJWTSVIDRequest {
        <ValidateJWTSVIDRequest as ::protobuf::Message>::default_instance()
    }
}

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

    // string audience = 1;


    pub fn get_audience(&self) -> &str {
        &self.audience
    }
    pub fn clear_audience(&mut self) {
        self.audience.clear();
    }

    // Param is passed by value, moved
    pub fn set_audience(&mut self, v: ::std::string::String) {
        self.audience = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_audience(&mut self) -> &mut ::std::string::String {
        &mut self.audience
    }

    // Take field
    pub fn take_audience(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.audience, ::std::string::String::new())
    }

    // string svid = 2;


    pub fn get_svid(&self) -> &str {
        &self.svid
    }
    pub fn clear_svid(&mut self) {
        self.svid.clear();
    }

    // Param is passed by value, moved
    pub fn set_svid(&mut self, v: ::std::string::String) {
        self.svid = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_svid(&mut self) -> &mut ::std::string::String {
        &mut self.svid
    }

    // Take field
    pub fn take_svid(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.svid, ::std::string::String::new())
    }
}

impl ::protobuf::Message for ValidateJWTSVIDRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.audience)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.svid)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.audience.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.audience);
        }
        if !self.svid.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.svid);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.audience.is_empty() {
            os.write_string(1, &self.audience)?;
        }
        if !self.svid.is_empty() {
            os.write_string(2, &self.svid)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ValidateJWTSVIDRequest {
        ValidateJWTSVIDRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "audience",
                |m: &ValidateJWTSVIDRequest| { &m.audience },
                |m: &mut ValidateJWTSVIDRequest| { &mut m.audience },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "svid",
                |m: &ValidateJWTSVIDRequest| { &m.svid },
                |m: &mut ValidateJWTSVIDRequest| { &mut m.svid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ValidateJWTSVIDRequest>(
                "ValidateJWTSVIDRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ValidateJWTSVIDRequest {
        static instance: ::protobuf::rt::LazyV2<ValidateJWTSVIDRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ValidateJWTSVIDRequest::new)
    }
}

impl ::protobuf::Clear for ValidateJWTSVIDRequest {
    fn clear(&mut self) {
        self.audience.clear();
        self.svid.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ValidateJWTSVIDRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ValidateJWTSVIDRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ValidateJWTSVIDResponse {
    // message fields
    pub spiffe_id: ::std::string::String,
    pub claims: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ValidateJWTSVIDResponse {
    fn default() -> &'a ValidateJWTSVIDResponse {
        <ValidateJWTSVIDResponse as ::protobuf::Message>::default_instance()
    }
}

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

    // string spiffe_id = 1;


    pub fn get_spiffe_id(&self) -> &str {
        &self.spiffe_id
    }
    pub fn clear_spiffe_id(&mut self) {
        self.spiffe_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_spiffe_id(&mut self, v: ::std::string::String) {
        self.spiffe_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_spiffe_id(&mut self) -> &mut ::std::string::String {
        &mut self.spiffe_id
    }

    // Take field
    pub fn take_spiffe_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.spiffe_id, ::std::string::String::new())
    }

    // .google.protobuf.Struct claims = 2;


    pub fn get_claims(&self) -> &::protobuf::well_known_types::Struct {
        self.claims.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Struct as ::protobuf::Message>::default_instance())
    }
    pub fn clear_claims(&mut self) {
        self.claims.clear();
    }

    pub fn has_claims(&self) -> bool {
        self.claims.is_some()
    }

    // Param is passed by value, moved
    pub fn set_claims(&mut self, v: ::protobuf::well_known_types::Struct) {
        self.claims = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_claims(&mut self) -> &mut ::protobuf::well_known_types::Struct {
        if self.claims.is_none() {
            self.claims.set_default();
        }
        self.claims.as_mut().unwrap()
    }

    // Take field
    pub fn take_claims(&mut self) -> ::protobuf::well_known_types::Struct {
        self.claims.take().unwrap_or_else(|| ::protobuf::well_known_types::Struct::new())
    }
}

impl ::protobuf::Message for ValidateJWTSVIDResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.claims {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.spiffe_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.claims)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.spiffe_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.spiffe_id);
        }
        if let Some(ref v) = self.claims.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.spiffe_id.is_empty() {
            os.write_string(1, &self.spiffe_id)?;
        }
        if let Some(ref v) = self.claims.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ValidateJWTSVIDResponse {
        ValidateJWTSVIDResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "spiffe_id",
                |m: &ValidateJWTSVIDResponse| { &m.spiffe_id },
                |m: &mut ValidateJWTSVIDResponse| { &mut m.spiffe_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>(
                "claims",
                |m: &ValidateJWTSVIDResponse| { &m.claims },
                |m: &mut ValidateJWTSVIDResponse| { &mut m.claims },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ValidateJWTSVIDResponse>(
                "ValidateJWTSVIDResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ValidateJWTSVIDResponse {
        static instance: ::protobuf::rt::LazyV2<ValidateJWTSVIDResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ValidateJWTSVIDResponse::new)
    }
}

impl ::protobuf::Clear for ValidateJWTSVIDResponse {
    fn clear(&mut self) {
        self.spiffe_id.clear();
        self.claims.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ValidateJWTSVIDResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ValidateJWTSVIDResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x0eworkload.proto\x1a\x1cgoogle/protobuf/struct.proto\"\x11\n\x0fX509\
    SVIDRequest\"\xe0\x01\n\x10X509SVIDResponse\x12\x1f\n\x05svids\x18\x01\
    \x20\x03(\x0b2\t.X509SVIDR\x05svids\x12\x10\n\x03crl\x18\x02\x20\x03(\
    \x0cR\x03crl\x12T\n\x11federated_bundles\x18\x03\x20\x03(\x0b2'.X509SVID\
    Response.FederatedBundlesEntryR\x10federatedBundles\x1aC\n\x15FederatedB\
    undlesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05val\
    ue\x18\x02\x20\x01(\x0cR\x05value:\x028\x01\"\x80\x01\n\x08X509SVID\x12\
    \x1b\n\tspiffe_id\x18\x01\x20\x01(\tR\x08spiffeId\x12\x1b\n\tx509_svid\
    \x18\x02\x20\x01(\x0cR\x08x509Svid\x12\"\n\rx509_svid_key\x18\x03\x20\
    \x01(\x0cR\x0bx509SvidKey\x12\x16\n\x06bundle\x18\x04\x20\x01(\x0cR\x06b\
    undle\"\x14\n\x12X509BundlesRequest\"\xa0\x01\n\x13X509BundlesResponse\
    \x12\x10\n\x03crl\x18\x01\x20\x03(\x0cR\x03crl\x12;\n\x07bundles\x18\x02\
    \x20\x03(\x0b2!.X509BundlesResponse.BundlesEntryR\x07bundles\x1a:\n\x0cB\
    undlesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05val\
    ue\x18\x02\x20\x01(\x0cR\x05value:\x028\x01\"I\n\x0eJWTSVIDRequest\x12\
    \x1a\n\x08audience\x18\x01\x20\x03(\tR\x08audience\x12\x1b\n\tspiffe_id\
    \x18\x02\x20\x01(\tR\x08spiffeId\"1\n\x0fJWTSVIDResponse\x12\x1e\n\x05sv\
    ids\x18\x01\x20\x03(\x0b2\x08.JWTSVIDR\x05svids\":\n\x07JWTSVID\x12\x1b\
    \n\tspiffe_id\x18\x01\x20\x01(\tR\x08spiffeId\x12\x12\n\x04svid\x18\x02\
    \x20\x01(\tR\x04svid\"\x13\n\x11JWTBundlesRequest\"\x8c\x01\n\x12JWTBund\
    lesResponse\x12:\n\x07bundles\x18\x01\x20\x03(\x0b2\x20.JWTBundlesRespon\
    se.BundlesEntryR\x07bundles\x1a:\n\x0cBundlesEntry\x12\x10\n\x03key\x18\
    \x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\x0cR\x05valu\
    e:\x028\x01\"H\n\x16ValidateJWTSVIDRequest\x12\x1a\n\x08audience\x18\x01\
    \x20\x01(\tR\x08audience\x12\x12\n\x04svid\x18\x02\x20\x01(\tR\x04svid\"\
    g\n\x17ValidateJWTSVIDResponse\x12\x1b\n\tspiffe_id\x18\x01\x20\x01(\tR\
    \x08spiffeId\x12/\n\x06claims\x18\x02\x20\x01(\x0b2\x17.google.protobuf.\
    StructR\x06claims2\xc3\x02\n\x11SpiffeWorkloadAPI\x126\n\rFetchX509SVID\
    \x12\x10.X509SVIDRequest\x1a\x11.X509SVIDResponse0\x01\x12?\n\x10FetchX5\
    09Bundles\x12\x13.X509BundlesRequest\x1a\x14.X509BundlesResponse0\x01\
    \x121\n\x0cFetchJWTSVID\x12\x0f.JWTSVIDRequest\x1a\x10.JWTSVIDResponse\
    \x12<\n\x0fFetchJWTBundles\x12\x12.JWTBundlesRequest\x1a\x13.JWTBundlesR\
    esponse0\x01\x12D\n\x0fValidateJWTSVID\x12\x17.ValidateJWTSVIDRequest\
    \x1a\x18.ValidateJWTSVIDResponseb\x06proto3\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}