// This file is generated by rust-protobuf 3.7.2. Do not edit
// .proto file is parsed by protoc 34.1
// @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(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `proto/svrb.proto`
// Generated for lite runtime

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

// @@protoc_insertion_point(message:svrb.client.Request4)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Request4 {
    // message oneof groups
    pub inner: ::std::option::Option<request4::Inner>,
    // special fields
    // @@protoc_insertion_point(special_field:svrb.client.Request4.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .svrb.client.Request4.Create create = 1;

    pub fn create(&self) -> &request4::Create {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Create(ref v)) => v,
            _ => <request4::Create as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_create(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_create(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Create(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_create(&mut self, v: request4::Create) {
        self.inner = ::std::option::Option::Some(request4::Inner::Create(v))
    }

    // Mutable pointer to the field.
    pub fn mut_create(&mut self) -> &mut request4::Create {
        if let ::std::option::Option::Some(request4::Inner::Create(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(request4::Inner::Create(request4::Create::new()));
        }
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Create(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_create(&mut self) -> request4::Create {
        if self.has_create() {
            match self.inner.take() {
                ::std::option::Option::Some(request4::Inner::Create(v)) => v,
                _ => panic!(),
            }
        } else {
            request4::Create::new()
        }
    }

    // .svrb.client.Request4.Restore1 restore1 = 2;

    pub fn restore1(&self) -> &request4::Restore1 {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Restore1(ref v)) => v,
            _ => <request4::Restore1 as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_restore1(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_restore1(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Restore1(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_restore1(&mut self, v: request4::Restore1) {
        self.inner = ::std::option::Option::Some(request4::Inner::Restore1(v))
    }

    // Mutable pointer to the field.
    pub fn mut_restore1(&mut self) -> &mut request4::Restore1 {
        if let ::std::option::Option::Some(request4::Inner::Restore1(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(request4::Inner::Restore1(request4::Restore1::new()));
        }
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Restore1(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_restore1(&mut self) -> request4::Restore1 {
        if self.has_restore1() {
            match self.inner.take() {
                ::std::option::Option::Some(request4::Inner::Restore1(v)) => v,
                _ => panic!(),
            }
        } else {
            request4::Restore1::new()
        }
    }

    // .svrb.client.Request4.Restore2 restore2 = 3;

    pub fn restore2(&self) -> &request4::Restore2 {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Restore2(ref v)) => v,
            _ => <request4::Restore2 as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_restore2(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_restore2(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Restore2(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_restore2(&mut self, v: request4::Restore2) {
        self.inner = ::std::option::Option::Some(request4::Inner::Restore2(v))
    }

    // Mutable pointer to the field.
    pub fn mut_restore2(&mut self) -> &mut request4::Restore2 {
        if let ::std::option::Option::Some(request4::Inner::Restore2(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(request4::Inner::Restore2(request4::Restore2::new()));
        }
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Restore2(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_restore2(&mut self) -> request4::Restore2 {
        if self.has_restore2() {
            match self.inner.take() {
                ::std::option::Option::Some(request4::Inner::Restore2(v)) => v,
                _ => panic!(),
            }
        } else {
            request4::Restore2::new()
        }
    }

    // .svrb.client.Request4.Remove remove = 4;

    pub fn remove(&self) -> &request4::Remove {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Remove(ref v)) => v,
            _ => <request4::Remove as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_remove(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_remove(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Remove(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_remove(&mut self, v: request4::Remove) {
        self.inner = ::std::option::Option::Some(request4::Inner::Remove(v))
    }

    // Mutable pointer to the field.
    pub fn mut_remove(&mut self) -> &mut request4::Remove {
        if let ::std::option::Option::Some(request4::Inner::Remove(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(request4::Inner::Remove(request4::Remove::new()));
        }
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Remove(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_remove(&mut self) -> request4::Remove {
        if self.has_remove() {
            match self.inner.take() {
                ::std::option::Option::Some(request4::Inner::Remove(v)) => v,
                _ => panic!(),
            }
        } else {
            request4::Remove::new()
        }
    }

    // .svrb.client.Request4.Query query = 5;

    pub fn query(&self) -> &request4::Query {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Query(ref v)) => v,
            _ => <request4::Query as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_query(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_query(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Query(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_query(&mut self, v: request4::Query) {
        self.inner = ::std::option::Option::Some(request4::Inner::Query(v))
    }

    // Mutable pointer to the field.
    pub fn mut_query(&mut self) -> &mut request4::Query {
        if let ::std::option::Option::Some(request4::Inner::Query(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(request4::Inner::Query(request4::Query::new()));
        }
        match self.inner {
            ::std::option::Option::Some(request4::Inner::Query(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_query(&mut self) -> request4::Query {
        if self.has_query() {
            match self.inner.take() {
                ::std::option::Option::Some(request4::Inner::Query(v)) => v,
                _ => panic!(),
            }
        } else {
            request4::Query::new()
        }
    }

    // .svrb.client.Request4.RotateStart rotate_start = 6;

    pub fn rotate_start(&self) -> &request4::RotateStart {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::RotateStart(ref v)) => v,
            _ => <request4::RotateStart as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_rotate_start(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_rotate_start(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::RotateStart(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_rotate_start(&mut self, v: request4::RotateStart) {
        self.inner = ::std::option::Option::Some(request4::Inner::RotateStart(v))
    }

    // Mutable pointer to the field.
    pub fn mut_rotate_start(&mut self) -> &mut request4::RotateStart {
        if let ::std::option::Option::Some(request4::Inner::RotateStart(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(request4::Inner::RotateStart(request4::RotateStart::new()));
        }
        match self.inner {
            ::std::option::Option::Some(request4::Inner::RotateStart(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_rotate_start(&mut self) -> request4::RotateStart {
        if self.has_rotate_start() {
            match self.inner.take() {
                ::std::option::Option::Some(request4::Inner::RotateStart(v)) => v,
                _ => panic!(),
            }
        } else {
            request4::RotateStart::new()
        }
    }

    // .svrb.client.Request4.RotateCommit rotate_commit = 7;

    pub fn rotate_commit(&self) -> &request4::RotateCommit {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::RotateCommit(ref v)) => v,
            _ => <request4::RotateCommit as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_rotate_commit(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_rotate_commit(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::RotateCommit(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_rotate_commit(&mut self, v: request4::RotateCommit) {
        self.inner = ::std::option::Option::Some(request4::Inner::RotateCommit(v))
    }

    // Mutable pointer to the field.
    pub fn mut_rotate_commit(&mut self) -> &mut request4::RotateCommit {
        if let ::std::option::Option::Some(request4::Inner::RotateCommit(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(request4::Inner::RotateCommit(request4::RotateCommit::new()));
        }
        match self.inner {
            ::std::option::Option::Some(request4::Inner::RotateCommit(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_rotate_commit(&mut self) -> request4::RotateCommit {
        if self.has_rotate_commit() {
            match self.inner.take() {
                ::std::option::Option::Some(request4::Inner::RotateCommit(v)) => v,
                _ => panic!(),
            }
        } else {
            request4::RotateCommit::new()
        }
    }

    // .svrb.client.Request4.RotateRollback rotate_rollback = 8;

    pub fn rotate_rollback(&self) -> &request4::RotateRollback {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::RotateRollback(ref v)) => v,
            _ => <request4::RotateRollback as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_rotate_rollback(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_rotate_rollback(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(request4::Inner::RotateRollback(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_rotate_rollback(&mut self, v: request4::RotateRollback) {
        self.inner = ::std::option::Option::Some(request4::Inner::RotateRollback(v))
    }

    // Mutable pointer to the field.
    pub fn mut_rotate_rollback(&mut self) -> &mut request4::RotateRollback {
        if let ::std::option::Option::Some(request4::Inner::RotateRollback(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(request4::Inner::RotateRollback(request4::RotateRollback::new()));
        }
        match self.inner {
            ::std::option::Option::Some(request4::Inner::RotateRollback(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_rotate_rollback(&mut self) -> request4::RotateRollback {
        if self.has_rotate_rollback() {
            match self.inner.take() {
                ::std::option::Option::Some(request4::Inner::RotateRollback(v)) => v,
                _ => panic!(),
            }
        } else {
            request4::RotateRollback::new()
        }
    }
}

impl ::protobuf::Message for Request4 {
    const NAME: &'static str = "Request4";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.inner = ::std::option::Option::Some(request4::Inner::Create(is.read_message()?));
                },
                18 => {
                    self.inner = ::std::option::Option::Some(request4::Inner::Restore1(is.read_message()?));
                },
                26 => {
                    self.inner = ::std::option::Option::Some(request4::Inner::Restore2(is.read_message()?));
                },
                34 => {
                    self.inner = ::std::option::Option::Some(request4::Inner::Remove(is.read_message()?));
                },
                42 => {
                    self.inner = ::std::option::Option::Some(request4::Inner::Query(is.read_message()?));
                },
                50 => {
                    self.inner = ::std::option::Option::Some(request4::Inner::RotateStart(is.read_message()?));
                },
                58 => {
                    self.inner = ::std::option::Option::Some(request4::Inner::RotateCommit(is.read_message()?));
                },
                66 => {
                    self.inner = ::std::option::Option::Some(request4::Inner::RotateRollback(is.read_message()?));
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.inner {
            match v {
                &request4::Inner::Create(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &request4::Inner::Restore1(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &request4::Inner::Restore2(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &request4::Inner::Remove(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &request4::Inner::Query(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &request4::Inner::RotateStart(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &request4::Inner::RotateCommit(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &request4::Inner::RotateRollback(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let ::std::option::Option::Some(ref v) = self.inner {
            match v {
                &request4::Inner::Create(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                },
                &request4::Inner::Restore1(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
                &request4::Inner::Restore2(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &request4::Inner::Remove(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &request4::Inner::Query(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &request4::Inner::RotateStart(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &request4::Inner::RotateCommit(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
                &request4::Inner::RotateRollback(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
                },
            };
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Request4 {
        static instance: Request4 = Request4 {
            inner: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `Request4`
pub mod request4 {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    // @@protoc_insertion_point(oneof:svrb.client.Request4.inner)
    pub enum Inner {
        // @@protoc_insertion_point(oneof_field:svrb.client.Request4.create)
        Create(Create),
        // @@protoc_insertion_point(oneof_field:svrb.client.Request4.restore1)
        Restore1(Restore1),
        // @@protoc_insertion_point(oneof_field:svrb.client.Request4.restore2)
        Restore2(Restore2),
        // @@protoc_insertion_point(oneof_field:svrb.client.Request4.remove)
        Remove(Remove),
        // @@protoc_insertion_point(oneof_field:svrb.client.Request4.query)
        Query(Query),
        // @@protoc_insertion_point(oneof_field:svrb.client.Request4.rotate_start)
        RotateStart(RotateStart),
        // @@protoc_insertion_point(oneof_field:svrb.client.Request4.rotate_commit)
        RotateCommit(RotateCommit),
        // @@protoc_insertion_point(oneof_field:svrb.client.Request4.rotate_rollback)
        RotateRollback(RotateRollback),
    }

    impl ::protobuf::Oneof for Inner {
    }

    impl Inner {
    }
    // @@protoc_insertion_point(message:svrb.client.Request4.Create)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Create {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Request4.Create.max_tries)
        pub max_tries: u32,
        // @@protoc_insertion_point(field:svrb.client.Request4.Create.oprf_secretshare)
        pub oprf_secretshare: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:svrb.client.Request4.Create.auth_commitment)
        pub auth_commitment: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:svrb.client.Request4.Create.encryption_secretshare)
        pub encryption_secretshare: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:svrb.client.Request4.Create.zero_secretshare)
        pub zero_secretshare: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:svrb.client.Request4.Create.version)
        pub version: u32,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Request4.Create.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for Create {
        const NAME: &'static str = "Create";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.max_tries = is.read_uint32()?;
                    },
                    18 => {
                        self.oprf_secretshare = is.read_bytes()?;
                    },
                    26 => {
                        self.auth_commitment = is.read_bytes()?;
                    },
                    34 => {
                        self.encryption_secretshare = is.read_bytes()?;
                    },
                    42 => {
                        self.zero_secretshare = is.read_bytes()?;
                    },
                    53 => {
                        self.version = is.read_fixed32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.max_tries != 0 {
                my_size += ::protobuf::rt::uint32_size(1, self.max_tries);
            }
            if !self.oprf_secretshare.is_empty() {
                my_size += ::protobuf::rt::bytes_size(2, &self.oprf_secretshare);
            }
            if !self.auth_commitment.is_empty() {
                my_size += ::protobuf::rt::bytes_size(3, &self.auth_commitment);
            }
            if !self.encryption_secretshare.is_empty() {
                my_size += ::protobuf::rt::bytes_size(4, &self.encryption_secretshare);
            }
            if !self.zero_secretshare.is_empty() {
                my_size += ::protobuf::rt::bytes_size(5, &self.zero_secretshare);
            }
            if self.version != 0 {
                my_size += 1 + 4;
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.max_tries != 0 {
                os.write_uint32(1, self.max_tries)?;
            }
            if !self.oprf_secretshare.is_empty() {
                os.write_bytes(2, &self.oprf_secretshare)?;
            }
            if !self.auth_commitment.is_empty() {
                os.write_bytes(3, &self.auth_commitment)?;
            }
            if !self.encryption_secretshare.is_empty() {
                os.write_bytes(4, &self.encryption_secretshare)?;
            }
            if !self.zero_secretshare.is_empty() {
                os.write_bytes(5, &self.zero_secretshare)?;
            }
            if self.version != 0 {
                os.write_fixed32(6, self.version)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.max_tries = 0;
            self.oprf_secretshare.clear();
            self.auth_commitment.clear();
            self.encryption_secretshare.clear();
            self.zero_secretshare.clear();
            self.version = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Create {
            static instance: Create = Create {
                max_tries: 0,
                oprf_secretshare: ::std::vec::Vec::new(),
                auth_commitment: ::std::vec::Vec::new(),
                encryption_secretshare: ::std::vec::Vec::new(),
                zero_secretshare: ::std::vec::Vec::new(),
                version: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Request4.Restore1)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Restore1 {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Request4.Restore1.blinded)
        pub blinded: ::std::vec::Vec<u8>,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Request4.Restore1.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for Restore1 {
        const NAME: &'static str = "Restore1";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.blinded = is.read_bytes()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if !self.blinded.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.blinded);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if !self.blinded.is_empty() {
                os.write_bytes(1, &self.blinded)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.blinded.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Restore1 {
            static instance: Restore1 = Restore1 {
                blinded: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Request4.Restore2)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Restore2 {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Request4.Restore2.auth_point)
        pub auth_point: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:svrb.client.Request4.Restore2.auth_scalar)
        pub auth_scalar: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:svrb.client.Request4.Restore2.version)
        pub version: u32,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Request4.Restore2.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for Restore2 {
        const NAME: &'static str = "Restore2";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.auth_point = is.read_bytes()?;
                    },
                    18 => {
                        self.auth_scalar = is.read_bytes()?;
                    },
                    29 => {
                        self.version = is.read_fixed32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if !self.auth_point.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.auth_point);
            }
            if !self.auth_scalar.is_empty() {
                my_size += ::protobuf::rt::bytes_size(2, &self.auth_scalar);
            }
            if self.version != 0 {
                my_size += 1 + 4;
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if !self.auth_point.is_empty() {
                os.write_bytes(1, &self.auth_point)?;
            }
            if !self.auth_scalar.is_empty() {
                os.write_bytes(2, &self.auth_scalar)?;
            }
            if self.version != 0 {
                os.write_fixed32(3, self.version)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.auth_point.clear();
            self.auth_scalar.clear();
            self.version = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Restore2 {
            static instance: Restore2 = Restore2 {
                auth_point: ::std::vec::Vec::new(),
                auth_scalar: ::std::vec::Vec::new(),
                version: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Request4.Remove)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Remove {
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Request4.Remove.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for Remove {
        const NAME: &'static str = "Remove";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Remove {
            static instance: Remove = Remove {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Request4.Query)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Query {
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Request4.Query.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for Query {
        const NAME: &'static str = "Query";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Query {
            static instance: Query = Query {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Request4.RotateStart)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct RotateStart {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Request4.RotateStart.version)
        pub version: u32,
        // @@protoc_insertion_point(field:svrb.client.Request4.RotateStart.oprf_secretshare_delta)
        pub oprf_secretshare_delta: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:svrb.client.Request4.RotateStart.encryption_secretshare_delta)
        pub encryption_secretshare_delta: ::std::vec::Vec<u8>,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Request4.RotateStart.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for RotateStart {
        const NAME: &'static str = "RotateStart";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.version = is.read_fixed32()?;
                    },
                    18 => {
                        self.oprf_secretshare_delta = is.read_bytes()?;
                    },
                    26 => {
                        self.encryption_secretshare_delta = is.read_bytes()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.version != 0 {
                my_size += 1 + 4;
            }
            if !self.oprf_secretshare_delta.is_empty() {
                my_size += ::protobuf::rt::bytes_size(2, &self.oprf_secretshare_delta);
            }
            if !self.encryption_secretshare_delta.is_empty() {
                my_size += ::protobuf::rt::bytes_size(3, &self.encryption_secretshare_delta);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.version != 0 {
                os.write_fixed32(1, self.version)?;
            }
            if !self.oprf_secretshare_delta.is_empty() {
                os.write_bytes(2, &self.oprf_secretshare_delta)?;
            }
            if !self.encryption_secretshare_delta.is_empty() {
                os.write_bytes(3, &self.encryption_secretshare_delta)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.version = 0;
            self.oprf_secretshare_delta.clear();
            self.encryption_secretshare_delta.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static RotateStart {
            static instance: RotateStart = RotateStart {
                version: 0,
                oprf_secretshare_delta: ::std::vec::Vec::new(),
                encryption_secretshare_delta: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Request4.RotateCommit)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct RotateCommit {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Request4.RotateCommit.version)
        pub version: u32,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Request4.RotateCommit.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for RotateCommit {
        const NAME: &'static str = "RotateCommit";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.version = is.read_fixed32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.version != 0 {
                my_size += 1 + 4;
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.version != 0 {
                os.write_fixed32(1, self.version)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.version = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static RotateCommit {
            static instance: RotateCommit = RotateCommit {
                version: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Request4.RotateRollback)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct RotateRollback {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Request4.RotateRollback.version)
        pub version: u32,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Request4.RotateRollback.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for RotateRollback {
        const NAME: &'static str = "RotateRollback";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    13 => {
                        self.version = is.read_fixed32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.version != 0 {
                my_size += 1 + 4;
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.version != 0 {
                os.write_fixed32(1, self.version)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.version = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static RotateRollback {
            static instance: RotateRollback = RotateRollback {
                version: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

// @@protoc_insertion_point(message:svrb.client.Response4)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Response4 {
    // message oneof groups
    pub inner: ::std::option::Option<response4::Inner>,
    // special fields
    // @@protoc_insertion_point(special_field:svrb.client.Response4.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .svrb.client.Response4.Create create = 1;

    pub fn create(&self) -> &response4::Create {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Create(ref v)) => v,
            _ => <response4::Create as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_create(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_create(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Create(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_create(&mut self, v: response4::Create) {
        self.inner = ::std::option::Option::Some(response4::Inner::Create(v))
    }

    // Mutable pointer to the field.
    pub fn mut_create(&mut self) -> &mut response4::Create {
        if let ::std::option::Option::Some(response4::Inner::Create(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(response4::Inner::Create(response4::Create::new()));
        }
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Create(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_create(&mut self) -> response4::Create {
        if self.has_create() {
            match self.inner.take() {
                ::std::option::Option::Some(response4::Inner::Create(v)) => v,
                _ => panic!(),
            }
        } else {
            response4::Create::new()
        }
    }

    // .svrb.client.Response4.Restore1 restore1 = 2;

    pub fn restore1(&self) -> &response4::Restore1 {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Restore1(ref v)) => v,
            _ => <response4::Restore1 as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_restore1(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_restore1(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Restore1(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_restore1(&mut self, v: response4::Restore1) {
        self.inner = ::std::option::Option::Some(response4::Inner::Restore1(v))
    }

    // Mutable pointer to the field.
    pub fn mut_restore1(&mut self) -> &mut response4::Restore1 {
        if let ::std::option::Option::Some(response4::Inner::Restore1(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(response4::Inner::Restore1(response4::Restore1::new()));
        }
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Restore1(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_restore1(&mut self) -> response4::Restore1 {
        if self.has_restore1() {
            match self.inner.take() {
                ::std::option::Option::Some(response4::Inner::Restore1(v)) => v,
                _ => panic!(),
            }
        } else {
            response4::Restore1::new()
        }
    }

    // .svrb.client.Response4.Restore2 restore2 = 3;

    pub fn restore2(&self) -> &response4::Restore2 {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Restore2(ref v)) => v,
            _ => <response4::Restore2 as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_restore2(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_restore2(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Restore2(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_restore2(&mut self, v: response4::Restore2) {
        self.inner = ::std::option::Option::Some(response4::Inner::Restore2(v))
    }

    // Mutable pointer to the field.
    pub fn mut_restore2(&mut self) -> &mut response4::Restore2 {
        if let ::std::option::Option::Some(response4::Inner::Restore2(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(response4::Inner::Restore2(response4::Restore2::new()));
        }
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Restore2(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_restore2(&mut self) -> response4::Restore2 {
        if self.has_restore2() {
            match self.inner.take() {
                ::std::option::Option::Some(response4::Inner::Restore2(v)) => v,
                _ => panic!(),
            }
        } else {
            response4::Restore2::new()
        }
    }

    // .svrb.client.Response4.Remove remove = 4;

    pub fn remove(&self) -> &response4::Remove {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Remove(ref v)) => v,
            _ => <response4::Remove as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_remove(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_remove(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Remove(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_remove(&mut self, v: response4::Remove) {
        self.inner = ::std::option::Option::Some(response4::Inner::Remove(v))
    }

    // Mutable pointer to the field.
    pub fn mut_remove(&mut self) -> &mut response4::Remove {
        if let ::std::option::Option::Some(response4::Inner::Remove(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(response4::Inner::Remove(response4::Remove::new()));
        }
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Remove(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_remove(&mut self) -> response4::Remove {
        if self.has_remove() {
            match self.inner.take() {
                ::std::option::Option::Some(response4::Inner::Remove(v)) => v,
                _ => panic!(),
            }
        } else {
            response4::Remove::new()
        }
    }

    // .svrb.client.Response4.Query query = 5;

    pub fn query(&self) -> &response4::Query {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Query(ref v)) => v,
            _ => <response4::Query as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_query(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_query(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Query(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_query(&mut self, v: response4::Query) {
        self.inner = ::std::option::Option::Some(response4::Inner::Query(v))
    }

    // Mutable pointer to the field.
    pub fn mut_query(&mut self) -> &mut response4::Query {
        if let ::std::option::Option::Some(response4::Inner::Query(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(response4::Inner::Query(response4::Query::new()));
        }
        match self.inner {
            ::std::option::Option::Some(response4::Inner::Query(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_query(&mut self) -> response4::Query {
        if self.has_query() {
            match self.inner.take() {
                ::std::option::Option::Some(response4::Inner::Query(v)) => v,
                _ => panic!(),
            }
        } else {
            response4::Query::new()
        }
    }

    // .svrb.client.Response4.RotateStart rotate_start = 6;

    pub fn rotate_start(&self) -> &response4::RotateStart {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::RotateStart(ref v)) => v,
            _ => <response4::RotateStart as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_rotate_start(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_rotate_start(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::RotateStart(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_rotate_start(&mut self, v: response4::RotateStart) {
        self.inner = ::std::option::Option::Some(response4::Inner::RotateStart(v))
    }

    // Mutable pointer to the field.
    pub fn mut_rotate_start(&mut self) -> &mut response4::RotateStart {
        if let ::std::option::Option::Some(response4::Inner::RotateStart(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(response4::Inner::RotateStart(response4::RotateStart::new()));
        }
        match self.inner {
            ::std::option::Option::Some(response4::Inner::RotateStart(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_rotate_start(&mut self) -> response4::RotateStart {
        if self.has_rotate_start() {
            match self.inner.take() {
                ::std::option::Option::Some(response4::Inner::RotateStart(v)) => v,
                _ => panic!(),
            }
        } else {
            response4::RotateStart::new()
        }
    }

    // .svrb.client.Response4.RotateCommit rotate_commit = 7;

    pub fn rotate_commit(&self) -> &response4::RotateCommit {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::RotateCommit(ref v)) => v,
            _ => <response4::RotateCommit as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_rotate_commit(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_rotate_commit(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::RotateCommit(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_rotate_commit(&mut self, v: response4::RotateCommit) {
        self.inner = ::std::option::Option::Some(response4::Inner::RotateCommit(v))
    }

    // Mutable pointer to the field.
    pub fn mut_rotate_commit(&mut self) -> &mut response4::RotateCommit {
        if let ::std::option::Option::Some(response4::Inner::RotateCommit(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(response4::Inner::RotateCommit(response4::RotateCommit::new()));
        }
        match self.inner {
            ::std::option::Option::Some(response4::Inner::RotateCommit(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_rotate_commit(&mut self) -> response4::RotateCommit {
        if self.has_rotate_commit() {
            match self.inner.take() {
                ::std::option::Option::Some(response4::Inner::RotateCommit(v)) => v,
                _ => panic!(),
            }
        } else {
            response4::RotateCommit::new()
        }
    }

    // .svrb.client.Response4.RotateRollback rotate_rollback = 8;

    pub fn rotate_rollback(&self) -> &response4::RotateRollback {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::RotateRollback(ref v)) => v,
            _ => <response4::RotateRollback as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_rotate_rollback(&mut self) {
        self.inner = ::std::option::Option::None;
    }

    pub fn has_rotate_rollback(&self) -> bool {
        match self.inner {
            ::std::option::Option::Some(response4::Inner::RotateRollback(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_rotate_rollback(&mut self, v: response4::RotateRollback) {
        self.inner = ::std::option::Option::Some(response4::Inner::RotateRollback(v))
    }

    // Mutable pointer to the field.
    pub fn mut_rotate_rollback(&mut self) -> &mut response4::RotateRollback {
        if let ::std::option::Option::Some(response4::Inner::RotateRollback(_)) = self.inner {
        } else {
            self.inner = ::std::option::Option::Some(response4::Inner::RotateRollback(response4::RotateRollback::new()));
        }
        match self.inner {
            ::std::option::Option::Some(response4::Inner::RotateRollback(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_rotate_rollback(&mut self) -> response4::RotateRollback {
        if self.has_rotate_rollback() {
            match self.inner.take() {
                ::std::option::Option::Some(response4::Inner::RotateRollback(v)) => v,
                _ => panic!(),
            }
        } else {
            response4::RotateRollback::new()
        }
    }
}

impl ::protobuf::Message for Response4 {
    const NAME: &'static str = "Response4";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.inner = ::std::option::Option::Some(response4::Inner::Create(is.read_message()?));
                },
                18 => {
                    self.inner = ::std::option::Option::Some(response4::Inner::Restore1(is.read_message()?));
                },
                26 => {
                    self.inner = ::std::option::Option::Some(response4::Inner::Restore2(is.read_message()?));
                },
                34 => {
                    self.inner = ::std::option::Option::Some(response4::Inner::Remove(is.read_message()?));
                },
                42 => {
                    self.inner = ::std::option::Option::Some(response4::Inner::Query(is.read_message()?));
                },
                50 => {
                    self.inner = ::std::option::Option::Some(response4::Inner::RotateStart(is.read_message()?));
                },
                58 => {
                    self.inner = ::std::option::Option::Some(response4::Inner::RotateCommit(is.read_message()?));
                },
                66 => {
                    self.inner = ::std::option::Option::Some(response4::Inner::RotateRollback(is.read_message()?));
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.inner {
            match v {
                &response4::Inner::Create(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &response4::Inner::Restore1(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &response4::Inner::Restore2(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &response4::Inner::Remove(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &response4::Inner::Query(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &response4::Inner::RotateStart(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &response4::Inner::RotateCommit(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &response4::Inner::RotateRollback(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let ::std::option::Option::Some(ref v) = self.inner {
            match v {
                &response4::Inner::Create(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                },
                &response4::Inner::Restore1(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
                &response4::Inner::Restore2(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &response4::Inner::Remove(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &response4::Inner::Query(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &response4::Inner::RotateStart(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &response4::Inner::RotateCommit(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
                &response4::Inner::RotateRollback(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
                },
            };
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.inner = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Response4 {
        static instance: Response4 = Response4 {
            inner: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `Response4`
pub mod response4 {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    // @@protoc_insertion_point(oneof:svrb.client.Response4.inner)
    pub enum Inner {
        // @@protoc_insertion_point(oneof_field:svrb.client.Response4.create)
        Create(Create),
        // @@protoc_insertion_point(oneof_field:svrb.client.Response4.restore1)
        Restore1(Restore1),
        // @@protoc_insertion_point(oneof_field:svrb.client.Response4.restore2)
        Restore2(Restore2),
        // @@protoc_insertion_point(oneof_field:svrb.client.Response4.remove)
        Remove(Remove),
        // @@protoc_insertion_point(oneof_field:svrb.client.Response4.query)
        Query(Query),
        // @@protoc_insertion_point(oneof_field:svrb.client.Response4.rotate_start)
        RotateStart(RotateStart),
        // @@protoc_insertion_point(oneof_field:svrb.client.Response4.rotate_commit)
        RotateCommit(RotateCommit),
        // @@protoc_insertion_point(oneof_field:svrb.client.Response4.rotate_rollback)
        RotateRollback(RotateRollback),
    }

    impl ::protobuf::Oneof for Inner {
    }

    impl Inner {
    }
    // @@protoc_insertion_point(message:svrb.client.Response4.Create)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Create {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Response4.Create.status)
        pub status: ::protobuf::EnumOrUnknown<Status>,
        // @@protoc_insertion_point(field:svrb.client.Response4.Create.tries_remaining)
        pub tries_remaining: u32,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Response4.Create.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for Create {
        const NAME: &'static str = "Create";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.status = is.read_enum_or_unknown()?;
                    },
                    16 => {
                        self.tries_remaining = is.read_uint32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                my_size += ::protobuf::rt::int32_size(1, self.status.value());
            }
            if self.tries_remaining != 0 {
                my_size += ::protobuf::rt::uint32_size(2, self.tries_remaining);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.status))?;
            }
            if self.tries_remaining != 0 {
                os.write_uint32(2, self.tries_remaining)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.status = ::protobuf::EnumOrUnknown::new(Status::UNSET);
            self.tries_remaining = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Create {
            static instance: Create = Create {
                status: ::protobuf::EnumOrUnknown::from_i32(0),
                tries_remaining: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Response4.Restore1)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Restore1 {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Response4.Restore1.status)
        pub status: ::protobuf::EnumOrUnknown<Status>,
        // @@protoc_insertion_point(field:svrb.client.Response4.Restore1.auth)
        pub auth: ::std::vec::Vec<restore1::Auth>,
        // @@protoc_insertion_point(field:svrb.client.Response4.Restore1.tries_remaining)
        pub tries_remaining: u32,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Response4.Restore1.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for Restore1 {
        const NAME: &'static str = "Restore1";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.status = is.read_enum_or_unknown()?;
                    },
                    18 => {
                        self.auth.push(is.read_message()?);
                    },
                    24 => {
                        self.tries_remaining = is.read_uint32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                my_size += ::protobuf::rt::int32_size(1, self.status.value());
            }
            for value in &self.auth {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            if self.tries_remaining != 0 {
                my_size += ::protobuf::rt::uint32_size(3, self.tries_remaining);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.status))?;
            }
            for v in &self.auth {
                ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
            };
            if self.tries_remaining != 0 {
                os.write_uint32(3, self.tries_remaining)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.status = ::protobuf::EnumOrUnknown::new(Status::UNSET);
            self.auth.clear();
            self.tries_remaining = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Restore1 {
            static instance: Restore1 = Restore1 {
                status: ::protobuf::EnumOrUnknown::from_i32(0),
                auth: ::std::vec::Vec::new(),
                tries_remaining: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `Restore1`
    pub mod restore1 {
        // @@protoc_insertion_point(message:svrb.client.Response4.Restore1.Auth)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct Auth {
            // message fields
            // @@protoc_insertion_point(field:svrb.client.Response4.Restore1.Auth.element)
            pub element: ::std::vec::Vec<u8>,
            // @@protoc_insertion_point(field:svrb.client.Response4.Restore1.Auth.version)
            pub version: u32,
            // special fields
            // @@protoc_insertion_point(special_field:svrb.client.Response4.Restore1.Auth.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

        impl ::protobuf::Message for Auth {
            const NAME: &'static str = "Auth";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        10 => {
                            self.element = is.read_bytes()?;
                        },
                        21 => {
                            self.version = is.read_fixed32()?;
                        },
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

            // Compute sizes of nested messages
            #[allow(unused_variables)]
            fn compute_size(&self) -> u64 {
                let mut my_size = 0;
                if !self.element.is_empty() {
                    my_size += ::protobuf::rt::bytes_size(1, &self.element);
                }
                if self.version != 0 {
                    my_size += 1 + 4;
                }
                my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                self.special_fields.cached_size().set(my_size as u32);
                my_size
            }

            fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                if !self.element.is_empty() {
                    os.write_bytes(1, &self.element)?;
                }
                if self.version != 0 {
                    os.write_fixed32(2, self.version)?;
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.element.clear();
                self.version = 0;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static Auth {
                static instance: Auth = Auth {
                    element: ::std::vec::Vec::new(),
                    version: 0,
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Response4.Restore2)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Restore2 {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Response4.Restore2.status)
        pub status: ::protobuf::EnumOrUnknown<Status>,
        // @@protoc_insertion_point(field:svrb.client.Response4.Restore2.encryption_secretshare)
        pub encryption_secretshare: ::std::vec::Vec<u8>,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Response4.Restore2.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for Restore2 {
        const NAME: &'static str = "Restore2";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.status = is.read_enum_or_unknown()?;
                    },
                    18 => {
                        self.encryption_secretshare = is.read_bytes()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                my_size += ::protobuf::rt::int32_size(1, self.status.value());
            }
            if !self.encryption_secretshare.is_empty() {
                my_size += ::protobuf::rt::bytes_size(2, &self.encryption_secretshare);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.status))?;
            }
            if !self.encryption_secretshare.is_empty() {
                os.write_bytes(2, &self.encryption_secretshare)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.status = ::protobuf::EnumOrUnknown::new(Status::UNSET);
            self.encryption_secretshare.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Restore2 {
            static instance: Restore2 = Restore2 {
                status: ::protobuf::EnumOrUnknown::from_i32(0),
                encryption_secretshare: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Response4.Remove)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Remove {
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Response4.Remove.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for Remove {
        const NAME: &'static str = "Remove";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Remove {
            static instance: Remove = Remove {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Response4.Query)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Query {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Response4.Query.status)
        pub status: ::protobuf::EnumOrUnknown<Status>,
        // @@protoc_insertion_point(field:svrb.client.Response4.Query.tries_remaining)
        pub tries_remaining: u32,
        // @@protoc_insertion_point(field:svrb.client.Response4.Query.version)
        pub version: u32,
        // @@protoc_insertion_point(field:svrb.client.Response4.Query.new_version)
        pub new_version: u32,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Response4.Query.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for Query {
        const NAME: &'static str = "Query";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.status = is.read_enum_or_unknown()?;
                    },
                    16 => {
                        self.tries_remaining = is.read_uint32()?;
                    },
                    29 => {
                        self.version = is.read_fixed32()?;
                    },
                    37 => {
                        self.new_version = is.read_fixed32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                my_size += ::protobuf::rt::int32_size(1, self.status.value());
            }
            if self.tries_remaining != 0 {
                my_size += ::protobuf::rt::uint32_size(2, self.tries_remaining);
            }
            if self.version != 0 {
                my_size += 1 + 4;
            }
            if self.new_version != 0 {
                my_size += 1 + 4;
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.status))?;
            }
            if self.tries_remaining != 0 {
                os.write_uint32(2, self.tries_remaining)?;
            }
            if self.version != 0 {
                os.write_fixed32(3, self.version)?;
            }
            if self.new_version != 0 {
                os.write_fixed32(4, self.new_version)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.status = ::protobuf::EnumOrUnknown::new(Status::UNSET);
            self.tries_remaining = 0;
            self.version = 0;
            self.new_version = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Query {
            static instance: Query = Query {
                status: ::protobuf::EnumOrUnknown::from_i32(0),
                tries_remaining: 0,
                version: 0,
                new_version: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Response4.RotateStart)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct RotateStart {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Response4.RotateStart.status)
        pub status: ::protobuf::EnumOrUnknown<Status>,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Response4.RotateStart.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for RotateStart {
        const NAME: &'static str = "RotateStart";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.status = is.read_enum_or_unknown()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                my_size += ::protobuf::rt::int32_size(1, self.status.value());
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.status))?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.status = ::protobuf::EnumOrUnknown::new(Status::UNSET);
            self.special_fields.clear();
        }

        fn default_instance() -> &'static RotateStart {
            static instance: RotateStart = RotateStart {
                status: ::protobuf::EnumOrUnknown::from_i32(0),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Response4.RotateCommit)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct RotateCommit {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Response4.RotateCommit.status)
        pub status: ::protobuf::EnumOrUnknown<Status>,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Response4.RotateCommit.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for RotateCommit {
        const NAME: &'static str = "RotateCommit";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.status = is.read_enum_or_unknown()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                my_size += ::protobuf::rt::int32_size(1, self.status.value());
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.status))?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.status = ::protobuf::EnumOrUnknown::new(Status::UNSET);
            self.special_fields.clear();
        }

        fn default_instance() -> &'static RotateCommit {
            static instance: RotateCommit = RotateCommit {
                status: ::protobuf::EnumOrUnknown::from_i32(0),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    // @@protoc_insertion_point(message:svrb.client.Response4.RotateRollback)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct RotateRollback {
        // message fields
        // @@protoc_insertion_point(field:svrb.client.Response4.RotateRollback.status)
        pub status: ::protobuf::EnumOrUnknown<Status>,
        // special fields
        // @@protoc_insertion_point(special_field:svrb.client.Response4.RotateRollback.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

    impl ::protobuf::Message for RotateRollback {
        const NAME: &'static str = "RotateRollback";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.status = is.read_enum_or_unknown()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                my_size += ::protobuf::rt::int32_size(1, self.status.value());
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.status != ::protobuf::EnumOrUnknown::new(Status::UNSET) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.status))?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.status = ::protobuf::EnumOrUnknown::new(Status::UNSET);
            self.special_fields.clear();
        }

        fn default_instance() -> &'static RotateRollback {
            static instance: RotateRollback = RotateRollback {
                status: ::protobuf::EnumOrUnknown::from_i32(0),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:svrb.client.Response4.Status)
    pub enum Status {
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.UNSET)
        UNSET = 0,
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.OK)
        OK = 1,
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.INVALID_REQUEST)
        INVALID_REQUEST = 2,
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.MISSING)
        MISSING = 3,
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.ERROR)
        ERROR = 4,
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.RESTORE1_MISSING)
        RESTORE1_MISSING = 5,
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.VERSION_MISMATCH)
        VERSION_MISMATCH = 6,
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.NOT_ROTATING)
        NOT_ROTATING = 7,
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.ALREADY_ROTATING)
        ALREADY_ROTATING = 8,
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.MERKLE_FAILURE)
        MERKLE_FAILURE = 9,
        // @@protoc_insertion_point(enum_value:svrb.client.Response4.Status.DUPLICATE_VERSION)
        DUPLICATE_VERSION = 10,
    }

    impl ::protobuf::Enum for Status {
        const NAME: &'static str = "Status";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<Status> {
            match value {
                0 => ::std::option::Option::Some(Status::UNSET),
                1 => ::std::option::Option::Some(Status::OK),
                2 => ::std::option::Option::Some(Status::INVALID_REQUEST),
                3 => ::std::option::Option::Some(Status::MISSING),
                4 => ::std::option::Option::Some(Status::ERROR),
                5 => ::std::option::Option::Some(Status::RESTORE1_MISSING),
                6 => ::std::option::Option::Some(Status::VERSION_MISMATCH),
                7 => ::std::option::Option::Some(Status::NOT_ROTATING),
                8 => ::std::option::Option::Some(Status::ALREADY_ROTATING),
                9 => ::std::option::Option::Some(Status::MERKLE_FAILURE),
                10 => ::std::option::Option::Some(Status::DUPLICATE_VERSION),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Status> {
            match str {
                "UNSET" => ::std::option::Option::Some(Status::UNSET),
                "OK" => ::std::option::Option::Some(Status::OK),
                "INVALID_REQUEST" => ::std::option::Option::Some(Status::INVALID_REQUEST),
                "MISSING" => ::std::option::Option::Some(Status::MISSING),
                "ERROR" => ::std::option::Option::Some(Status::ERROR),
                "RESTORE1_MISSING" => ::std::option::Option::Some(Status::RESTORE1_MISSING),
                "VERSION_MISMATCH" => ::std::option::Option::Some(Status::VERSION_MISMATCH),
                "NOT_ROTATING" => ::std::option::Option::Some(Status::NOT_ROTATING),
                "ALREADY_ROTATING" => ::std::option::Option::Some(Status::ALREADY_ROTATING),
                "MERKLE_FAILURE" => ::std::option::Option::Some(Status::MERKLE_FAILURE),
                "DUPLICATE_VERSION" => ::std::option::Option::Some(Status::DUPLICATE_VERSION),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Status] = &[
            Status::UNSET,
            Status::OK,
            Status::INVALID_REQUEST,
            Status::MISSING,
            Status::ERROR,
            Status::RESTORE1_MISSING,
            Status::VERSION_MISMATCH,
            Status::NOT_ROTATING,
            Status::ALREADY_ROTATING,
            Status::MERKLE_FAILURE,
            Status::DUPLICATE_VERSION,
        ];
    }

    impl ::std::default::Default for Status {
        fn default() -> Self {
            Status::UNSET
        }
    }

}
