// This file is generated by rust-protobuf 3.7.2. Do not edit
// .proto file is parsed by protoc 35.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/backup.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;

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.BackupInfo)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct BackupInfo {
    // message fields
    #[field_name("version")]
    // @@protoc_insertion_point(field:signal.backup.BackupInfo.version)
    pub version: u64,
    #[field_name("backupTimeMs")]
    // @@protoc_insertion_point(field:signal.backup.BackupInfo.backupTimeMs)
    pub backupTimeMs: u64,
    #[field_name("mediaRootBackupKey")]
    // @@protoc_insertion_point(field:signal.backup.BackupInfo.mediaRootBackupKey)
    pub mediaRootBackupKey: ::std::vec::Vec<u8>,
    #[field_name("currentAppVersion")]
    // @@protoc_insertion_point(field:signal.backup.BackupInfo.currentAppVersion)
    pub currentAppVersion: ::std::string::String,
    #[field_name("firstAppVersion")]
    // @@protoc_insertion_point(field:signal.backup.BackupInfo.firstAppVersion)
    pub firstAppVersion: ::std::string::String,
    #[field_name("debugInfo")]
    // @@protoc_insertion_point(field:signal.backup.BackupInfo.debugInfo)
    pub debugInfo: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.BackupInfo.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.version = is.read_uint64()?;
                },
                16 => {
                    self.backupTimeMs = is.read_uint64()?;
                },
                26 => {
                    self.mediaRootBackupKey = is.read_bytes()?;
                },
                34 => {
                    self.currentAppVersion = is.read_string()?;
                },
                42 => {
                    self.firstAppVersion = is.read_string()?;
                },
                50 => {
                    self.debugInfo = 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 += ::protobuf::rt::uint64_size(1, self.version);
        }
        if self.backupTimeMs != 0 {
            my_size += ::protobuf::rt::uint64_size(2, self.backupTimeMs);
        }
        if !self.mediaRootBackupKey.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.mediaRootBackupKey);
        }
        if !self.currentAppVersion.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.currentAppVersion);
        }
        if !self.firstAppVersion.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.firstAppVersion);
        }
        if !self.debugInfo.is_empty() {
            my_size += ::protobuf::rt::bytes_size(6, &self.debugInfo);
        }
        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_uint64(1, self.version)?;
        }
        if self.backupTimeMs != 0 {
            os.write_uint64(2, self.backupTimeMs)?;
        }
        if !self.mediaRootBackupKey.is_empty() {
            os.write_bytes(3, &self.mediaRootBackupKey)?;
        }
        if !self.currentAppVersion.is_empty() {
            os.write_string(4, &self.currentAppVersion)?;
        }
        if !self.firstAppVersion.is_empty() {
            os.write_string(5, &self.firstAppVersion)?;
        }
        if !self.debugInfo.is_empty() {
            os.write_bytes(6, &self.debugInfo)?;
        }
        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() -> BackupInfo {
        BackupInfo::new()
    }

    fn clear(&mut self) {
        self.version = 0;
        self.backupTimeMs = 0;
        self.mediaRootBackupKey.clear();
        self.currentAppVersion.clear();
        self.firstAppVersion.clear();
        self.debugInfo.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static BackupInfo {
        static instance: BackupInfo = BackupInfo {
            version: 0,
            backupTimeMs: 0,
            mediaRootBackupKey: ::std::vec::Vec::new(),
            currentAppVersion: ::std::string::String::new(),
            firstAppVersion: ::std::string::String::new(),
            debugInfo: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Frame)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Frame {
    // message oneof groups
    pub item: ::std::option::Option<frame::Item>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Frame.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .signal.backup.AccountData account = 1;

    pub fn account(&self) -> &AccountData {
        match self.item {
            ::std::option::Option::Some(frame::Item::Account(ref v)) => v,
            _ => <AccountData as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_account(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(frame::Item::Account(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_account(&mut self, v: AccountData) {
        self.item = ::std::option::Option::Some(frame::Item::Account(v))
    }

    // Mutable pointer to the field.
    pub fn mut_account(&mut self) -> &mut AccountData {
        if let ::std::option::Option::Some(frame::Item::Account(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(frame::Item::Account(AccountData::new()));
        }
        match self.item {
            ::std::option::Option::Some(frame::Item::Account(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_account(&mut self) -> AccountData {
        if self.has_account() {
            match self.item.take() {
                ::std::option::Option::Some(frame::Item::Account(v)) => v,
                _ => panic!(),
            }
        } else {
            AccountData::new()
        }
    }

    // .signal.backup.Recipient recipient = 2;

    pub fn recipient(&self) -> &Recipient {
        match self.item {
            ::std::option::Option::Some(frame::Item::Recipient(ref v)) => v,
            _ => <Recipient as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_recipient(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(frame::Item::Recipient(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_recipient(&mut self, v: Recipient) {
        self.item = ::std::option::Option::Some(frame::Item::Recipient(v))
    }

    // Mutable pointer to the field.
    pub fn mut_recipient(&mut self) -> &mut Recipient {
        if let ::std::option::Option::Some(frame::Item::Recipient(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(frame::Item::Recipient(Recipient::new()));
        }
        match self.item {
            ::std::option::Option::Some(frame::Item::Recipient(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_recipient(&mut self) -> Recipient {
        if self.has_recipient() {
            match self.item.take() {
                ::std::option::Option::Some(frame::Item::Recipient(v)) => v,
                _ => panic!(),
            }
        } else {
            Recipient::new()
        }
    }

    // .signal.backup.Chat chat = 3;

    pub fn chat(&self) -> &Chat {
        match self.item {
            ::std::option::Option::Some(frame::Item::Chat(ref v)) => v,
            _ => <Chat as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_chat(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(frame::Item::Chat(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_chat(&mut self, v: Chat) {
        self.item = ::std::option::Option::Some(frame::Item::Chat(v))
    }

    // Mutable pointer to the field.
    pub fn mut_chat(&mut self) -> &mut Chat {
        if let ::std::option::Option::Some(frame::Item::Chat(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(frame::Item::Chat(Chat::new()));
        }
        match self.item {
            ::std::option::Option::Some(frame::Item::Chat(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_chat(&mut self) -> Chat {
        if self.has_chat() {
            match self.item.take() {
                ::std::option::Option::Some(frame::Item::Chat(v)) => v,
                _ => panic!(),
            }
        } else {
            Chat::new()
        }
    }

    // .signal.backup.ChatItem chatItem = 4;

    pub fn chatItem(&self) -> &ChatItem {
        match self.item {
            ::std::option::Option::Some(frame::Item::ChatItem(ref v)) => v,
            _ => <ChatItem as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_chatItem(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(frame::Item::ChatItem(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_chatItem(&mut self, v: ChatItem) {
        self.item = ::std::option::Option::Some(frame::Item::ChatItem(v))
    }

    // Mutable pointer to the field.
    pub fn mut_chatItem(&mut self) -> &mut ChatItem {
        if let ::std::option::Option::Some(frame::Item::ChatItem(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(frame::Item::ChatItem(ChatItem::new()));
        }
        match self.item {
            ::std::option::Option::Some(frame::Item::ChatItem(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_chatItem(&mut self) -> ChatItem {
        if self.has_chatItem() {
            match self.item.take() {
                ::std::option::Option::Some(frame::Item::ChatItem(v)) => v,
                _ => panic!(),
            }
        } else {
            ChatItem::new()
        }
    }

    // .signal.backup.StickerPack stickerPack = 5;

    pub fn stickerPack(&self) -> &StickerPack {
        match self.item {
            ::std::option::Option::Some(frame::Item::StickerPack(ref v)) => v,
            _ => <StickerPack as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_stickerPack(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(frame::Item::StickerPack(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_stickerPack(&mut self, v: StickerPack) {
        self.item = ::std::option::Option::Some(frame::Item::StickerPack(v))
    }

    // Mutable pointer to the field.
    pub fn mut_stickerPack(&mut self) -> &mut StickerPack {
        if let ::std::option::Option::Some(frame::Item::StickerPack(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(frame::Item::StickerPack(StickerPack::new()));
        }
        match self.item {
            ::std::option::Option::Some(frame::Item::StickerPack(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_stickerPack(&mut self) -> StickerPack {
        if self.has_stickerPack() {
            match self.item.take() {
                ::std::option::Option::Some(frame::Item::StickerPack(v)) => v,
                _ => panic!(),
            }
        } else {
            StickerPack::new()
        }
    }

    // .signal.backup.AdHocCall adHocCall = 6;

    pub fn adHocCall(&self) -> &AdHocCall {
        match self.item {
            ::std::option::Option::Some(frame::Item::AdHocCall(ref v)) => v,
            _ => <AdHocCall as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_adHocCall(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(frame::Item::AdHocCall(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_adHocCall(&mut self, v: AdHocCall) {
        self.item = ::std::option::Option::Some(frame::Item::AdHocCall(v))
    }

    // Mutable pointer to the field.
    pub fn mut_adHocCall(&mut self) -> &mut AdHocCall {
        if let ::std::option::Option::Some(frame::Item::AdHocCall(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(frame::Item::AdHocCall(AdHocCall::new()));
        }
        match self.item {
            ::std::option::Option::Some(frame::Item::AdHocCall(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_adHocCall(&mut self) -> AdHocCall {
        if self.has_adHocCall() {
            match self.item.take() {
                ::std::option::Option::Some(frame::Item::AdHocCall(v)) => v,
                _ => panic!(),
            }
        } else {
            AdHocCall::new()
        }
    }

    // .signal.backup.NotificationProfile notificationProfile = 7;

    pub fn notificationProfile(&self) -> &NotificationProfile {
        match self.item {
            ::std::option::Option::Some(frame::Item::NotificationProfile(ref v)) => v,
            _ => <NotificationProfile as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_notificationProfile(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(frame::Item::NotificationProfile(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_notificationProfile(&mut self, v: NotificationProfile) {
        self.item = ::std::option::Option::Some(frame::Item::NotificationProfile(v))
    }

    // Mutable pointer to the field.
    pub fn mut_notificationProfile(&mut self) -> &mut NotificationProfile {
        if let ::std::option::Option::Some(frame::Item::NotificationProfile(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(frame::Item::NotificationProfile(NotificationProfile::new()));
        }
        match self.item {
            ::std::option::Option::Some(frame::Item::NotificationProfile(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_notificationProfile(&mut self) -> NotificationProfile {
        if self.has_notificationProfile() {
            match self.item.take() {
                ::std::option::Option::Some(frame::Item::NotificationProfile(v)) => v,
                _ => panic!(),
            }
        } else {
            NotificationProfile::new()
        }
    }

    // .signal.backup.ChatFolder chatFolder = 8;

    pub fn chatFolder(&self) -> &ChatFolder {
        match self.item {
            ::std::option::Option::Some(frame::Item::ChatFolder(ref v)) => v,
            _ => <ChatFolder as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_chatFolder(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(frame::Item::ChatFolder(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_chatFolder(&mut self, v: ChatFolder) {
        self.item = ::std::option::Option::Some(frame::Item::ChatFolder(v))
    }

    // Mutable pointer to the field.
    pub fn mut_chatFolder(&mut self) -> &mut ChatFolder {
        if let ::std::option::Option::Some(frame::Item::ChatFolder(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(frame::Item::ChatFolder(ChatFolder::new()));
        }
        match self.item {
            ::std::option::Option::Some(frame::Item::ChatFolder(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_chatFolder(&mut self) -> ChatFolder {
        if self.has_chatFolder() {
            match self.item.take() {
                ::std::option::Option::Some(frame::Item::ChatFolder(v)) => v,
                _ => panic!(),
            }
        } else {
            ChatFolder::new()
        }
    }
}

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

    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.item = ::std::option::Option::Some(frame::Item::Account(is.read_message()?));
                },
                18 => {
                    self.item = ::std::option::Option::Some(frame::Item::Recipient(is.read_message()?));
                },
                26 => {
                    self.item = ::std::option::Option::Some(frame::Item::Chat(is.read_message()?));
                },
                34 => {
                    self.item = ::std::option::Option::Some(frame::Item::ChatItem(is.read_message()?));
                },
                42 => {
                    self.item = ::std::option::Option::Some(frame::Item::StickerPack(is.read_message()?));
                },
                50 => {
                    self.item = ::std::option::Option::Some(frame::Item::AdHocCall(is.read_message()?));
                },
                58 => {
                    self.item = ::std::option::Option::Some(frame::Item::NotificationProfile(is.read_message()?));
                },
                66 => {
                    self.item = ::std::option::Option::Some(frame::Item::ChatFolder(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.item {
            match v {
                &frame::Item::Account(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &frame::Item::Recipient(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &frame::Item::Chat(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &frame::Item::ChatItem(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &frame::Item::StickerPack(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &frame::Item::AdHocCall(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &frame::Item::NotificationProfile(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &frame::Item::ChatFolder(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.item {
            match v {
                &frame::Item::Account(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                },
                &frame::Item::Recipient(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
                &frame::Item::Chat(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &frame::Item::ChatItem(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &frame::Item::StickerPack(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &frame::Item::AdHocCall(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &frame::Item::NotificationProfile(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
                &frame::Item::ChatFolder(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() -> Frame {
        Frame::new()
    }

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

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

/// Nested message and enums of message `Frame`
pub mod frame {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.Frame.item)
    pub enum Item {
        // @@protoc_insertion_point(oneof_field:signal.backup.Frame.account)
        Account(super::AccountData),
        // @@protoc_insertion_point(oneof_field:signal.backup.Frame.recipient)
        Recipient(super::Recipient),
        // @@protoc_insertion_point(oneof_field:signal.backup.Frame.chat)
        Chat(super::Chat),
        // @@protoc_insertion_point(oneof_field:signal.backup.Frame.chatItem)
        ChatItem(super::ChatItem),
        // @@protoc_insertion_point(oneof_field:signal.backup.Frame.stickerPack)
        StickerPack(super::StickerPack),
        // @@protoc_insertion_point(oneof_field:signal.backup.Frame.adHocCall)
        AdHocCall(super::AdHocCall),
        // @@protoc_insertion_point(oneof_field:signal.backup.Frame.notificationProfile)
        NotificationProfile(super::NotificationProfile),
        // @@protoc_insertion_point(oneof_field:signal.backup.Frame.chatFolder)
        ChatFolder(super::ChatFolder),
    }

    impl ::protobuf::Oneof for Item {
    }

    impl Item {
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.AccountData)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AccountData {
    // message fields
    #[field_name("profileKey")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.profileKey)
    pub profileKey: ::std::vec::Vec<u8>,
    #[field_name("username")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.username)
    pub username: ::std::option::Option<::std::string::String>,
    #[field_name("usernameLink")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.usernameLink)
    pub usernameLink: ::protobuf::MessageField<account_data::UsernameLink>,
    #[field_name("givenName")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.givenName)
    pub givenName: ::std::string::String,
    #[field_name("familyName")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.familyName)
    pub familyName: ::std::string::String,
    #[field_name("avatarUrlPath")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.avatarUrlPath)
    pub avatarUrlPath: ::std::string::String,
    #[field_name("donationSubscriberData")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.donationSubscriberData)
    pub donationSubscriberData: ::protobuf::MessageField<account_data::SubscriberData>,
    #[field_name("accountSettings")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.accountSettings)
    pub accountSettings: ::protobuf::MessageField<account_data::AccountSettings>,
    #[field_name("backupsSubscriberData")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.backupsSubscriberData)
    pub backupsSubscriberData: ::protobuf::MessageField<account_data::IAPSubscriberData>,
    #[field_name("svrPin")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.svrPin)
    pub svrPin: ::std::string::String,
    #[field_name("androidSpecificSettings")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.androidSpecificSettings)
    pub androidSpecificSettings: ::protobuf::MessageField<account_data::AndroidSpecificSettings>,
    #[field_name("bioText")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.bioText)
    pub bioText: ::std::string::String,
    #[field_name("bioEmoji")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.bioEmoji)
    pub bioEmoji: ::std::string::String,
    #[field_name("iosSpecificSettings")]
    // @@protoc_insertion_point(field:signal.backup.AccountData.iosSpecificSettings)
    pub iosSpecificSettings: ::protobuf::MessageField<account_data::IOSSpecificSettings>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.AccountData.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.profileKey = is.read_bytes()?;
                },
                18 => {
                    self.username = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.usernameLink)?;
                },
                34 => {
                    self.givenName = is.read_string()?;
                },
                42 => {
                    self.familyName = is.read_string()?;
                },
                50 => {
                    self.avatarUrlPath = is.read_string()?;
                },
                58 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.donationSubscriberData)?;
                },
                74 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.accountSettings)?;
                },
                82 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.backupsSubscriberData)?;
                },
                90 => {
                    self.svrPin = is.read_string()?;
                },
                98 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.androidSpecificSettings)?;
                },
                106 => {
                    self.bioText = is.read_string()?;
                },
                114 => {
                    self.bioEmoji = is.read_string()?;
                },
                130 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.iosSpecificSettings)?;
                },
                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.profileKey.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.profileKey);
        }
        if let Some(v) = self.username.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.usernameLink.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.givenName.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.givenName);
        }
        if !self.familyName.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.familyName);
        }
        if !self.avatarUrlPath.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.avatarUrlPath);
        }
        if let Some(v) = self.donationSubscriberData.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.accountSettings.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.backupsSubscriberData.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.svrPin.is_empty() {
            my_size += ::protobuf::rt::string_size(11, &self.svrPin);
        }
        if let Some(v) = self.androidSpecificSettings.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.bioText.is_empty() {
            my_size += ::protobuf::rt::string_size(13, &self.bioText);
        }
        if !self.bioEmoji.is_empty() {
            my_size += ::protobuf::rt::string_size(14, &self.bioEmoji);
        }
        if let Some(v) = self.iosSpecificSettings.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::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 !self.profileKey.is_empty() {
            os.write_bytes(1, &self.profileKey)?;
        }
        if let Some(v) = self.username.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.usernameLink.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if !self.givenName.is_empty() {
            os.write_string(4, &self.givenName)?;
        }
        if !self.familyName.is_empty() {
            os.write_string(5, &self.familyName)?;
        }
        if !self.avatarUrlPath.is_empty() {
            os.write_string(6, &self.avatarUrlPath)?;
        }
        if let Some(v) = self.donationSubscriberData.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
        }
        if let Some(v) = self.accountSettings.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
        }
        if let Some(v) = self.backupsSubscriberData.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
        }
        if !self.svrPin.is_empty() {
            os.write_string(11, &self.svrPin)?;
        }
        if let Some(v) = self.androidSpecificSettings.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
        }
        if !self.bioText.is_empty() {
            os.write_string(13, &self.bioText)?;
        }
        if !self.bioEmoji.is_empty() {
            os.write_string(14, &self.bioEmoji)?;
        }
        if let Some(v) = self.iosSpecificSettings.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(16, 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() -> AccountData {
        AccountData::new()
    }

    fn clear(&mut self) {
        self.profileKey.clear();
        self.username = ::std::option::Option::None;
        self.usernameLink.clear();
        self.givenName.clear();
        self.familyName.clear();
        self.avatarUrlPath.clear();
        self.donationSubscriberData.clear();
        self.accountSettings.clear();
        self.backupsSubscriberData.clear();
        self.svrPin.clear();
        self.androidSpecificSettings.clear();
        self.bioText.clear();
        self.bioEmoji.clear();
        self.iosSpecificSettings.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static AccountData {
        static instance: AccountData = AccountData {
            profileKey: ::std::vec::Vec::new(),
            username: ::std::option::Option::None,
            usernameLink: ::protobuf::MessageField::none(),
            givenName: ::std::string::String::new(),
            familyName: ::std::string::String::new(),
            avatarUrlPath: ::std::string::String::new(),
            donationSubscriberData: ::protobuf::MessageField::none(),
            accountSettings: ::protobuf::MessageField::none(),
            backupsSubscriberData: ::protobuf::MessageField::none(),
            svrPin: ::std::string::String::new(),
            androidSpecificSettings: ::protobuf::MessageField::none(),
            bioText: ::std::string::String::new(),
            bioEmoji: ::std::string::String::new(),
            iosSpecificSettings: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `AccountData`
pub mod account_data {
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.AccountData.UsernameLink)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct UsernameLink {
        // message fields
        #[field_name("entropy")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.UsernameLink.entropy)
        pub entropy: ::std::vec::Vec<u8>,
        #[field_name("serverId")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.UsernameLink.serverId)
        pub serverId: ::std::vec::Vec<u8>,
        #[field_name("color")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.UsernameLink.color)
        pub color: ::protobuf::EnumOrUnknown<username_link::Color>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.AccountData.UsernameLink.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.entropy = is.read_bytes()?;
                    },
                    18 => {
                        self.serverId = is.read_bytes()?;
                    },
                    24 => {
                        self.color = 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.entropy.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.entropy);
            }
            if !self.serverId.is_empty() {
                my_size += ::protobuf::rt::bytes_size(2, &self.serverId);
            }
            if self.color != ::protobuf::EnumOrUnknown::new(username_link::Color::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(3, self.color.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.entropy.is_empty() {
                os.write_bytes(1, &self.entropy)?;
            }
            if !self.serverId.is_empty() {
                os.write_bytes(2, &self.serverId)?;
            }
            if self.color != ::protobuf::EnumOrUnknown::new(username_link::Color::UNKNOWN) {
                os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.color))?;
            }
            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() -> UsernameLink {
            UsernameLink::new()
        }

        fn clear(&mut self) {
            self.entropy.clear();
            self.serverId.clear();
            self.color = ::protobuf::EnumOrUnknown::new(username_link::Color::UNKNOWN);
            self.special_fields.clear();
        }

        fn default_instance() -> &'static UsernameLink {
            static instance: UsernameLink = UsernameLink {
                entropy: ::std::vec::Vec::new(),
                serverId: ::std::vec::Vec::new(),
                color: ::protobuf::EnumOrUnknown::from_i32(0),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `UsernameLink`
    pub mod username_link {
        #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(enum:signal.backup.AccountData.UsernameLink.Color)
        pub enum Color {
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.UsernameLink.Color.UNKNOWN)
            UNKNOWN = 0,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.UsernameLink.Color.BLUE)
            BLUE = 1,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.UsernameLink.Color.WHITE)
            WHITE = 2,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.UsernameLink.Color.GREY)
            GREY = 3,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.UsernameLink.Color.OLIVE)
            OLIVE = 4,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.UsernameLink.Color.GREEN)
            GREEN = 5,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.UsernameLink.Color.ORANGE)
            ORANGE = 6,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.UsernameLink.Color.PINK)
            PINK = 7,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.UsernameLink.Color.PURPLE)
            PURPLE = 8,
        }

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

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

            fn from_i32(value: i32) -> ::std::option::Option<Color> {
                match value {
                    0 => ::std::option::Option::Some(Color::UNKNOWN),
                    1 => ::std::option::Option::Some(Color::BLUE),
                    2 => ::std::option::Option::Some(Color::WHITE),
                    3 => ::std::option::Option::Some(Color::GREY),
                    4 => ::std::option::Option::Some(Color::OLIVE),
                    5 => ::std::option::Option::Some(Color::GREEN),
                    6 => ::std::option::Option::Some(Color::ORANGE),
                    7 => ::std::option::Option::Some(Color::PINK),
                    8 => ::std::option::Option::Some(Color::PURPLE),
                    _ => ::std::option::Option::None
                }
            }

            fn from_str(str: &str) -> ::std::option::Option<Color> {
                match str {
                    "UNKNOWN" => ::std::option::Option::Some(Color::UNKNOWN),
                    "BLUE" => ::std::option::Option::Some(Color::BLUE),
                    "WHITE" => ::std::option::Option::Some(Color::WHITE),
                    "GREY" => ::std::option::Option::Some(Color::GREY),
                    "OLIVE" => ::std::option::Option::Some(Color::OLIVE),
                    "GREEN" => ::std::option::Option::Some(Color::GREEN),
                    "ORANGE" => ::std::option::Option::Some(Color::ORANGE),
                    "PINK" => ::std::option::Option::Some(Color::PINK),
                    "PURPLE" => ::std::option::Option::Some(Color::PURPLE),
                    _ => ::std::option::Option::None
                }
            }

            const VALUES: &'static [Color] = &[
                Color::UNKNOWN,
                Color::BLUE,
                Color::WHITE,
                Color::GREY,
                Color::OLIVE,
                Color::GREEN,
                Color::ORANGE,
                Color::PINK,
                Color::PURPLE,
            ];
        }

        impl ::std::default::Default for Color {
            fn default() -> Self {
                Color::UNKNOWN
            }
        }

    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.AccountData.AutoDownloadSettings)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct AutoDownloadSettings {
        // message fields
        #[field_name("images")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AutoDownloadSettings.images)
        pub images: ::protobuf::EnumOrUnknown<auto_download_settings::AutoDownloadOption>,
        #[field_name("audio")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AutoDownloadSettings.audio)
        pub audio: ::protobuf::EnumOrUnknown<auto_download_settings::AutoDownloadOption>,
        #[field_name("video")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AutoDownloadSettings.video)
        pub video: ::protobuf::EnumOrUnknown<auto_download_settings::AutoDownloadOption>,
        #[field_name("documents")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AutoDownloadSettings.documents)
        pub documents: ::protobuf::EnumOrUnknown<auto_download_settings::AutoDownloadOption>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.AccountData.AutoDownloadSettings.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.images = is.read_enum_or_unknown()?;
                    },
                    16 => {
                        self.audio = is.read_enum_or_unknown()?;
                    },
                    24 => {
                        self.video = is.read_enum_or_unknown()?;
                    },
                    32 => {
                        self.documents = 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.images != ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(1, self.images.value());
            }
            if self.audio != ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(2, self.audio.value());
            }
            if self.video != ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(3, self.video.value());
            }
            if self.documents != ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(4, self.documents.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.images != ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.images))?;
            }
            if self.audio != ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN) {
                os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.audio))?;
            }
            if self.video != ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN) {
                os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.video))?;
            }
            if self.documents != ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN) {
                os.write_enum(4, ::protobuf::EnumOrUnknown::value(&self.documents))?;
            }
            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() -> AutoDownloadSettings {
            AutoDownloadSettings::new()
        }

        fn clear(&mut self) {
            self.images = ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN);
            self.audio = ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN);
            self.video = ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN);
            self.documents = ::protobuf::EnumOrUnknown::new(auto_download_settings::AutoDownloadOption::UNKNOWN);
            self.special_fields.clear();
        }

        fn default_instance() -> &'static AutoDownloadSettings {
            static instance: AutoDownloadSettings = AutoDownloadSettings {
                images: ::protobuf::EnumOrUnknown::from_i32(0),
                audio: ::protobuf::EnumOrUnknown::from_i32(0),
                video: ::protobuf::EnumOrUnknown::from_i32(0),
                documents: ::protobuf::EnumOrUnknown::from_i32(0),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `AutoDownloadSettings`
    pub mod auto_download_settings {
        #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(enum:signal.backup.AccountData.AutoDownloadSettings.AutoDownloadOption)
        pub enum AutoDownloadOption {
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AutoDownloadSettings.AutoDownloadOption.UNKNOWN)
            UNKNOWN = 0,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AutoDownloadSettings.AutoDownloadOption.NEVER)
            NEVER = 1,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AutoDownloadSettings.AutoDownloadOption.WIFI)
            WIFI = 2,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AutoDownloadSettings.AutoDownloadOption.WIFI_AND_CELLULAR)
            WIFI_AND_CELLULAR = 3,
        }

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

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

            fn from_i32(value: i32) -> ::std::option::Option<AutoDownloadOption> {
                match value {
                    0 => ::std::option::Option::Some(AutoDownloadOption::UNKNOWN),
                    1 => ::std::option::Option::Some(AutoDownloadOption::NEVER),
                    2 => ::std::option::Option::Some(AutoDownloadOption::WIFI),
                    3 => ::std::option::Option::Some(AutoDownloadOption::WIFI_AND_CELLULAR),
                    _ => ::std::option::Option::None
                }
            }

            fn from_str(str: &str) -> ::std::option::Option<AutoDownloadOption> {
                match str {
                    "UNKNOWN" => ::std::option::Option::Some(AutoDownloadOption::UNKNOWN),
                    "NEVER" => ::std::option::Option::Some(AutoDownloadOption::NEVER),
                    "WIFI" => ::std::option::Option::Some(AutoDownloadOption::WIFI),
                    "WIFI_AND_CELLULAR" => ::std::option::Option::Some(AutoDownloadOption::WIFI_AND_CELLULAR),
                    _ => ::std::option::Option::None
                }
            }

            const VALUES: &'static [AutoDownloadOption] = &[
                AutoDownloadOption::UNKNOWN,
                AutoDownloadOption::NEVER,
                AutoDownloadOption::WIFI,
                AutoDownloadOption::WIFI_AND_CELLULAR,
            ];
        }

        impl ::std::default::Default for AutoDownloadOption {
            fn default() -> Self {
                AutoDownloadOption::UNKNOWN
            }
        }

    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.AccountData.AccountSettings)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct AccountSettings {
        // message fields
        #[field_name("readReceipts")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.readReceipts)
        pub readReceipts: bool,
        #[field_name("sealedSenderIndicators")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.sealedSenderIndicators)
        pub sealedSenderIndicators: bool,
        #[field_name("typingIndicators")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.typingIndicators)
        pub typingIndicators: bool,
        #[field_name("linkPreviews")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.linkPreviews)
        pub linkPreviews: bool,
        #[field_name("notDiscoverableByPhoneNumber")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.notDiscoverableByPhoneNumber)
        pub notDiscoverableByPhoneNumber: bool,
        #[field_name("preferContactAvatars")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.preferContactAvatars)
        pub preferContactAvatars: bool,
        #[field_name("universalExpireTimerSeconds")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.universalExpireTimerSeconds)
        pub universalExpireTimerSeconds: u32,
        #[field_name("preferredReactionEmoji")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.preferredReactionEmoji)
        pub preferredReactionEmoji: ::std::vec::Vec<::std::string::String>,
        #[field_name("displayBadgesOnProfile")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.displayBadgesOnProfile)
        pub displayBadgesOnProfile: bool,
        #[field_name("keepMutedChatsArchived")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.keepMutedChatsArchived)
        pub keepMutedChatsArchived: bool,
        #[field_name("hasSetMyStoriesPrivacy")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.hasSetMyStoriesPrivacy)
        pub hasSetMyStoriesPrivacy: bool,
        #[field_name("hasViewedOnboardingStory")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.hasViewedOnboardingStory)
        pub hasViewedOnboardingStory: bool,
        #[field_name("storiesDisabled")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.storiesDisabled)
        pub storiesDisabled: bool,
        #[field_name("storyViewReceiptsEnabled")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.storyViewReceiptsEnabled)
        pub storyViewReceiptsEnabled: ::std::option::Option<bool>,
        #[field_name("hasSeenGroupStoryEducationSheet")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.hasSeenGroupStoryEducationSheet)
        pub hasSeenGroupStoryEducationSheet: bool,
        #[field_name("hasCompletedUsernameOnboarding")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.hasCompletedUsernameOnboarding)
        pub hasCompletedUsernameOnboarding: bool,
        #[field_name("phoneNumberSharingMode")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.phoneNumberSharingMode)
        pub phoneNumberSharingMode: ::protobuf::EnumOrUnknown<PhoneNumberSharingMode>,
        #[field_name("defaultChatStyle")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.defaultChatStyle)
        pub defaultChatStyle: ::protobuf::MessageField<super::ChatStyle>,
        #[field_name("customChatColors")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.customChatColors)
        pub customChatColors: ::std::vec::Vec<super::chat_style::CustomChatColor>,
        #[field_name("optimizeOnDeviceStorage")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.optimizeOnDeviceStorage)
        pub optimizeOnDeviceStorage: bool,
        #[field_name("backupTier")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.backupTier)
        pub backupTier: ::std::option::Option<u64>,
        #[field_name("defaultSentMediaQuality")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.defaultSentMediaQuality)
        pub defaultSentMediaQuality: ::protobuf::EnumOrUnknown<SentMediaQuality>,
        #[field_name("autoDownloadSettings")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.autoDownloadSettings)
        pub autoDownloadSettings: ::protobuf::MessageField<AutoDownloadSettings>,
        #[field_name("screenLockTimeoutMinutes")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.screenLockTimeoutMinutes)
        pub screenLockTimeoutMinutes: ::std::option::Option<u32>,
        #[field_name("pinReminders")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.pinReminders)
        pub pinReminders: ::std::option::Option<bool>,
        #[field_name("appTheme")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.appTheme)
        pub appTheme: ::protobuf::EnumOrUnknown<AppTheme>,
        #[field_name("callsUseLessDataSetting")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.callsUseLessDataSetting)
        pub callsUseLessDataSetting: ::protobuf::EnumOrUnknown<CallsUseLessDataSetting>,
        #[field_name("allowSealedSenderFromAnyone")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.allowSealedSenderFromAnyone)
        pub allowSealedSenderFromAnyone: bool,
        #[field_name("allowAutomaticKeyVerification")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.allowAutomaticKeyVerification)
        pub allowAutomaticKeyVerification: bool,
        #[field_name("hasSeenAdminDeleteEducationDialog")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AccountSettings.hasSeenAdminDeleteEducationDialog)
        pub hasSeenAdminDeleteEducationDialog: bool,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.AccountData.AccountSettings.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.readReceipts = is.read_bool()?;
                    },
                    16 => {
                        self.sealedSenderIndicators = is.read_bool()?;
                    },
                    24 => {
                        self.typingIndicators = is.read_bool()?;
                    },
                    32 => {
                        self.linkPreviews = is.read_bool()?;
                    },
                    40 => {
                        self.notDiscoverableByPhoneNumber = is.read_bool()?;
                    },
                    48 => {
                        self.preferContactAvatars = is.read_bool()?;
                    },
                    56 => {
                        self.universalExpireTimerSeconds = is.read_uint32()?;
                    },
                    66 => {
                        self.preferredReactionEmoji.push(is.read_string()?);
                    },
                    72 => {
                        self.displayBadgesOnProfile = is.read_bool()?;
                    },
                    80 => {
                        self.keepMutedChatsArchived = is.read_bool()?;
                    },
                    88 => {
                        self.hasSetMyStoriesPrivacy = is.read_bool()?;
                    },
                    96 => {
                        self.hasViewedOnboardingStory = is.read_bool()?;
                    },
                    104 => {
                        self.storiesDisabled = is.read_bool()?;
                    },
                    112 => {
                        self.storyViewReceiptsEnabled = ::std::option::Option::Some(is.read_bool()?);
                    },
                    120 => {
                        self.hasSeenGroupStoryEducationSheet = is.read_bool()?;
                    },
                    128 => {
                        self.hasCompletedUsernameOnboarding = is.read_bool()?;
                    },
                    136 => {
                        self.phoneNumberSharingMode = is.read_enum_or_unknown()?;
                    },
                    146 => {
                        ::protobuf::rt::read_singular_message_into_field(is, &mut self.defaultChatStyle)?;
                    },
                    154 => {
                        self.customChatColors.push(is.read_message()?);
                    },
                    160 => {
                        self.optimizeOnDeviceStorage = is.read_bool()?;
                    },
                    168 => {
                        self.backupTier = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    184 => {
                        self.defaultSentMediaQuality = is.read_enum_or_unknown()?;
                    },
                    194 => {
                        ::protobuf::rt::read_singular_message_into_field(is, &mut self.autoDownloadSettings)?;
                    },
                    208 => {
                        self.screenLockTimeoutMinutes = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    216 => {
                        self.pinReminders = ::std::option::Option::Some(is.read_bool()?);
                    },
                    224 => {
                        self.appTheme = is.read_enum_or_unknown()?;
                    },
                    232 => {
                        self.callsUseLessDataSetting = is.read_enum_or_unknown()?;
                    },
                    240 => {
                        self.allowSealedSenderFromAnyone = is.read_bool()?;
                    },
                    248 => {
                        self.allowAutomaticKeyVerification = is.read_bool()?;
                    },
                    256 => {
                        self.hasSeenAdminDeleteEducationDialog = is.read_bool()?;
                    },
                    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.readReceipts != false {
                my_size += 1 + 1;
            }
            if self.sealedSenderIndicators != false {
                my_size += 1 + 1;
            }
            if self.typingIndicators != false {
                my_size += 1 + 1;
            }
            if self.linkPreviews != false {
                my_size += 1 + 1;
            }
            if self.notDiscoverableByPhoneNumber != false {
                my_size += 1 + 1;
            }
            if self.preferContactAvatars != false {
                my_size += 1 + 1;
            }
            if self.universalExpireTimerSeconds != 0 {
                my_size += ::protobuf::rt::uint32_size(7, self.universalExpireTimerSeconds);
            }
            for value in &self.preferredReactionEmoji {
                my_size += ::protobuf::rt::string_size(8, &value);
            };
            if self.displayBadgesOnProfile != false {
                my_size += 1 + 1;
            }
            if self.keepMutedChatsArchived != false {
                my_size += 1 + 1;
            }
            if self.hasSetMyStoriesPrivacy != false {
                my_size += 1 + 1;
            }
            if self.hasViewedOnboardingStory != false {
                my_size += 1 + 1;
            }
            if self.storiesDisabled != false {
                my_size += 1 + 1;
            }
            if let Some(v) = self.storyViewReceiptsEnabled {
                my_size += 1 + 1;
            }
            if self.hasSeenGroupStoryEducationSheet != false {
                my_size += 1 + 1;
            }
            if self.hasCompletedUsernameOnboarding != false {
                my_size += 2 + 1;
            }
            if self.phoneNumberSharingMode != ::protobuf::EnumOrUnknown::new(PhoneNumberSharingMode::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(17, self.phoneNumberSharingMode.value());
            }
            if let Some(v) = self.defaultChatStyle.as_ref() {
                let len = v.compute_size();
                my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            }
            for value in &self.customChatColors {
                let len = value.compute_size();
                my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            if self.optimizeOnDeviceStorage != false {
                my_size += 2 + 1;
            }
            if let Some(v) = self.backupTier {
                my_size += ::protobuf::rt::uint64_size(21, v);
            }
            if self.defaultSentMediaQuality != ::protobuf::EnumOrUnknown::new(SentMediaQuality::UNKNOWN_QUALITY) {
                my_size += ::protobuf::rt::int32_size(23, self.defaultSentMediaQuality.value());
            }
            if let Some(v) = self.autoDownloadSettings.as_ref() {
                let len = v.compute_size();
                my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            }
            if let Some(v) = self.screenLockTimeoutMinutes {
                my_size += ::protobuf::rt::uint32_size(26, v);
            }
            if let Some(v) = self.pinReminders {
                my_size += 2 + 1;
            }
            if self.appTheme != ::protobuf::EnumOrUnknown::new(AppTheme::UNKNOWN_APP_THEME) {
                my_size += ::protobuf::rt::int32_size(28, self.appTheme.value());
            }
            if self.callsUseLessDataSetting != ::protobuf::EnumOrUnknown::new(CallsUseLessDataSetting::UNKNOWN_CALL_DATA_SETTING) {
                my_size += ::protobuf::rt::int32_size(29, self.callsUseLessDataSetting.value());
            }
            if self.allowSealedSenderFromAnyone != false {
                my_size += 2 + 1;
            }
            if self.allowAutomaticKeyVerification != false {
                my_size += 2 + 1;
            }
            if self.hasSeenAdminDeleteEducationDialog != false {
                my_size += 2 + 1;
            }
            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.readReceipts != false {
                os.write_bool(1, self.readReceipts)?;
            }
            if self.sealedSenderIndicators != false {
                os.write_bool(2, self.sealedSenderIndicators)?;
            }
            if self.typingIndicators != false {
                os.write_bool(3, self.typingIndicators)?;
            }
            if self.linkPreviews != false {
                os.write_bool(4, self.linkPreviews)?;
            }
            if self.notDiscoverableByPhoneNumber != false {
                os.write_bool(5, self.notDiscoverableByPhoneNumber)?;
            }
            if self.preferContactAvatars != false {
                os.write_bool(6, self.preferContactAvatars)?;
            }
            if self.universalExpireTimerSeconds != 0 {
                os.write_uint32(7, self.universalExpireTimerSeconds)?;
            }
            for v in &self.preferredReactionEmoji {
                os.write_string(8, &v)?;
            };
            if self.displayBadgesOnProfile != false {
                os.write_bool(9, self.displayBadgesOnProfile)?;
            }
            if self.keepMutedChatsArchived != false {
                os.write_bool(10, self.keepMutedChatsArchived)?;
            }
            if self.hasSetMyStoriesPrivacy != false {
                os.write_bool(11, self.hasSetMyStoriesPrivacy)?;
            }
            if self.hasViewedOnboardingStory != false {
                os.write_bool(12, self.hasViewedOnboardingStory)?;
            }
            if self.storiesDisabled != false {
                os.write_bool(13, self.storiesDisabled)?;
            }
            if let Some(v) = self.storyViewReceiptsEnabled {
                os.write_bool(14, v)?;
            }
            if self.hasSeenGroupStoryEducationSheet != false {
                os.write_bool(15, self.hasSeenGroupStoryEducationSheet)?;
            }
            if self.hasCompletedUsernameOnboarding != false {
                os.write_bool(16, self.hasCompletedUsernameOnboarding)?;
            }
            if self.phoneNumberSharingMode != ::protobuf::EnumOrUnknown::new(PhoneNumberSharingMode::UNKNOWN) {
                os.write_enum(17, ::protobuf::EnumOrUnknown::value(&self.phoneNumberSharingMode))?;
            }
            if let Some(v) = self.defaultChatStyle.as_ref() {
                ::protobuf::rt::write_message_field_with_cached_size(18, v, os)?;
            }
            for v in &self.customChatColors {
                ::protobuf::rt::write_message_field_with_cached_size(19, v, os)?;
            };
            if self.optimizeOnDeviceStorage != false {
                os.write_bool(20, self.optimizeOnDeviceStorage)?;
            }
            if let Some(v) = self.backupTier {
                os.write_uint64(21, v)?;
            }
            if self.defaultSentMediaQuality != ::protobuf::EnumOrUnknown::new(SentMediaQuality::UNKNOWN_QUALITY) {
                os.write_enum(23, ::protobuf::EnumOrUnknown::value(&self.defaultSentMediaQuality))?;
            }
            if let Some(v) = self.autoDownloadSettings.as_ref() {
                ::protobuf::rt::write_message_field_with_cached_size(24, v, os)?;
            }
            if let Some(v) = self.screenLockTimeoutMinutes {
                os.write_uint32(26, v)?;
            }
            if let Some(v) = self.pinReminders {
                os.write_bool(27, v)?;
            }
            if self.appTheme != ::protobuf::EnumOrUnknown::new(AppTheme::UNKNOWN_APP_THEME) {
                os.write_enum(28, ::protobuf::EnumOrUnknown::value(&self.appTheme))?;
            }
            if self.callsUseLessDataSetting != ::protobuf::EnumOrUnknown::new(CallsUseLessDataSetting::UNKNOWN_CALL_DATA_SETTING) {
                os.write_enum(29, ::protobuf::EnumOrUnknown::value(&self.callsUseLessDataSetting))?;
            }
            if self.allowSealedSenderFromAnyone != false {
                os.write_bool(30, self.allowSealedSenderFromAnyone)?;
            }
            if self.allowAutomaticKeyVerification != false {
                os.write_bool(31, self.allowAutomaticKeyVerification)?;
            }
            if self.hasSeenAdminDeleteEducationDialog != false {
                os.write_bool(32, self.hasSeenAdminDeleteEducationDialog)?;
            }
            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() -> AccountSettings {
            AccountSettings::new()
        }

        fn clear(&mut self) {
            self.readReceipts = false;
            self.sealedSenderIndicators = false;
            self.typingIndicators = false;
            self.linkPreviews = false;
            self.notDiscoverableByPhoneNumber = false;
            self.preferContactAvatars = false;
            self.universalExpireTimerSeconds = 0;
            self.preferredReactionEmoji.clear();
            self.displayBadgesOnProfile = false;
            self.keepMutedChatsArchived = false;
            self.hasSetMyStoriesPrivacy = false;
            self.hasViewedOnboardingStory = false;
            self.storiesDisabled = false;
            self.storyViewReceiptsEnabled = ::std::option::Option::None;
            self.hasSeenGroupStoryEducationSheet = false;
            self.hasCompletedUsernameOnboarding = false;
            self.phoneNumberSharingMode = ::protobuf::EnumOrUnknown::new(PhoneNumberSharingMode::UNKNOWN);
            self.defaultChatStyle.clear();
            self.customChatColors.clear();
            self.optimizeOnDeviceStorage = false;
            self.backupTier = ::std::option::Option::None;
            self.defaultSentMediaQuality = ::protobuf::EnumOrUnknown::new(SentMediaQuality::UNKNOWN_QUALITY);
            self.autoDownloadSettings.clear();
            self.screenLockTimeoutMinutes = ::std::option::Option::None;
            self.pinReminders = ::std::option::Option::None;
            self.appTheme = ::protobuf::EnumOrUnknown::new(AppTheme::UNKNOWN_APP_THEME);
            self.callsUseLessDataSetting = ::protobuf::EnumOrUnknown::new(CallsUseLessDataSetting::UNKNOWN_CALL_DATA_SETTING);
            self.allowSealedSenderFromAnyone = false;
            self.allowAutomaticKeyVerification = false;
            self.hasSeenAdminDeleteEducationDialog = false;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static AccountSettings {
            static instance: AccountSettings = AccountSettings {
                readReceipts: false,
                sealedSenderIndicators: false,
                typingIndicators: false,
                linkPreviews: false,
                notDiscoverableByPhoneNumber: false,
                preferContactAvatars: false,
                universalExpireTimerSeconds: 0,
                preferredReactionEmoji: ::std::vec::Vec::new(),
                displayBadgesOnProfile: false,
                keepMutedChatsArchived: false,
                hasSetMyStoriesPrivacy: false,
                hasViewedOnboardingStory: false,
                storiesDisabled: false,
                storyViewReceiptsEnabled: ::std::option::Option::None,
                hasSeenGroupStoryEducationSheet: false,
                hasCompletedUsernameOnboarding: false,
                phoneNumberSharingMode: ::protobuf::EnumOrUnknown::from_i32(0),
                defaultChatStyle: ::protobuf::MessageField::none(),
                customChatColors: ::std::vec::Vec::new(),
                optimizeOnDeviceStorage: false,
                backupTier: ::std::option::Option::None,
                defaultSentMediaQuality: ::protobuf::EnumOrUnknown::from_i32(0),
                autoDownloadSettings: ::protobuf::MessageField::none(),
                screenLockTimeoutMinutes: ::std::option::Option::None,
                pinReminders: ::std::option::Option::None,
                appTheme: ::protobuf::EnumOrUnknown::from_i32(0),
                callsUseLessDataSetting: ::protobuf::EnumOrUnknown::from_i32(0),
                allowSealedSenderFromAnyone: false,
                allowAutomaticKeyVerification: false,
                hasSeenAdminDeleteEducationDialog: false,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.AccountData.SubscriberData)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SubscriberData {
        // message fields
        #[field_name("subscriberId")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.SubscriberData.subscriberId)
        pub subscriberId: ::std::vec::Vec<u8>,
        #[field_name("currencyCode")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.SubscriberData.currencyCode)
        pub currencyCode: ::std::string::String,
        #[field_name("manuallyCancelled")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.SubscriberData.manuallyCancelled)
        pub manuallyCancelled: bool,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.AccountData.SubscriberData.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.subscriberId = is.read_bytes()?;
                    },
                    18 => {
                        self.currencyCode = is.read_string()?;
                    },
                    24 => {
                        self.manuallyCancelled = is.read_bool()?;
                    },
                    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.subscriberId.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.subscriberId);
            }
            if !self.currencyCode.is_empty() {
                my_size += ::protobuf::rt::string_size(2, &self.currencyCode);
            }
            if self.manuallyCancelled != false {
                my_size += 1 + 1;
            }
            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.subscriberId.is_empty() {
                os.write_bytes(1, &self.subscriberId)?;
            }
            if !self.currencyCode.is_empty() {
                os.write_string(2, &self.currencyCode)?;
            }
            if self.manuallyCancelled != false {
                os.write_bool(3, self.manuallyCancelled)?;
            }
            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() -> SubscriberData {
            SubscriberData::new()
        }

        fn clear(&mut self) {
            self.subscriberId.clear();
            self.currencyCode.clear();
            self.manuallyCancelled = false;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SubscriberData {
            static instance: SubscriberData = SubscriberData {
                subscriberId: ::std::vec::Vec::new(),
                currencyCode: ::std::string::String::new(),
                manuallyCancelled: false,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.AccountData.IAPSubscriberData)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct IAPSubscriberData {
        // message fields
        #[field_name("subscriberId")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.IAPSubscriberData.subscriberId)
        pub subscriberId: ::std::vec::Vec<u8>,
        // message oneof groups
        pub iapSubscriptionId: ::std::option::Option<iapsubscriber_data::IapSubscriptionId>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.AccountData.IAPSubscriberData.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        // string purchaseToken = 2;

        pub fn purchaseToken(&self) -> &str {
            match self.iapSubscriptionId {
                ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::PurchaseToken(ref v)) => v,
                _ => "",
            }
        }

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

        pub fn has_purchaseToken(&self) -> bool {
            match self.iapSubscriptionId {
                ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::PurchaseToken(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_purchaseToken(&mut self, v: ::std::string::String) {
            self.iapSubscriptionId = ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::PurchaseToken(v))
        }

        // Mutable pointer to the field.
        pub fn mut_purchaseToken(&mut self) -> &mut ::std::string::String {
            if let ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::PurchaseToken(_)) = self.iapSubscriptionId {
            } else {
                self.iapSubscriptionId = ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::PurchaseToken(::std::string::String::new()));
            }
            match self.iapSubscriptionId {
                ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::PurchaseToken(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_purchaseToken(&mut self) -> ::std::string::String {
            if self.has_purchaseToken() {
                match self.iapSubscriptionId.take() {
                    ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::PurchaseToken(v)) => v,
                    _ => panic!(),
                }
            } else {
                ::std::string::String::new()
            }
        }

        // uint64 originalTransactionId = 3;

        pub fn originalTransactionId(&self) -> u64 {
            match self.iapSubscriptionId {
                ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::OriginalTransactionId(v)) => v,
                _ => 0,
            }
        }

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

        pub fn has_originalTransactionId(&self) -> bool {
            match self.iapSubscriptionId {
                ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::OriginalTransactionId(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_originalTransactionId(&mut self, v: u64) {
            self.iapSubscriptionId = ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::OriginalTransactionId(v))
        }
    }

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

        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.subscriberId = is.read_bytes()?;
                    },
                    18 => {
                        self.iapSubscriptionId = ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::PurchaseToken(is.read_string()?));
                    },
                    24 => {
                        self.iapSubscriptionId = ::std::option::Option::Some(iapsubscriber_data::IapSubscriptionId::OriginalTransactionId(is.read_uint64()?));
                    },
                    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.subscriberId.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.subscriberId);
            }
            if let ::std::option::Option::Some(ref v) = self.iapSubscriptionId {
                match v {
                    &iapsubscriber_data::IapSubscriptionId::PurchaseToken(ref v) => {
                        my_size += ::protobuf::rt::string_size(2, &v);
                    },
                    &iapsubscriber_data::IapSubscriptionId::OriginalTransactionId(v) => {
                        my_size += ::protobuf::rt::uint64_size(3, v);
                    },
                };
            }
            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.subscriberId.is_empty() {
                os.write_bytes(1, &self.subscriberId)?;
            }
            if let ::std::option::Option::Some(ref v) = self.iapSubscriptionId {
                match v {
                    &iapsubscriber_data::IapSubscriptionId::PurchaseToken(ref v) => {
                        os.write_string(2, v)?;
                    },
                    &iapsubscriber_data::IapSubscriptionId::OriginalTransactionId(v) => {
                        os.write_uint64(3, v)?;
                    },
                };
            }
            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() -> IAPSubscriberData {
            IAPSubscriberData::new()
        }

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

        fn default_instance() -> &'static IAPSubscriberData {
            static instance: IAPSubscriberData = IAPSubscriberData {
                subscriberId: ::std::vec::Vec::new(),
                iapSubscriptionId: ::std::option::Option::None,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `IAPSubscriberData`
    pub mod iapsubscriber_data {

        #[derive(Clone,PartialEq,Debug)]
        #[non_exhaustive]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(oneof:signal.backup.AccountData.IAPSubscriberData.iapSubscriptionId)
        pub enum IapSubscriptionId {
            // @@protoc_insertion_point(oneof_field:signal.backup.AccountData.IAPSubscriberData.purchaseToken)
            PurchaseToken(::std::string::String),
            // @@protoc_insertion_point(oneof_field:signal.backup.AccountData.IAPSubscriberData.originalTransactionId)
            OriginalTransactionId(u64),
        }

        impl ::protobuf::Oneof for IapSubscriptionId {
        }

        impl IapSubscriptionId {
        }
    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.AccountData.AndroidSpecificSettings)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct AndroidSpecificSettings {
        // message fields
        #[field_name("useSystemEmoji")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AndroidSpecificSettings.useSystemEmoji)
        pub useSystemEmoji: bool,
        #[field_name("screenshotSecurity")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AndroidSpecificSettings.screenshotSecurity)
        pub screenshotSecurity: bool,
        #[field_name("navigationBarSize")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.AndroidSpecificSettings.navigationBarSize)
        pub navigationBarSize: ::protobuf::EnumOrUnknown<android_specific_settings::NavigationBarSize>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.AccountData.AndroidSpecificSettings.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.useSystemEmoji = is.read_bool()?;
                    },
                    16 => {
                        self.screenshotSecurity = is.read_bool()?;
                    },
                    24 => {
                        self.navigationBarSize = 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.useSystemEmoji != false {
                my_size += 1 + 1;
            }
            if self.screenshotSecurity != false {
                my_size += 1 + 1;
            }
            if self.navigationBarSize != ::protobuf::EnumOrUnknown::new(android_specific_settings::NavigationBarSize::UNKNOWN_BAR_SIZE) {
                my_size += ::protobuf::rt::int32_size(3, self.navigationBarSize.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.useSystemEmoji != false {
                os.write_bool(1, self.useSystemEmoji)?;
            }
            if self.screenshotSecurity != false {
                os.write_bool(2, self.screenshotSecurity)?;
            }
            if self.navigationBarSize != ::protobuf::EnumOrUnknown::new(android_specific_settings::NavigationBarSize::UNKNOWN_BAR_SIZE) {
                os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.navigationBarSize))?;
            }
            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() -> AndroidSpecificSettings {
            AndroidSpecificSettings::new()
        }

        fn clear(&mut self) {
            self.useSystemEmoji = false;
            self.screenshotSecurity = false;
            self.navigationBarSize = ::protobuf::EnumOrUnknown::new(android_specific_settings::NavigationBarSize::UNKNOWN_BAR_SIZE);
            self.special_fields.clear();
        }

        fn default_instance() -> &'static AndroidSpecificSettings {
            static instance: AndroidSpecificSettings = AndroidSpecificSettings {
                useSystemEmoji: false,
                screenshotSecurity: false,
                navigationBarSize: ::protobuf::EnumOrUnknown::from_i32(0),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `AndroidSpecificSettings`
    pub mod android_specific_settings {
        #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(enum:signal.backup.AccountData.AndroidSpecificSettings.NavigationBarSize)
        pub enum NavigationBarSize {
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AndroidSpecificSettings.NavigationBarSize.UNKNOWN_BAR_SIZE)
            UNKNOWN_BAR_SIZE = 0,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AndroidSpecificSettings.NavigationBarSize.NORMAL)
            NORMAL = 1,
            // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AndroidSpecificSettings.NavigationBarSize.COMPACT)
            COMPACT = 2,
        }

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

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

            fn from_i32(value: i32) -> ::std::option::Option<NavigationBarSize> {
                match value {
                    0 => ::std::option::Option::Some(NavigationBarSize::UNKNOWN_BAR_SIZE),
                    1 => ::std::option::Option::Some(NavigationBarSize::NORMAL),
                    2 => ::std::option::Option::Some(NavigationBarSize::COMPACT),
                    _ => ::std::option::Option::None
                }
            }

            fn from_str(str: &str) -> ::std::option::Option<NavigationBarSize> {
                match str {
                    "UNKNOWN_BAR_SIZE" => ::std::option::Option::Some(NavigationBarSize::UNKNOWN_BAR_SIZE),
                    "NORMAL" => ::std::option::Option::Some(NavigationBarSize::NORMAL),
                    "COMPACT" => ::std::option::Option::Some(NavigationBarSize::COMPACT),
                    _ => ::std::option::Option::None
                }
            }

            const VALUES: &'static [NavigationBarSize] = &[
                NavigationBarSize::UNKNOWN_BAR_SIZE,
                NavigationBarSize::NORMAL,
                NavigationBarSize::COMPACT,
            ];
        }

        impl ::std::default::Default for NavigationBarSize {
            fn default() -> Self {
                NavigationBarSize::UNKNOWN_BAR_SIZE
            }
        }

    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.AccountData.IOSSpecificSettings)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct IOSSpecificSettings {
        // message fields
        #[field_name("isSystemCallLogEnabled")]
        // @@protoc_insertion_point(field:signal.backup.AccountData.IOSSpecificSettings.isSystemCallLogEnabled)
        pub isSystemCallLogEnabled: bool,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.AccountData.IOSSpecificSettings.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.isSystemCallLogEnabled = is.read_bool()?;
                    },
                    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.isSystemCallLogEnabled != false {
                my_size += 1 + 1;
            }
            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.isSystemCallLogEnabled != false {
                os.write_bool(1, self.isSystemCallLogEnabled)?;
            }
            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() -> IOSSpecificSettings {
            IOSSpecificSettings::new()
        }

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

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

    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.AccountData.PhoneNumberSharingMode)
    pub enum PhoneNumberSharingMode {
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.PhoneNumberSharingMode.UNKNOWN)
        UNKNOWN = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.PhoneNumberSharingMode.EVERYBODY)
        EVERYBODY = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.PhoneNumberSharingMode.NOBODY)
        NOBODY = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<PhoneNumberSharingMode> {
            match value {
                0 => ::std::option::Option::Some(PhoneNumberSharingMode::UNKNOWN),
                1 => ::std::option::Option::Some(PhoneNumberSharingMode::EVERYBODY),
                2 => ::std::option::Option::Some(PhoneNumberSharingMode::NOBODY),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<PhoneNumberSharingMode> {
            match str {
                "UNKNOWN" => ::std::option::Option::Some(PhoneNumberSharingMode::UNKNOWN),
                "EVERYBODY" => ::std::option::Option::Some(PhoneNumberSharingMode::EVERYBODY),
                "NOBODY" => ::std::option::Option::Some(PhoneNumberSharingMode::NOBODY),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [PhoneNumberSharingMode] = &[
            PhoneNumberSharingMode::UNKNOWN,
            PhoneNumberSharingMode::EVERYBODY,
            PhoneNumberSharingMode::NOBODY,
        ];
    }

    impl ::std::default::Default for PhoneNumberSharingMode {
        fn default() -> Self {
            PhoneNumberSharingMode::UNKNOWN
        }
    }


    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.AccountData.SentMediaQuality)
    pub enum SentMediaQuality {
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.SentMediaQuality.UNKNOWN_QUALITY)
        UNKNOWN_QUALITY = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.SentMediaQuality.STANDARD)
        STANDARD = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.SentMediaQuality.HIGH)
        HIGH = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<SentMediaQuality> {
            match value {
                0 => ::std::option::Option::Some(SentMediaQuality::UNKNOWN_QUALITY),
                1 => ::std::option::Option::Some(SentMediaQuality::STANDARD),
                2 => ::std::option::Option::Some(SentMediaQuality::HIGH),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<SentMediaQuality> {
            match str {
                "UNKNOWN_QUALITY" => ::std::option::Option::Some(SentMediaQuality::UNKNOWN_QUALITY),
                "STANDARD" => ::std::option::Option::Some(SentMediaQuality::STANDARD),
                "HIGH" => ::std::option::Option::Some(SentMediaQuality::HIGH),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [SentMediaQuality] = &[
            SentMediaQuality::UNKNOWN_QUALITY,
            SentMediaQuality::STANDARD,
            SentMediaQuality::HIGH,
        ];
    }

    impl ::std::default::Default for SentMediaQuality {
        fn default() -> Self {
            SentMediaQuality::UNKNOWN_QUALITY
        }
    }


    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.AccountData.AppTheme)
    pub enum AppTheme {
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AppTheme.UNKNOWN_APP_THEME)
        UNKNOWN_APP_THEME = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AppTheme.SYSTEM)
        SYSTEM = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AppTheme.LIGHT)
        LIGHT = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.AppTheme.DARK)
        DARK = 3,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<AppTheme> {
            match value {
                0 => ::std::option::Option::Some(AppTheme::UNKNOWN_APP_THEME),
                1 => ::std::option::Option::Some(AppTheme::SYSTEM),
                2 => ::std::option::Option::Some(AppTheme::LIGHT),
                3 => ::std::option::Option::Some(AppTheme::DARK),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<AppTheme> {
            match str {
                "UNKNOWN_APP_THEME" => ::std::option::Option::Some(AppTheme::UNKNOWN_APP_THEME),
                "SYSTEM" => ::std::option::Option::Some(AppTheme::SYSTEM),
                "LIGHT" => ::std::option::Option::Some(AppTheme::LIGHT),
                "DARK" => ::std::option::Option::Some(AppTheme::DARK),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [AppTheme] = &[
            AppTheme::UNKNOWN_APP_THEME,
            AppTheme::SYSTEM,
            AppTheme::LIGHT,
            AppTheme::DARK,
        ];
    }

    impl ::std::default::Default for AppTheme {
        fn default() -> Self {
            AppTheme::UNKNOWN_APP_THEME
        }
    }


    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.AccountData.CallsUseLessDataSetting)
    pub enum CallsUseLessDataSetting {
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.CallsUseLessDataSetting.UNKNOWN_CALL_DATA_SETTING)
        UNKNOWN_CALL_DATA_SETTING = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.CallsUseLessDataSetting.NEVER)
        NEVER = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.CallsUseLessDataSetting.MOBILE_DATA_ONLY)
        MOBILE_DATA_ONLY = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.AccountData.CallsUseLessDataSetting.WIFI_AND_MOBILE_DATA)
        WIFI_AND_MOBILE_DATA = 3,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<CallsUseLessDataSetting> {
            match value {
                0 => ::std::option::Option::Some(CallsUseLessDataSetting::UNKNOWN_CALL_DATA_SETTING),
                1 => ::std::option::Option::Some(CallsUseLessDataSetting::NEVER),
                2 => ::std::option::Option::Some(CallsUseLessDataSetting::MOBILE_DATA_ONLY),
                3 => ::std::option::Option::Some(CallsUseLessDataSetting::WIFI_AND_MOBILE_DATA),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<CallsUseLessDataSetting> {
            match str {
                "UNKNOWN_CALL_DATA_SETTING" => ::std::option::Option::Some(CallsUseLessDataSetting::UNKNOWN_CALL_DATA_SETTING),
                "NEVER" => ::std::option::Option::Some(CallsUseLessDataSetting::NEVER),
                "MOBILE_DATA_ONLY" => ::std::option::Option::Some(CallsUseLessDataSetting::MOBILE_DATA_ONLY),
                "WIFI_AND_MOBILE_DATA" => ::std::option::Option::Some(CallsUseLessDataSetting::WIFI_AND_MOBILE_DATA),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [CallsUseLessDataSetting] = &[
            CallsUseLessDataSetting::UNKNOWN_CALL_DATA_SETTING,
            CallsUseLessDataSetting::NEVER,
            CallsUseLessDataSetting::MOBILE_DATA_ONLY,
            CallsUseLessDataSetting::WIFI_AND_MOBILE_DATA,
        ];
    }

    impl ::std::default::Default for CallsUseLessDataSetting {
        fn default() -> Self {
            CallsUseLessDataSetting::UNKNOWN_CALL_DATA_SETTING
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Recipient)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Recipient {
    // message fields
    #[field_name("id")]
    // @@protoc_insertion_point(field:signal.backup.Recipient.id)
    pub id: u64,
    // message oneof groups
    pub destination: ::std::option::Option<recipient::Destination>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Recipient.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .signal.backup.Contact contact = 2;

    pub fn contact(&self) -> &Contact {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::Contact(ref v)) => v,
            _ => <Contact as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_contact(&self) -> bool {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::Contact(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_contact(&mut self, v: Contact) {
        self.destination = ::std::option::Option::Some(recipient::Destination::Contact(v))
    }

    // Mutable pointer to the field.
    pub fn mut_contact(&mut self) -> &mut Contact {
        if let ::std::option::Option::Some(recipient::Destination::Contact(_)) = self.destination {
        } else {
            self.destination = ::std::option::Option::Some(recipient::Destination::Contact(Contact::new()));
        }
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::Contact(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_contact(&mut self) -> Contact {
        if self.has_contact() {
            match self.destination.take() {
                ::std::option::Option::Some(recipient::Destination::Contact(v)) => v,
                _ => panic!(),
            }
        } else {
            Contact::new()
        }
    }

    // .signal.backup.Group group = 3;

    pub fn group(&self) -> &Group {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::Group(ref v)) => v,
            _ => <Group as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_group(&self) -> bool {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::Group(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_group(&mut self, v: Group) {
        self.destination = ::std::option::Option::Some(recipient::Destination::Group(v))
    }

    // Mutable pointer to the field.
    pub fn mut_group(&mut self) -> &mut Group {
        if let ::std::option::Option::Some(recipient::Destination::Group(_)) = self.destination {
        } else {
            self.destination = ::std::option::Option::Some(recipient::Destination::Group(Group::new()));
        }
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::Group(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_group(&mut self) -> Group {
        if self.has_group() {
            match self.destination.take() {
                ::std::option::Option::Some(recipient::Destination::Group(v)) => v,
                _ => panic!(),
            }
        } else {
            Group::new()
        }
    }

    // .signal.backup.DistributionListItem distributionList = 4;

    pub fn distributionList(&self) -> &DistributionListItem {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::DistributionList(ref v)) => v,
            _ => <DistributionListItem as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_distributionList(&self) -> bool {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::DistributionList(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_distributionList(&mut self, v: DistributionListItem) {
        self.destination = ::std::option::Option::Some(recipient::Destination::DistributionList(v))
    }

    // Mutable pointer to the field.
    pub fn mut_distributionList(&mut self) -> &mut DistributionListItem {
        if let ::std::option::Option::Some(recipient::Destination::DistributionList(_)) = self.destination {
        } else {
            self.destination = ::std::option::Option::Some(recipient::Destination::DistributionList(DistributionListItem::new()));
        }
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::DistributionList(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_distributionList(&mut self) -> DistributionListItem {
        if self.has_distributionList() {
            match self.destination.take() {
                ::std::option::Option::Some(recipient::Destination::DistributionList(v)) => v,
                _ => panic!(),
            }
        } else {
            DistributionListItem::new()
        }
    }

    // .signal.backup.Self self = 5;

    pub fn self_(&self) -> &Self_ {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::Self_(ref v)) => v,
            _ => <Self_ as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_self(&self) -> bool {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::Self_(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_self(&mut self, v: Self_) {
        self.destination = ::std::option::Option::Some(recipient::Destination::Self_(v))
    }

    // Mutable pointer to the field.
    pub fn mut_self(&mut self) -> &mut Self_ {
        if let ::std::option::Option::Some(recipient::Destination::Self_(_)) = self.destination {
        } else {
            self.destination = ::std::option::Option::Some(recipient::Destination::Self_(Self_::new()));
        }
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::Self_(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_self_(&mut self) -> Self_ {
        if self.has_self() {
            match self.destination.take() {
                ::std::option::Option::Some(recipient::Destination::Self_(v)) => v,
                _ => panic!(),
            }
        } else {
            Self_::new()
        }
    }

    // .signal.backup.ReleaseNotes releaseNotes = 6;

    pub fn releaseNotes(&self) -> &ReleaseNotes {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::ReleaseNotes(ref v)) => v,
            _ => <ReleaseNotes as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_releaseNotes(&self) -> bool {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::ReleaseNotes(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_releaseNotes(&mut self, v: ReleaseNotes) {
        self.destination = ::std::option::Option::Some(recipient::Destination::ReleaseNotes(v))
    }

    // Mutable pointer to the field.
    pub fn mut_releaseNotes(&mut self) -> &mut ReleaseNotes {
        if let ::std::option::Option::Some(recipient::Destination::ReleaseNotes(_)) = self.destination {
        } else {
            self.destination = ::std::option::Option::Some(recipient::Destination::ReleaseNotes(ReleaseNotes::new()));
        }
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::ReleaseNotes(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_releaseNotes(&mut self) -> ReleaseNotes {
        if self.has_releaseNotes() {
            match self.destination.take() {
                ::std::option::Option::Some(recipient::Destination::ReleaseNotes(v)) => v,
                _ => panic!(),
            }
        } else {
            ReleaseNotes::new()
        }
    }

    // .signal.backup.CallLink callLink = 7;

    pub fn callLink(&self) -> &CallLink {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::CallLink(ref v)) => v,
            _ => <CallLink as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_callLink(&self) -> bool {
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::CallLink(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_callLink(&mut self, v: CallLink) {
        self.destination = ::std::option::Option::Some(recipient::Destination::CallLink(v))
    }

    // Mutable pointer to the field.
    pub fn mut_callLink(&mut self) -> &mut CallLink {
        if let ::std::option::Option::Some(recipient::Destination::CallLink(_)) = self.destination {
        } else {
            self.destination = ::std::option::Option::Some(recipient::Destination::CallLink(CallLink::new()));
        }
        match self.destination {
            ::std::option::Option::Some(recipient::Destination::CallLink(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_callLink(&mut self) -> CallLink {
        if self.has_callLink() {
            match self.destination.take() {
                ::std::option::Option::Some(recipient::Destination::CallLink(v)) => v,
                _ => panic!(),
            }
        } else {
            CallLink::new()
        }
    }
}

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

    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.id = is.read_uint64()?;
                },
                18 => {
                    self.destination = ::std::option::Option::Some(recipient::Destination::Contact(is.read_message()?));
                },
                26 => {
                    self.destination = ::std::option::Option::Some(recipient::Destination::Group(is.read_message()?));
                },
                34 => {
                    self.destination = ::std::option::Option::Some(recipient::Destination::DistributionList(is.read_message()?));
                },
                42 => {
                    self.destination = ::std::option::Option::Some(recipient::Destination::Self_(is.read_message()?));
                },
                50 => {
                    self.destination = ::std::option::Option::Some(recipient::Destination::ReleaseNotes(is.read_message()?));
                },
                58 => {
                    self.destination = ::std::option::Option::Some(recipient::Destination::CallLink(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 self.id != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.id);
        }
        if let ::std::option::Option::Some(ref v) = self.destination {
            match v {
                &recipient::Destination::Contact(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &recipient::Destination::Group(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &recipient::Destination::DistributionList(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &recipient::Destination::Self_(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &recipient::Destination::ReleaseNotes(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &recipient::Destination::CallLink(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 self.id != 0 {
            os.write_uint64(1, self.id)?;
        }
        if let ::std::option::Option::Some(ref v) = self.destination {
            match v {
                &recipient::Destination::Contact(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
                &recipient::Destination::Group(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &recipient::Destination::DistributionList(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &recipient::Destination::Self_(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &recipient::Destination::ReleaseNotes(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &recipient::Destination::CallLink(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, 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() -> Recipient {
        Recipient::new()
    }

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

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

/// Nested message and enums of message `Recipient`
pub mod recipient {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.Recipient.destination)
    pub enum Destination {
        // @@protoc_insertion_point(oneof_field:signal.backup.Recipient.contact)
        Contact(super::Contact),
        // @@protoc_insertion_point(oneof_field:signal.backup.Recipient.group)
        Group(super::Group),
        // @@protoc_insertion_point(oneof_field:signal.backup.Recipient.distributionList)
        DistributionList(super::DistributionListItem),
        // @@protoc_insertion_point(oneof_field:signal.backup.Recipient.self)
        Self_(super::Self_),
        // @@protoc_insertion_point(oneof_field:signal.backup.Recipient.releaseNotes)
        ReleaseNotes(super::ReleaseNotes),
        // @@protoc_insertion_point(oneof_field:signal.backup.Recipient.callLink)
        CallLink(super::CallLink),
    }

    impl ::protobuf::Oneof for Destination {
    }

    impl Destination {
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Contact)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Contact {
    // message fields
    #[field_name("aci")]
    // @@protoc_insertion_point(field:signal.backup.Contact.aci)
    pub aci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("pni")]
    // @@protoc_insertion_point(field:signal.backup.Contact.pni)
    pub pni: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("username")]
    // @@protoc_insertion_point(field:signal.backup.Contact.username)
    pub username: ::std::option::Option<::std::string::String>,
    #[field_name("e164")]
    // @@protoc_insertion_point(field:signal.backup.Contact.e164)
    pub e164: ::std::option::Option<u64>,
    #[field_name("blocked")]
    // @@protoc_insertion_point(field:signal.backup.Contact.blocked)
    pub blocked: bool,
    #[field_name("visibility")]
    // @@protoc_insertion_point(field:signal.backup.Contact.visibility)
    pub visibility: ::protobuf::EnumOrUnknown<contact::Visibility>,
    #[field_name("profileKey")]
    // @@protoc_insertion_point(field:signal.backup.Contact.profileKey)
    pub profileKey: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("profileSharing")]
    // @@protoc_insertion_point(field:signal.backup.Contact.profileSharing)
    pub profileSharing: bool,
    #[field_name("profileGivenName")]
    // @@protoc_insertion_point(field:signal.backup.Contact.profileGivenName)
    pub profileGivenName: ::std::option::Option<::std::string::String>,
    #[field_name("profileFamilyName")]
    // @@protoc_insertion_point(field:signal.backup.Contact.profileFamilyName)
    pub profileFamilyName: ::std::option::Option<::std::string::String>,
    #[field_name("hideStory")]
    // @@protoc_insertion_point(field:signal.backup.Contact.hideStory)
    pub hideStory: bool,
    #[field_name("identityKey")]
    // @@protoc_insertion_point(field:signal.backup.Contact.identityKey)
    pub identityKey: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("identityState")]
    // @@protoc_insertion_point(field:signal.backup.Contact.identityState)
    pub identityState: ::protobuf::EnumOrUnknown<contact::IdentityState>,
    #[field_name("nickname")]
    // @@protoc_insertion_point(field:signal.backup.Contact.nickname)
    pub nickname: ::protobuf::MessageField<contact::Name>,
    #[field_name("note")]
    // @@protoc_insertion_point(field:signal.backup.Contact.note)
    pub note: ::std::string::String,
    #[field_name("systemGivenName")]
    // @@protoc_insertion_point(field:signal.backup.Contact.systemGivenName)
    pub systemGivenName: ::std::string::String,
    #[field_name("systemFamilyName")]
    // @@protoc_insertion_point(field:signal.backup.Contact.systemFamilyName)
    pub systemFamilyName: ::std::string::String,
    #[field_name("systemNickname")]
    // @@protoc_insertion_point(field:signal.backup.Contact.systemNickname)
    pub systemNickname: ::std::string::String,
    #[field_name("avatarColor")]
    // @@protoc_insertion_point(field:signal.backup.Contact.avatarColor)
    pub avatarColor: ::std::option::Option<::protobuf::EnumOrUnknown<AvatarColor>>,
    #[field_name("keyTransparencyData")]
    // @@protoc_insertion_point(field:signal.backup.Contact.keyTransparencyData)
    pub keyTransparencyData: ::std::option::Option<::std::vec::Vec<u8>>,
    // message oneof groups
    pub registration: ::std::option::Option<contact::Registration>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Contact.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .signal.backup.Contact.Registered registered = 7;

    pub fn registered(&self) -> &contact::Registered {
        match self.registration {
            ::std::option::Option::Some(contact::Registration::Registered(ref v)) => v,
            _ => <contact::Registered as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_registered(&self) -> bool {
        match self.registration {
            ::std::option::Option::Some(contact::Registration::Registered(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_registered(&mut self, v: contact::Registered) {
        self.registration = ::std::option::Option::Some(contact::Registration::Registered(v))
    }

    // Mutable pointer to the field.
    pub fn mut_registered(&mut self) -> &mut contact::Registered {
        if let ::std::option::Option::Some(contact::Registration::Registered(_)) = self.registration {
        } else {
            self.registration = ::std::option::Option::Some(contact::Registration::Registered(contact::Registered::new()));
        }
        match self.registration {
            ::std::option::Option::Some(contact::Registration::Registered(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_registered(&mut self) -> contact::Registered {
        if self.has_registered() {
            match self.registration.take() {
                ::std::option::Option::Some(contact::Registration::Registered(v)) => v,
                _ => panic!(),
            }
        } else {
            contact::Registered::new()
        }
    }

    // .signal.backup.Contact.NotRegistered notRegistered = 8;

    pub fn notRegistered(&self) -> &contact::NotRegistered {
        match self.registration {
            ::std::option::Option::Some(contact::Registration::NotRegistered(ref v)) => v,
            _ => <contact::NotRegistered as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_notRegistered(&self) -> bool {
        match self.registration {
            ::std::option::Option::Some(contact::Registration::NotRegistered(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_notRegistered(&mut self, v: contact::NotRegistered) {
        self.registration = ::std::option::Option::Some(contact::Registration::NotRegistered(v))
    }

    // Mutable pointer to the field.
    pub fn mut_notRegistered(&mut self) -> &mut contact::NotRegistered {
        if let ::std::option::Option::Some(contact::Registration::NotRegistered(_)) = self.registration {
        } else {
            self.registration = ::std::option::Option::Some(contact::Registration::NotRegistered(contact::NotRegistered::new()));
        }
        match self.registration {
            ::std::option::Option::Some(contact::Registration::NotRegistered(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_notRegistered(&mut self) -> contact::NotRegistered {
        if self.has_notRegistered() {
            match self.registration.take() {
                ::std::option::Option::Some(contact::Registration::NotRegistered(v)) => v,
                _ => panic!(),
            }
        } else {
            contact::NotRegistered::new()
        }
    }
}

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

    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.aci = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.pni = ::std::option::Option::Some(is.read_bytes()?);
                },
                26 => {
                    self.username = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.e164 = ::std::option::Option::Some(is.read_uint64()?);
                },
                40 => {
                    self.blocked = is.read_bool()?;
                },
                48 => {
                    self.visibility = is.read_enum_or_unknown()?;
                },
                58 => {
                    self.registration = ::std::option::Option::Some(contact::Registration::Registered(is.read_message()?));
                },
                66 => {
                    self.registration = ::std::option::Option::Some(contact::Registration::NotRegistered(is.read_message()?));
                },
                74 => {
                    self.profileKey = ::std::option::Option::Some(is.read_bytes()?);
                },
                80 => {
                    self.profileSharing = is.read_bool()?;
                },
                90 => {
                    self.profileGivenName = ::std::option::Option::Some(is.read_string()?);
                },
                98 => {
                    self.profileFamilyName = ::std::option::Option::Some(is.read_string()?);
                },
                104 => {
                    self.hideStory = is.read_bool()?;
                },
                114 => {
                    self.identityKey = ::std::option::Option::Some(is.read_bytes()?);
                },
                120 => {
                    self.identityState = is.read_enum_or_unknown()?;
                },
                130 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.nickname)?;
                },
                138 => {
                    self.note = is.read_string()?;
                },
                146 => {
                    self.systemGivenName = is.read_string()?;
                },
                154 => {
                    self.systemFamilyName = is.read_string()?;
                },
                162 => {
                    self.systemNickname = is.read_string()?;
                },
                168 => {
                    self.avatarColor = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                178 => {
                    self.keyTransparencyData = ::std::option::Option::Some(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 let Some(v) = self.aci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.pni.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.username.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.e164 {
            my_size += ::protobuf::rt::uint64_size(4, v);
        }
        if self.blocked != false {
            my_size += 1 + 1;
        }
        if self.visibility != ::protobuf::EnumOrUnknown::new(contact::Visibility::VISIBLE) {
            my_size += ::protobuf::rt::int32_size(6, self.visibility.value());
        }
        if let Some(v) = self.profileKey.as_ref() {
            my_size += ::protobuf::rt::bytes_size(9, &v);
        }
        if self.profileSharing != false {
            my_size += 1 + 1;
        }
        if let Some(v) = self.profileGivenName.as_ref() {
            my_size += ::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.profileFamilyName.as_ref() {
            my_size += ::protobuf::rt::string_size(12, &v);
        }
        if self.hideStory != false {
            my_size += 1 + 1;
        }
        if let Some(v) = self.identityKey.as_ref() {
            my_size += ::protobuf::rt::bytes_size(14, &v);
        }
        if self.identityState != ::protobuf::EnumOrUnknown::new(contact::IdentityState::DEFAULT) {
            my_size += ::protobuf::rt::int32_size(15, self.identityState.value());
        }
        if let Some(v) = self.nickname.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.note.is_empty() {
            my_size += ::protobuf::rt::string_size(17, &self.note);
        }
        if !self.systemGivenName.is_empty() {
            my_size += ::protobuf::rt::string_size(18, &self.systemGivenName);
        }
        if !self.systemFamilyName.is_empty() {
            my_size += ::protobuf::rt::string_size(19, &self.systemFamilyName);
        }
        if !self.systemNickname.is_empty() {
            my_size += ::protobuf::rt::string_size(20, &self.systemNickname);
        }
        if let Some(v) = self.avatarColor {
            my_size += ::protobuf::rt::int32_size(21, v.value());
        }
        if let Some(v) = self.keyTransparencyData.as_ref() {
            my_size += ::protobuf::rt::bytes_size(22, &v);
        }
        if let ::std::option::Option::Some(ref v) = self.registration {
            match v {
                &contact::Registration::Registered(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &contact::Registration::NotRegistered(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 Some(v) = self.aci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if let Some(v) = self.pni.as_ref() {
            os.write_bytes(2, v)?;
        }
        if let Some(v) = self.username.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.e164 {
            os.write_uint64(4, v)?;
        }
        if self.blocked != false {
            os.write_bool(5, self.blocked)?;
        }
        if self.visibility != ::protobuf::EnumOrUnknown::new(contact::Visibility::VISIBLE) {
            os.write_enum(6, ::protobuf::EnumOrUnknown::value(&self.visibility))?;
        }
        if let Some(v) = self.profileKey.as_ref() {
            os.write_bytes(9, v)?;
        }
        if self.profileSharing != false {
            os.write_bool(10, self.profileSharing)?;
        }
        if let Some(v) = self.profileGivenName.as_ref() {
            os.write_string(11, v)?;
        }
        if let Some(v) = self.profileFamilyName.as_ref() {
            os.write_string(12, v)?;
        }
        if self.hideStory != false {
            os.write_bool(13, self.hideStory)?;
        }
        if let Some(v) = self.identityKey.as_ref() {
            os.write_bytes(14, v)?;
        }
        if self.identityState != ::protobuf::EnumOrUnknown::new(contact::IdentityState::DEFAULT) {
            os.write_enum(15, ::protobuf::EnumOrUnknown::value(&self.identityState))?;
        }
        if let Some(v) = self.nickname.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(16, v, os)?;
        }
        if !self.note.is_empty() {
            os.write_string(17, &self.note)?;
        }
        if !self.systemGivenName.is_empty() {
            os.write_string(18, &self.systemGivenName)?;
        }
        if !self.systemFamilyName.is_empty() {
            os.write_string(19, &self.systemFamilyName)?;
        }
        if !self.systemNickname.is_empty() {
            os.write_string(20, &self.systemNickname)?;
        }
        if let Some(v) = self.avatarColor {
            os.write_enum(21, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.keyTransparencyData.as_ref() {
            os.write_bytes(22, v)?;
        }
        if let ::std::option::Option::Some(ref v) = self.registration {
            match v {
                &contact::Registration::Registered(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
                &contact::Registration::NotRegistered(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() -> Contact {
        Contact::new()
    }

    fn clear(&mut self) {
        self.aci = ::std::option::Option::None;
        self.pni = ::std::option::Option::None;
        self.username = ::std::option::Option::None;
        self.e164 = ::std::option::Option::None;
        self.blocked = false;
        self.visibility = ::protobuf::EnumOrUnknown::new(contact::Visibility::VISIBLE);
        self.registration = ::std::option::Option::None;
        self.registration = ::std::option::Option::None;
        self.profileKey = ::std::option::Option::None;
        self.profileSharing = false;
        self.profileGivenName = ::std::option::Option::None;
        self.profileFamilyName = ::std::option::Option::None;
        self.hideStory = false;
        self.identityKey = ::std::option::Option::None;
        self.identityState = ::protobuf::EnumOrUnknown::new(contact::IdentityState::DEFAULT);
        self.nickname.clear();
        self.note.clear();
        self.systemGivenName.clear();
        self.systemFamilyName.clear();
        self.systemNickname.clear();
        self.avatarColor = ::std::option::Option::None;
        self.keyTransparencyData = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Contact {
        static instance: Contact = Contact {
            aci: ::std::option::Option::None,
            pni: ::std::option::Option::None,
            username: ::std::option::Option::None,
            e164: ::std::option::Option::None,
            blocked: false,
            visibility: ::protobuf::EnumOrUnknown::from_i32(0),
            profileKey: ::std::option::Option::None,
            profileSharing: false,
            profileGivenName: ::std::option::Option::None,
            profileFamilyName: ::std::option::Option::None,
            hideStory: false,
            identityKey: ::std::option::Option::None,
            identityState: ::protobuf::EnumOrUnknown::from_i32(0),
            nickname: ::protobuf::MessageField::none(),
            note: ::std::string::String::new(),
            systemGivenName: ::std::string::String::new(),
            systemFamilyName: ::std::string::String::new(),
            systemNickname: ::std::string::String::new(),
            avatarColor: ::std::option::Option::None,
            keyTransparencyData: ::std::option::Option::None,
            registration: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `Contact`
pub mod contact {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.Contact.registration)
    pub enum Registration {
        // @@protoc_insertion_point(oneof_field:signal.backup.Contact.registered)
        Registered(Registered),
        // @@protoc_insertion_point(oneof_field:signal.backup.Contact.notRegistered)
        NotRegistered(NotRegistered),
    }

    impl ::protobuf::Oneof for Registration {
    }

    impl Registration {
    }
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Contact.Registered)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Registered {
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Contact.Registered.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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() -> Registered {
            Registered::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Contact.NotRegistered)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct NotRegistered {
        // message fields
        #[field_name("unregisteredTimestamp")]
        // @@protoc_insertion_point(field:signal.backup.Contact.NotRegistered.unregisteredTimestamp)
        pub unregisteredTimestamp: u64,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Contact.NotRegistered.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.unregisteredTimestamp = is.read_uint64()?;
                    },
                    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.unregisteredTimestamp != 0 {
                my_size += ::protobuf::rt::uint64_size(1, self.unregisteredTimestamp);
            }
            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.unregisteredTimestamp != 0 {
                os.write_uint64(1, self.unregisteredTimestamp)?;
            }
            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() -> NotRegistered {
            NotRegistered::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Contact.Name)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Name {
        // message fields
        #[field_name("given")]
        // @@protoc_insertion_point(field:signal.backup.Contact.Name.given)
        pub given: ::std::string::String,
        #[field_name("family")]
        // @@protoc_insertion_point(field:signal.backup.Contact.Name.family)
        pub family: ::std::string::String,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Contact.Name.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.given = is.read_string()?;
                    },
                    18 => {
                        self.family = is.read_string()?;
                    },
                    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.given.is_empty() {
                my_size += ::protobuf::rt::string_size(1, &self.given);
            }
            if !self.family.is_empty() {
                my_size += ::protobuf::rt::string_size(2, &self.family);
            }
            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.given.is_empty() {
                os.write_string(1, &self.given)?;
            }
            if !self.family.is_empty() {
                os.write_string(2, &self.family)?;
            }
            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() -> Name {
            Name::new()
        }

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

        fn default_instance() -> &'static Name {
            static instance: Name = Name {
                given: ::std::string::String::new(),
                family: ::std::string::String::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.Contact.IdentityState)
    pub enum IdentityState {
        // @@protoc_insertion_point(enum_value:signal.backup.Contact.IdentityState.DEFAULT)
        DEFAULT = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.Contact.IdentityState.VERIFIED)
        VERIFIED = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.Contact.IdentityState.UNVERIFIED)
        UNVERIFIED = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<IdentityState> {
            match value {
                0 => ::std::option::Option::Some(IdentityState::DEFAULT),
                1 => ::std::option::Option::Some(IdentityState::VERIFIED),
                2 => ::std::option::Option::Some(IdentityState::UNVERIFIED),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<IdentityState> {
            match str {
                "DEFAULT" => ::std::option::Option::Some(IdentityState::DEFAULT),
                "VERIFIED" => ::std::option::Option::Some(IdentityState::VERIFIED),
                "UNVERIFIED" => ::std::option::Option::Some(IdentityState::UNVERIFIED),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [IdentityState] = &[
            IdentityState::DEFAULT,
            IdentityState::VERIFIED,
            IdentityState::UNVERIFIED,
        ];
    }

    impl ::std::default::Default for IdentityState {
        fn default() -> Self {
            IdentityState::DEFAULT
        }
    }


    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.Contact.Visibility)
    pub enum Visibility {
        // @@protoc_insertion_point(enum_value:signal.backup.Contact.Visibility.VISIBLE)
        VISIBLE = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.Contact.Visibility.HIDDEN)
        HIDDEN = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.Contact.Visibility.HIDDEN_MESSAGE_REQUEST)
        HIDDEN_MESSAGE_REQUEST = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<Visibility> {
            match value {
                0 => ::std::option::Option::Some(Visibility::VISIBLE),
                1 => ::std::option::Option::Some(Visibility::HIDDEN),
                2 => ::std::option::Option::Some(Visibility::HIDDEN_MESSAGE_REQUEST),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Visibility> {
            match str {
                "VISIBLE" => ::std::option::Option::Some(Visibility::VISIBLE),
                "HIDDEN" => ::std::option::Option::Some(Visibility::HIDDEN),
                "HIDDEN_MESSAGE_REQUEST" => ::std::option::Option::Some(Visibility::HIDDEN_MESSAGE_REQUEST),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Visibility] = &[
            Visibility::VISIBLE,
            Visibility::HIDDEN,
            Visibility::HIDDEN_MESSAGE_REQUEST,
        ];
    }

    impl ::std::default::Default for Visibility {
        fn default() -> Self {
            Visibility::VISIBLE
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Group)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Group {
    // message fields
    #[field_name("masterKey")]
    // @@protoc_insertion_point(field:signal.backup.Group.masterKey)
    pub masterKey: ::std::vec::Vec<u8>,
    #[field_name("whitelisted")]
    // @@protoc_insertion_point(field:signal.backup.Group.whitelisted)
    pub whitelisted: bool,
    #[field_name("hideStory")]
    // @@protoc_insertion_point(field:signal.backup.Group.hideStory)
    pub hideStory: bool,
    #[field_name("storySendMode")]
    // @@protoc_insertion_point(field:signal.backup.Group.storySendMode)
    pub storySendMode: ::protobuf::EnumOrUnknown<group::StorySendMode>,
    #[field_name("snapshot")]
    // @@protoc_insertion_point(field:signal.backup.Group.snapshot)
    pub snapshot: ::protobuf::MessageField<group::GroupSnapshot>,
    #[field_name("blocked")]
    // @@protoc_insertion_point(field:signal.backup.Group.blocked)
    pub blocked: bool,
    #[field_name("avatarColor")]
    // @@protoc_insertion_point(field:signal.backup.Group.avatarColor)
    pub avatarColor: ::std::option::Option<::protobuf::EnumOrUnknown<AvatarColor>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Group.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.masterKey = is.read_bytes()?;
                },
                16 => {
                    self.whitelisted = is.read_bool()?;
                },
                24 => {
                    self.hideStory = is.read_bool()?;
                },
                32 => {
                    self.storySendMode = is.read_enum_or_unknown()?;
                },
                42 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.snapshot)?;
                },
                48 => {
                    self.blocked = is.read_bool()?;
                },
                56 => {
                    self.avatarColor = ::std::option::Option::Some(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.masterKey.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.masterKey);
        }
        if self.whitelisted != false {
            my_size += 1 + 1;
        }
        if self.hideStory != false {
            my_size += 1 + 1;
        }
        if self.storySendMode != ::protobuf::EnumOrUnknown::new(group::StorySendMode::DEFAULT) {
            my_size += ::protobuf::rt::int32_size(4, self.storySendMode.value());
        }
        if let Some(v) = self.snapshot.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.blocked != false {
            my_size += 1 + 1;
        }
        if let Some(v) = self.avatarColor {
            my_size += ::protobuf::rt::int32_size(7, v.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.masterKey.is_empty() {
            os.write_bytes(1, &self.masterKey)?;
        }
        if self.whitelisted != false {
            os.write_bool(2, self.whitelisted)?;
        }
        if self.hideStory != false {
            os.write_bool(3, self.hideStory)?;
        }
        if self.storySendMode != ::protobuf::EnumOrUnknown::new(group::StorySendMode::DEFAULT) {
            os.write_enum(4, ::protobuf::EnumOrUnknown::value(&self.storySendMode))?;
        }
        if let Some(v) = self.snapshot.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        if self.blocked != false {
            os.write_bool(6, self.blocked)?;
        }
        if let Some(v) = self.avatarColor {
            os.write_enum(7, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        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() -> Group {
        Group::new()
    }

    fn clear(&mut self) {
        self.masterKey.clear();
        self.whitelisted = false;
        self.hideStory = false;
        self.storySendMode = ::protobuf::EnumOrUnknown::new(group::StorySendMode::DEFAULT);
        self.snapshot.clear();
        self.blocked = false;
        self.avatarColor = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Group {
        static instance: Group = Group {
            masterKey: ::std::vec::Vec::new(),
            whitelisted: false,
            hideStory: false,
            storySendMode: ::protobuf::EnumOrUnknown::from_i32(0),
            snapshot: ::protobuf::MessageField::none(),
            blocked: false,
            avatarColor: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `Group`
pub mod group {
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Group.GroupSnapshot)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GroupSnapshot {
        // message fields
        #[field_name("title")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.title)
        pub title: ::protobuf::MessageField<GroupAttributeBlob>,
        #[field_name("description")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.description)
        pub description: ::protobuf::MessageField<GroupAttributeBlob>,
        #[field_name("avatarUrl")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.avatarUrl)
        pub avatarUrl: ::std::string::String,
        #[field_name("disappearingMessagesTimer")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.disappearingMessagesTimer)
        pub disappearingMessagesTimer: ::protobuf::MessageField<GroupAttributeBlob>,
        #[field_name("accessControl")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.accessControl)
        pub accessControl: ::protobuf::MessageField<AccessControl>,
        #[field_name("version")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.version)
        pub version: u32,
        #[field_name("members")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.members)
        pub members: ::std::vec::Vec<Member>,
        #[field_name("membersPendingProfileKey")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.membersPendingProfileKey)
        pub membersPendingProfileKey: ::std::vec::Vec<MemberPendingProfileKey>,
        #[field_name("membersPendingAdminApproval")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.membersPendingAdminApproval)
        pub membersPendingAdminApproval: ::std::vec::Vec<MemberPendingAdminApproval>,
        #[field_name("inviteLinkPassword")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.inviteLinkPassword)
        pub inviteLinkPassword: ::std::vec::Vec<u8>,
        #[field_name("announcementsOnly")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.announcementsOnly)
        pub announcementsOnly: bool,
        #[field_name("membersBanned")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.membersBanned)
        pub membersBanned: ::std::vec::Vec<MemberBanned>,
        #[field_name("terminated")]
        // @@protoc_insertion_point(field:signal.backup.Group.GroupSnapshot.terminated)
        pub terminated: bool,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Group.GroupSnapshot.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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 {
                    18 => {
                        ::protobuf::rt::read_singular_message_into_field(is, &mut self.title)?;
                    },
                    90 => {
                        ::protobuf::rt::read_singular_message_into_field(is, &mut self.description)?;
                    },
                    26 => {
                        self.avatarUrl = is.read_string()?;
                    },
                    34 => {
                        ::protobuf::rt::read_singular_message_into_field(is, &mut self.disappearingMessagesTimer)?;
                    },
                    42 => {
                        ::protobuf::rt::read_singular_message_into_field(is, &mut self.accessControl)?;
                    },
                    48 => {
                        self.version = is.read_uint32()?;
                    },
                    58 => {
                        self.members.push(is.read_message()?);
                    },
                    66 => {
                        self.membersPendingProfileKey.push(is.read_message()?);
                    },
                    74 => {
                        self.membersPendingAdminApproval.push(is.read_message()?);
                    },
                    82 => {
                        self.inviteLinkPassword = is.read_bytes()?;
                    },
                    96 => {
                        self.announcementsOnly = is.read_bool()?;
                    },
                    106 => {
                        self.membersBanned.push(is.read_message()?);
                    },
                    112 => {
                        self.terminated = is.read_bool()?;
                    },
                    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 Some(v) = self.title.as_ref() {
                let len = v.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            }
            if let Some(v) = self.description.as_ref() {
                let len = v.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            }
            if !self.avatarUrl.is_empty() {
                my_size += ::protobuf::rt::string_size(3, &self.avatarUrl);
            }
            if let Some(v) = self.disappearingMessagesTimer.as_ref() {
                let len = v.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            }
            if let Some(v) = self.accessControl.as_ref() {
                let len = v.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            }
            if self.version != 0 {
                my_size += ::protobuf::rt::uint32_size(6, self.version);
            }
            for value in &self.members {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            for value in &self.membersPendingProfileKey {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            for value in &self.membersPendingAdminApproval {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            if !self.inviteLinkPassword.is_empty() {
                my_size += ::protobuf::rt::bytes_size(10, &self.inviteLinkPassword);
            }
            if self.announcementsOnly != false {
                my_size += 1 + 1;
            }
            for value in &self.membersBanned {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            if self.terminated != false {
                my_size += 1 + 1;
            }
            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 Some(v) = self.title.as_ref() {
                ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
            }
            if let Some(v) = self.description.as_ref() {
                ::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
            }
            if !self.avatarUrl.is_empty() {
                os.write_string(3, &self.avatarUrl)?;
            }
            if let Some(v) = self.disappearingMessagesTimer.as_ref() {
                ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
            }
            if let Some(v) = self.accessControl.as_ref() {
                ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
            }
            if self.version != 0 {
                os.write_uint32(6, self.version)?;
            }
            for v in &self.members {
                ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
            };
            for v in &self.membersPendingProfileKey {
                ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
            };
            for v in &self.membersPendingAdminApproval {
                ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
            };
            if !self.inviteLinkPassword.is_empty() {
                os.write_bytes(10, &self.inviteLinkPassword)?;
            }
            if self.announcementsOnly != false {
                os.write_bool(12, self.announcementsOnly)?;
            }
            for v in &self.membersBanned {
                ::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
            };
            if self.terminated != false {
                os.write_bool(14, self.terminated)?;
            }
            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() -> GroupSnapshot {
            GroupSnapshot::new()
        }

        fn clear(&mut self) {
            self.title.clear();
            self.description.clear();
            self.avatarUrl.clear();
            self.disappearingMessagesTimer.clear();
            self.accessControl.clear();
            self.version = 0;
            self.members.clear();
            self.membersPendingProfileKey.clear();
            self.membersPendingAdminApproval.clear();
            self.inviteLinkPassword.clear();
            self.announcementsOnly = false;
            self.membersBanned.clear();
            self.terminated = false;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GroupSnapshot {
            static instance: GroupSnapshot = GroupSnapshot {
                title: ::protobuf::MessageField::none(),
                description: ::protobuf::MessageField::none(),
                avatarUrl: ::std::string::String::new(),
                disappearingMessagesTimer: ::protobuf::MessageField::none(),
                accessControl: ::protobuf::MessageField::none(),
                version: 0,
                members: ::std::vec::Vec::new(),
                membersPendingProfileKey: ::std::vec::Vec::new(),
                membersPendingAdminApproval: ::std::vec::Vec::new(),
                inviteLinkPassword: ::std::vec::Vec::new(),
                announcementsOnly: false,
                membersBanned: ::std::vec::Vec::new(),
                terminated: false,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Group.GroupAttributeBlob)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GroupAttributeBlob {
        // message oneof groups
        pub content: ::std::option::Option<group_attribute_blob::Content>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Group.GroupAttributeBlob.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        // string title = 1;

        pub fn title(&self) -> &str {
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::Title(ref v)) => v,
                _ => "",
            }
        }

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

        pub fn has_title(&self) -> bool {
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::Title(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_title(&mut self, v: ::std::string::String) {
            self.content = ::std::option::Option::Some(group_attribute_blob::Content::Title(v))
        }

        // Mutable pointer to the field.
        pub fn mut_title(&mut self) -> &mut ::std::string::String {
            if let ::std::option::Option::Some(group_attribute_blob::Content::Title(_)) = self.content {
            } else {
                self.content = ::std::option::Option::Some(group_attribute_blob::Content::Title(::std::string::String::new()));
            }
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::Title(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_title(&mut self) -> ::std::string::String {
            if self.has_title() {
                match self.content.take() {
                    ::std::option::Option::Some(group_attribute_blob::Content::Title(v)) => v,
                    _ => panic!(),
                }
            } else {
                ::std::string::String::new()
            }
        }

        // bytes avatar = 2;

        pub fn avatar(&self) -> &[u8] {
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::Avatar(ref v)) => v,
                _ => &[],
            }
        }

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

        pub fn has_avatar(&self) -> bool {
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::Avatar(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_avatar(&mut self, v: ::std::vec::Vec<u8>) {
            self.content = ::std::option::Option::Some(group_attribute_blob::Content::Avatar(v))
        }

        // Mutable pointer to the field.
        pub fn mut_avatar(&mut self) -> &mut ::std::vec::Vec<u8> {
            if let ::std::option::Option::Some(group_attribute_blob::Content::Avatar(_)) = self.content {
            } else {
                self.content = ::std::option::Option::Some(group_attribute_blob::Content::Avatar(::std::vec::Vec::new()));
            }
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::Avatar(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_avatar(&mut self) -> ::std::vec::Vec<u8> {
            if self.has_avatar() {
                match self.content.take() {
                    ::std::option::Option::Some(group_attribute_blob::Content::Avatar(v)) => v,
                    _ => panic!(),
                }
            } else {
                ::std::vec::Vec::new()
            }
        }

        // uint32 disappearingMessagesDuration = 3;

        pub fn disappearingMessagesDuration(&self) -> u32 {
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::DisappearingMessagesDuration(v)) => v,
                _ => 0,
            }
        }

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

        pub fn has_disappearingMessagesDuration(&self) -> bool {
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::DisappearingMessagesDuration(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_disappearingMessagesDuration(&mut self, v: u32) {
            self.content = ::std::option::Option::Some(group_attribute_blob::Content::DisappearingMessagesDuration(v))
        }

        // string descriptionText = 4;

        pub fn descriptionText(&self) -> &str {
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::DescriptionText(ref v)) => v,
                _ => "",
            }
        }

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

        pub fn has_descriptionText(&self) -> bool {
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::DescriptionText(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_descriptionText(&mut self, v: ::std::string::String) {
            self.content = ::std::option::Option::Some(group_attribute_blob::Content::DescriptionText(v))
        }

        // Mutable pointer to the field.
        pub fn mut_descriptionText(&mut self) -> &mut ::std::string::String {
            if let ::std::option::Option::Some(group_attribute_blob::Content::DescriptionText(_)) = self.content {
            } else {
                self.content = ::std::option::Option::Some(group_attribute_blob::Content::DescriptionText(::std::string::String::new()));
            }
            match self.content {
                ::std::option::Option::Some(group_attribute_blob::Content::DescriptionText(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_descriptionText(&mut self) -> ::std::string::String {
            if self.has_descriptionText() {
                match self.content.take() {
                    ::std::option::Option::Some(group_attribute_blob::Content::DescriptionText(v)) => v,
                    _ => panic!(),
                }
            } else {
                ::std::string::String::new()
            }
        }
    }

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

        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.content = ::std::option::Option::Some(group_attribute_blob::Content::Title(is.read_string()?));
                    },
                    18 => {
                        self.content = ::std::option::Option::Some(group_attribute_blob::Content::Avatar(is.read_bytes()?));
                    },
                    24 => {
                        self.content = ::std::option::Option::Some(group_attribute_blob::Content::DisappearingMessagesDuration(is.read_uint32()?));
                    },
                    34 => {
                        self.content = ::std::option::Option::Some(group_attribute_blob::Content::DescriptionText(is.read_string()?));
                    },
                    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.content {
                match v {
                    &group_attribute_blob::Content::Title(ref v) => {
                        my_size += ::protobuf::rt::string_size(1, &v);
                    },
                    &group_attribute_blob::Content::Avatar(ref v) => {
                        my_size += ::protobuf::rt::bytes_size(2, &v);
                    },
                    &group_attribute_blob::Content::DisappearingMessagesDuration(v) => {
                        my_size += ::protobuf::rt::uint32_size(3, v);
                    },
                    &group_attribute_blob::Content::DescriptionText(ref v) => {
                        my_size += ::protobuf::rt::string_size(4, &v);
                    },
                };
            }
            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.content {
                match v {
                    &group_attribute_blob::Content::Title(ref v) => {
                        os.write_string(1, v)?;
                    },
                    &group_attribute_blob::Content::Avatar(ref v) => {
                        os.write_bytes(2, v)?;
                    },
                    &group_attribute_blob::Content::DisappearingMessagesDuration(v) => {
                        os.write_uint32(3, v)?;
                    },
                    &group_attribute_blob::Content::DescriptionText(ref v) => {
                        os.write_string(4, v)?;
                    },
                };
            }
            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() -> GroupAttributeBlob {
            GroupAttributeBlob::new()
        }

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

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

    /// Nested message and enums of message `GroupAttributeBlob`
    pub mod group_attribute_blob {

        #[derive(Clone,PartialEq,Debug)]
        #[non_exhaustive]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(oneof:signal.backup.Group.GroupAttributeBlob.content)
        pub enum Content {
            // @@protoc_insertion_point(oneof_field:signal.backup.Group.GroupAttributeBlob.title)
            Title(::std::string::String),
            // @@protoc_insertion_point(oneof_field:signal.backup.Group.GroupAttributeBlob.avatar)
            Avatar(::std::vec::Vec<u8>),
            // @@protoc_insertion_point(oneof_field:signal.backup.Group.GroupAttributeBlob.disappearingMessagesDuration)
            DisappearingMessagesDuration(u32),
            // @@protoc_insertion_point(oneof_field:signal.backup.Group.GroupAttributeBlob.descriptionText)
            DescriptionText(::std::string::String),
        }

        impl ::protobuf::Oneof for Content {
        }

        impl Content {
        }
    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Group.Member)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Member {
        // message fields
        #[field_name("userId")]
        // @@protoc_insertion_point(field:signal.backup.Group.Member.userId)
        pub userId: ::std::vec::Vec<u8>,
        #[field_name("role")]
        // @@protoc_insertion_point(field:signal.backup.Group.Member.role)
        pub role: ::protobuf::EnumOrUnknown<member::Role>,
        #[field_name("joinedAtVersion")]
        // @@protoc_insertion_point(field:signal.backup.Group.Member.joinedAtVersion)
        pub joinedAtVersion: u32,
        #[field_name("labelEmoji")]
        // @@protoc_insertion_point(field:signal.backup.Group.Member.labelEmoji)
        pub labelEmoji: ::std::string::String,
        #[field_name("labelString")]
        // @@protoc_insertion_point(field:signal.backup.Group.Member.labelString)
        pub labelString: ::std::string::String,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Group.Member.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.userId = is.read_bytes()?;
                    },
                    16 => {
                        self.role = is.read_enum_or_unknown()?;
                    },
                    40 => {
                        self.joinedAtVersion = is.read_uint32()?;
                    },
                    50 => {
                        self.labelEmoji = is.read_string()?;
                    },
                    58 => {
                        self.labelString = is.read_string()?;
                    },
                    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.userId.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.userId);
            }
            if self.role != ::protobuf::EnumOrUnknown::new(member::Role::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(2, self.role.value());
            }
            if self.joinedAtVersion != 0 {
                my_size += ::protobuf::rt::uint32_size(5, self.joinedAtVersion);
            }
            if !self.labelEmoji.is_empty() {
                my_size += ::protobuf::rt::string_size(6, &self.labelEmoji);
            }
            if !self.labelString.is_empty() {
                my_size += ::protobuf::rt::string_size(7, &self.labelString);
            }
            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.userId.is_empty() {
                os.write_bytes(1, &self.userId)?;
            }
            if self.role != ::protobuf::EnumOrUnknown::new(member::Role::UNKNOWN) {
                os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.role))?;
            }
            if self.joinedAtVersion != 0 {
                os.write_uint32(5, self.joinedAtVersion)?;
            }
            if !self.labelEmoji.is_empty() {
                os.write_string(6, &self.labelEmoji)?;
            }
            if !self.labelString.is_empty() {
                os.write_string(7, &self.labelString)?;
            }
            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() -> Member {
            Member::new()
        }

        fn clear(&mut self) {
            self.userId.clear();
            self.role = ::protobuf::EnumOrUnknown::new(member::Role::UNKNOWN);
            self.joinedAtVersion = 0;
            self.labelEmoji.clear();
            self.labelString.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Member {
            static instance: Member = Member {
                userId: ::std::vec::Vec::new(),
                role: ::protobuf::EnumOrUnknown::from_i32(0),
                joinedAtVersion: 0,
                labelEmoji: ::std::string::String::new(),
                labelString: ::std::string::String::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `Member`
    pub mod member {
        #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(enum:signal.backup.Group.Member.Role)
        pub enum Role {
            // @@protoc_insertion_point(enum_value:signal.backup.Group.Member.Role.UNKNOWN)
            UNKNOWN = 0,
            // @@protoc_insertion_point(enum_value:signal.backup.Group.Member.Role.DEFAULT)
            DEFAULT = 1,
            // @@protoc_insertion_point(enum_value:signal.backup.Group.Member.Role.ADMINISTRATOR)
            ADMINISTRATOR = 2,
        }

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

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

            fn from_i32(value: i32) -> ::std::option::Option<Role> {
                match value {
                    0 => ::std::option::Option::Some(Role::UNKNOWN),
                    1 => ::std::option::Option::Some(Role::DEFAULT),
                    2 => ::std::option::Option::Some(Role::ADMINISTRATOR),
                    _ => ::std::option::Option::None
                }
            }

            fn from_str(str: &str) -> ::std::option::Option<Role> {
                match str {
                    "UNKNOWN" => ::std::option::Option::Some(Role::UNKNOWN),
                    "DEFAULT" => ::std::option::Option::Some(Role::DEFAULT),
                    "ADMINISTRATOR" => ::std::option::Option::Some(Role::ADMINISTRATOR),
                    _ => ::std::option::Option::None
                }
            }

            const VALUES: &'static [Role] = &[
                Role::UNKNOWN,
                Role::DEFAULT,
                Role::ADMINISTRATOR,
            ];
        }

        impl ::std::default::Default for Role {
            fn default() -> Self {
                Role::UNKNOWN
            }
        }

    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Group.MemberPendingProfileKey)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct MemberPendingProfileKey {
        // message fields
        #[field_name("member")]
        // @@protoc_insertion_point(field:signal.backup.Group.MemberPendingProfileKey.member)
        pub member: ::protobuf::MessageField<Member>,
        #[field_name("addedByUserId")]
        // @@protoc_insertion_point(field:signal.backup.Group.MemberPendingProfileKey.addedByUserId)
        pub addedByUserId: ::std::vec::Vec<u8>,
        #[field_name("timestamp")]
        // @@protoc_insertion_point(field:signal.backup.Group.MemberPendingProfileKey.timestamp)
        pub timestamp: u64,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Group.MemberPendingProfileKey.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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 => {
                        ::protobuf::rt::read_singular_message_into_field(is, &mut self.member)?;
                    },
                    18 => {
                        self.addedByUserId = is.read_bytes()?;
                    },
                    24 => {
                        self.timestamp = is.read_uint64()?;
                    },
                    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 Some(v) = self.member.as_ref() {
                let len = v.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            }
            if !self.addedByUserId.is_empty() {
                my_size += ::protobuf::rt::bytes_size(2, &self.addedByUserId);
            }
            if self.timestamp != 0 {
                my_size += ::protobuf::rt::uint64_size(3, self.timestamp);
            }
            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 Some(v) = self.member.as_ref() {
                ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
            }
            if !self.addedByUserId.is_empty() {
                os.write_bytes(2, &self.addedByUserId)?;
            }
            if self.timestamp != 0 {
                os.write_uint64(3, self.timestamp)?;
            }
            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() -> MemberPendingProfileKey {
            MemberPendingProfileKey::new()
        }

        fn clear(&mut self) {
            self.member.clear();
            self.addedByUserId.clear();
            self.timestamp = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static MemberPendingProfileKey {
            static instance: MemberPendingProfileKey = MemberPendingProfileKey {
                member: ::protobuf::MessageField::none(),
                addedByUserId: ::std::vec::Vec::new(),
                timestamp: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Group.MemberPendingAdminApproval)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct MemberPendingAdminApproval {
        // message fields
        #[field_name("userId")]
        // @@protoc_insertion_point(field:signal.backup.Group.MemberPendingAdminApproval.userId)
        pub userId: ::std::vec::Vec<u8>,
        #[field_name("timestamp")]
        // @@protoc_insertion_point(field:signal.backup.Group.MemberPendingAdminApproval.timestamp)
        pub timestamp: u64,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Group.MemberPendingAdminApproval.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.userId = is.read_bytes()?;
                    },
                    32 => {
                        self.timestamp = is.read_uint64()?;
                    },
                    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.userId.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.userId);
            }
            if self.timestamp != 0 {
                my_size += ::protobuf::rt::uint64_size(4, self.timestamp);
            }
            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.userId.is_empty() {
                os.write_bytes(1, &self.userId)?;
            }
            if self.timestamp != 0 {
                os.write_uint64(4, self.timestamp)?;
            }
            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() -> MemberPendingAdminApproval {
            MemberPendingAdminApproval::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Group.MemberBanned)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct MemberBanned {
        // message fields
        #[field_name("userId")]
        // @@protoc_insertion_point(field:signal.backup.Group.MemberBanned.userId)
        pub userId: ::std::vec::Vec<u8>,
        #[field_name("timestamp")]
        // @@protoc_insertion_point(field:signal.backup.Group.MemberBanned.timestamp)
        pub timestamp: u64,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Group.MemberBanned.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.userId = is.read_bytes()?;
                    },
                    16 => {
                        self.timestamp = is.read_uint64()?;
                    },
                    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.userId.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.userId);
            }
            if self.timestamp != 0 {
                my_size += ::protobuf::rt::uint64_size(2, self.timestamp);
            }
            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.userId.is_empty() {
                os.write_bytes(1, &self.userId)?;
            }
            if self.timestamp != 0 {
                os.write_uint64(2, self.timestamp)?;
            }
            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() -> MemberBanned {
            MemberBanned::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Group.AccessControl)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct AccessControl {
        // message fields
        #[field_name("attributes")]
        // @@protoc_insertion_point(field:signal.backup.Group.AccessControl.attributes)
        pub attributes: ::protobuf::EnumOrUnknown<access_control::AccessRequired>,
        #[field_name("members")]
        // @@protoc_insertion_point(field:signal.backup.Group.AccessControl.members)
        pub members: ::protobuf::EnumOrUnknown<access_control::AccessRequired>,
        #[field_name("addFromInviteLink")]
        // @@protoc_insertion_point(field:signal.backup.Group.AccessControl.addFromInviteLink)
        pub addFromInviteLink: ::protobuf::EnumOrUnknown<access_control::AccessRequired>,
        #[field_name("memberLabel")]
        // @@protoc_insertion_point(field:signal.backup.Group.AccessControl.memberLabel)
        pub memberLabel: ::protobuf::EnumOrUnknown<access_control::AccessRequired>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Group.AccessControl.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.attributes = is.read_enum_or_unknown()?;
                    },
                    16 => {
                        self.members = is.read_enum_or_unknown()?;
                    },
                    24 => {
                        self.addFromInviteLink = is.read_enum_or_unknown()?;
                    },
                    32 => {
                        self.memberLabel = 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.attributes != ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(1, self.attributes.value());
            }
            if self.members != ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(2, self.members.value());
            }
            if self.addFromInviteLink != ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(3, self.addFromInviteLink.value());
            }
            if self.memberLabel != ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(4, self.memberLabel.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.attributes != ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.attributes))?;
            }
            if self.members != ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN) {
                os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.members))?;
            }
            if self.addFromInviteLink != ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN) {
                os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.addFromInviteLink))?;
            }
            if self.memberLabel != ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN) {
                os.write_enum(4, ::protobuf::EnumOrUnknown::value(&self.memberLabel))?;
            }
            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() -> AccessControl {
            AccessControl::new()
        }

        fn clear(&mut self) {
            self.attributes = ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN);
            self.members = ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN);
            self.addFromInviteLink = ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN);
            self.memberLabel = ::protobuf::EnumOrUnknown::new(access_control::AccessRequired::UNKNOWN);
            self.special_fields.clear();
        }

        fn default_instance() -> &'static AccessControl {
            static instance: AccessControl = AccessControl {
                attributes: ::protobuf::EnumOrUnknown::from_i32(0),
                members: ::protobuf::EnumOrUnknown::from_i32(0),
                addFromInviteLink: ::protobuf::EnumOrUnknown::from_i32(0),
                memberLabel: ::protobuf::EnumOrUnknown::from_i32(0),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `AccessControl`
    pub mod access_control {
        #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(enum:signal.backup.Group.AccessControl.AccessRequired)
        pub enum AccessRequired {
            // @@protoc_insertion_point(enum_value:signal.backup.Group.AccessControl.AccessRequired.UNKNOWN)
            UNKNOWN = 0,
            // @@protoc_insertion_point(enum_value:signal.backup.Group.AccessControl.AccessRequired.ANY)
            ANY = 1,
            // @@protoc_insertion_point(enum_value:signal.backup.Group.AccessControl.AccessRequired.MEMBER)
            MEMBER = 2,
            // @@protoc_insertion_point(enum_value:signal.backup.Group.AccessControl.AccessRequired.ADMINISTRATOR)
            ADMINISTRATOR = 3,
            // @@protoc_insertion_point(enum_value:signal.backup.Group.AccessControl.AccessRequired.UNSATISFIABLE)
            UNSATISFIABLE = 4,
        }

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

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

            fn from_i32(value: i32) -> ::std::option::Option<AccessRequired> {
                match value {
                    0 => ::std::option::Option::Some(AccessRequired::UNKNOWN),
                    1 => ::std::option::Option::Some(AccessRequired::ANY),
                    2 => ::std::option::Option::Some(AccessRequired::MEMBER),
                    3 => ::std::option::Option::Some(AccessRequired::ADMINISTRATOR),
                    4 => ::std::option::Option::Some(AccessRequired::UNSATISFIABLE),
                    _ => ::std::option::Option::None
                }
            }

            fn from_str(str: &str) -> ::std::option::Option<AccessRequired> {
                match str {
                    "UNKNOWN" => ::std::option::Option::Some(AccessRequired::UNKNOWN),
                    "ANY" => ::std::option::Option::Some(AccessRequired::ANY),
                    "MEMBER" => ::std::option::Option::Some(AccessRequired::MEMBER),
                    "ADMINISTRATOR" => ::std::option::Option::Some(AccessRequired::ADMINISTRATOR),
                    "UNSATISFIABLE" => ::std::option::Option::Some(AccessRequired::UNSATISFIABLE),
                    _ => ::std::option::Option::None
                }
            }

            const VALUES: &'static [AccessRequired] = &[
                AccessRequired::UNKNOWN,
                AccessRequired::ANY,
                AccessRequired::MEMBER,
                AccessRequired::ADMINISTRATOR,
                AccessRequired::UNSATISFIABLE,
            ];
        }

        impl ::std::default::Default for AccessRequired {
            fn default() -> Self {
                AccessRequired::UNKNOWN
            }
        }

    }

    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.Group.StorySendMode)
    pub enum StorySendMode {
        // @@protoc_insertion_point(enum_value:signal.backup.Group.StorySendMode.DEFAULT)
        DEFAULT = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.Group.StorySendMode.DISABLED)
        DISABLED = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.Group.StorySendMode.ENABLED)
        ENABLED = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<StorySendMode> {
            match value {
                0 => ::std::option::Option::Some(StorySendMode::DEFAULT),
                1 => ::std::option::Option::Some(StorySendMode::DISABLED),
                2 => ::std::option::Option::Some(StorySendMode::ENABLED),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<StorySendMode> {
            match str {
                "DEFAULT" => ::std::option::Option::Some(StorySendMode::DEFAULT),
                "DISABLED" => ::std::option::Option::Some(StorySendMode::DISABLED),
                "ENABLED" => ::std::option::Option::Some(StorySendMode::ENABLED),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [StorySendMode] = &[
            StorySendMode::DEFAULT,
            StorySendMode::DISABLED,
            StorySendMode::ENABLED,
        ];
    }

    impl ::std::default::Default for StorySendMode {
        fn default() -> Self {
            StorySendMode::DEFAULT
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Self)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Self_ {
    // message fields
    #[field_name("avatarColor")]
    // @@protoc_insertion_point(field:signal.backup.Self.avatarColor)
    pub avatarColor: ::std::option::Option<::protobuf::EnumOrUnknown<AvatarColor>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Self.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.avatarColor = ::std::option::Option::Some(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 let Some(v) = self.avatarColor {
            my_size += ::protobuf::rt::int32_size(1, v.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 let Some(v) = self.avatarColor {
            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        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() -> Self_ {
        Self_::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ReleaseNotes)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ReleaseNotes {
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ReleaseNotes.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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() -> ReleaseNotes {
        ReleaseNotes::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Chat)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Chat {
    // message fields
    #[field_name("id")]
    // @@protoc_insertion_point(field:signal.backup.Chat.id)
    pub id: u64,
    #[field_name("recipientId")]
    // @@protoc_insertion_point(field:signal.backup.Chat.recipientId)
    pub recipientId: u64,
    #[field_name("archived")]
    // @@protoc_insertion_point(field:signal.backup.Chat.archived)
    pub archived: bool,
    #[field_name("pinnedOrder")]
    // @@protoc_insertion_point(field:signal.backup.Chat.pinnedOrder)
    pub pinnedOrder: ::std::option::Option<u32>,
    #[field_name("expirationTimerMs")]
    // @@protoc_insertion_point(field:signal.backup.Chat.expirationTimerMs)
    pub expirationTimerMs: ::std::option::Option<u64>,
    #[field_name("muteUntilMs")]
    // @@protoc_insertion_point(field:signal.backup.Chat.muteUntilMs)
    pub muteUntilMs: ::std::option::Option<u64>,
    #[field_name("markedUnread")]
    // @@protoc_insertion_point(field:signal.backup.Chat.markedUnread)
    pub markedUnread: bool,
    #[field_name("dontNotifyForMentionsIfMuted")]
    // @@protoc_insertion_point(field:signal.backup.Chat.dontNotifyForMentionsIfMuted)
    pub dontNotifyForMentionsIfMuted: bool,
    #[field_name("style")]
    // @@protoc_insertion_point(field:signal.backup.Chat.style)
    pub style: ::protobuf::MessageField<ChatStyle>,
    #[field_name("expireTimerVersion")]
    // @@protoc_insertion_point(field:signal.backup.Chat.expireTimerVersion)
    pub expireTimerVersion: u32,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Chat.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.id = is.read_uint64()?;
                },
                16 => {
                    self.recipientId = is.read_uint64()?;
                },
                24 => {
                    self.archived = is.read_bool()?;
                },
                32 => {
                    self.pinnedOrder = ::std::option::Option::Some(is.read_uint32()?);
                },
                40 => {
                    self.expirationTimerMs = ::std::option::Option::Some(is.read_uint64()?);
                },
                48 => {
                    self.muteUntilMs = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.markedUnread = is.read_bool()?;
                },
                64 => {
                    self.dontNotifyForMentionsIfMuted = is.read_bool()?;
                },
                74 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.style)?;
                },
                80 => {
                    self.expireTimerVersion = 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.id != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.id);
        }
        if self.recipientId != 0 {
            my_size += ::protobuf::rt::uint64_size(2, self.recipientId);
        }
        if self.archived != false {
            my_size += 1 + 1;
        }
        if let Some(v) = self.pinnedOrder {
            my_size += ::protobuf::rt::uint32_size(4, v);
        }
        if let Some(v) = self.expirationTimerMs {
            my_size += ::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.muteUntilMs {
            my_size += ::protobuf::rt::uint64_size(6, v);
        }
        if self.markedUnread != false {
            my_size += 1 + 1;
        }
        if self.dontNotifyForMentionsIfMuted != false {
            my_size += 1 + 1;
        }
        if let Some(v) = self.style.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.expireTimerVersion != 0 {
            my_size += ::protobuf::rt::uint32_size(10, self.expireTimerVersion);
        }
        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.id != 0 {
            os.write_uint64(1, self.id)?;
        }
        if self.recipientId != 0 {
            os.write_uint64(2, self.recipientId)?;
        }
        if self.archived != false {
            os.write_bool(3, self.archived)?;
        }
        if let Some(v) = self.pinnedOrder {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.expirationTimerMs {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.muteUntilMs {
            os.write_uint64(6, v)?;
        }
        if self.markedUnread != false {
            os.write_bool(7, self.markedUnread)?;
        }
        if self.dontNotifyForMentionsIfMuted != false {
            os.write_bool(8, self.dontNotifyForMentionsIfMuted)?;
        }
        if let Some(v) = self.style.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
        }
        if self.expireTimerVersion != 0 {
            os.write_uint32(10, self.expireTimerVersion)?;
        }
        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() -> Chat {
        Chat::new()
    }

    fn clear(&mut self) {
        self.id = 0;
        self.recipientId = 0;
        self.archived = false;
        self.pinnedOrder = ::std::option::Option::None;
        self.expirationTimerMs = ::std::option::Option::None;
        self.muteUntilMs = ::std::option::Option::None;
        self.markedUnread = false;
        self.dontNotifyForMentionsIfMuted = false;
        self.style.clear();
        self.expireTimerVersion = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Chat {
        static instance: Chat = Chat {
            id: 0,
            recipientId: 0,
            archived: false,
            pinnedOrder: ::std::option::Option::None,
            expirationTimerMs: ::std::option::Option::None,
            muteUntilMs: ::std::option::Option::None,
            markedUnread: false,
            dontNotifyForMentionsIfMuted: false,
            style: ::protobuf::MessageField::none(),
            expireTimerVersion: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.CallLink)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CallLink {
    // message fields
    #[field_name("rootKey")]
    // @@protoc_insertion_point(field:signal.backup.CallLink.rootKey)
    pub rootKey: ::std::vec::Vec<u8>,
    #[field_name("adminKey")]
    // @@protoc_insertion_point(field:signal.backup.CallLink.adminKey)
    pub adminKey: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("name")]
    // @@protoc_insertion_point(field:signal.backup.CallLink.name)
    pub name: ::std::string::String,
    #[field_name("restrictions")]
    // @@protoc_insertion_point(field:signal.backup.CallLink.restrictions)
    pub restrictions: ::protobuf::EnumOrUnknown<call_link::Restrictions>,
    #[field_name("expirationMs")]
    // @@protoc_insertion_point(field:signal.backup.CallLink.expirationMs)
    pub expirationMs: u64,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.CallLink.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.rootKey = is.read_bytes()?;
                },
                18 => {
                    self.adminKey = ::std::option::Option::Some(is.read_bytes()?);
                },
                26 => {
                    self.name = is.read_string()?;
                },
                32 => {
                    self.restrictions = is.read_enum_or_unknown()?;
                },
                40 => {
                    self.expirationMs = is.read_uint64()?;
                },
                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.rootKey.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.rootKey);
        }
        if let Some(v) = self.adminKey.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.name);
        }
        if self.restrictions != ::protobuf::EnumOrUnknown::new(call_link::Restrictions::UNKNOWN) {
            my_size += ::protobuf::rt::int32_size(4, self.restrictions.value());
        }
        if self.expirationMs != 0 {
            my_size += ::protobuf::rt::uint64_size(5, self.expirationMs);
        }
        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.rootKey.is_empty() {
            os.write_bytes(1, &self.rootKey)?;
        }
        if let Some(v) = self.adminKey.as_ref() {
            os.write_bytes(2, v)?;
        }
        if !self.name.is_empty() {
            os.write_string(3, &self.name)?;
        }
        if self.restrictions != ::protobuf::EnumOrUnknown::new(call_link::Restrictions::UNKNOWN) {
            os.write_enum(4, ::protobuf::EnumOrUnknown::value(&self.restrictions))?;
        }
        if self.expirationMs != 0 {
            os.write_uint64(5, self.expirationMs)?;
        }
        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() -> CallLink {
        CallLink::new()
    }

    fn clear(&mut self) {
        self.rootKey.clear();
        self.adminKey = ::std::option::Option::None;
        self.name.clear();
        self.restrictions = ::protobuf::EnumOrUnknown::new(call_link::Restrictions::UNKNOWN);
        self.expirationMs = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CallLink {
        static instance: CallLink = CallLink {
            rootKey: ::std::vec::Vec::new(),
            adminKey: ::std::option::Option::None,
            name: ::std::string::String::new(),
            restrictions: ::protobuf::EnumOrUnknown::from_i32(0),
            expirationMs: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `CallLink`
pub mod call_link {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.CallLink.Restrictions)
    pub enum Restrictions {
        // @@protoc_insertion_point(enum_value:signal.backup.CallLink.Restrictions.UNKNOWN)
        UNKNOWN = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.CallLink.Restrictions.NONE)
        NONE = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.CallLink.Restrictions.ADMIN_APPROVAL)
        ADMIN_APPROVAL = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<Restrictions> {
            match value {
                0 => ::std::option::Option::Some(Restrictions::UNKNOWN),
                1 => ::std::option::Option::Some(Restrictions::NONE),
                2 => ::std::option::Option::Some(Restrictions::ADMIN_APPROVAL),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Restrictions> {
            match str {
                "UNKNOWN" => ::std::option::Option::Some(Restrictions::UNKNOWN),
                "NONE" => ::std::option::Option::Some(Restrictions::NONE),
                "ADMIN_APPROVAL" => ::std::option::Option::Some(Restrictions::ADMIN_APPROVAL),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Restrictions] = &[
            Restrictions::UNKNOWN,
            Restrictions::NONE,
            Restrictions::ADMIN_APPROVAL,
        ];
    }

    impl ::std::default::Default for Restrictions {
        fn default() -> Self {
            Restrictions::UNKNOWN
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.AdHocCall)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AdHocCall {
    // message fields
    #[field_name("callId")]
    // @@protoc_insertion_point(field:signal.backup.AdHocCall.callId)
    pub callId: u64,
    #[field_name("recipientId")]
    // @@protoc_insertion_point(field:signal.backup.AdHocCall.recipientId)
    pub recipientId: u64,
    #[field_name("state")]
    // @@protoc_insertion_point(field:signal.backup.AdHocCall.state)
    pub state: ::protobuf::EnumOrUnknown<ad_hoc_call::State>,
    #[field_name("callTimestamp")]
    // @@protoc_insertion_point(field:signal.backup.AdHocCall.callTimestamp)
    pub callTimestamp: u64,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.AdHocCall.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.callId = is.read_uint64()?;
                },
                16 => {
                    self.recipientId = is.read_uint64()?;
                },
                24 => {
                    self.state = is.read_enum_or_unknown()?;
                },
                32 => {
                    self.callTimestamp = is.read_uint64()?;
                },
                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.callId != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.callId);
        }
        if self.recipientId != 0 {
            my_size += ::protobuf::rt::uint64_size(2, self.recipientId);
        }
        if self.state != ::protobuf::EnumOrUnknown::new(ad_hoc_call::State::UNKNOWN_STATE) {
            my_size += ::protobuf::rt::int32_size(3, self.state.value());
        }
        if self.callTimestamp != 0 {
            my_size += ::protobuf::rt::uint64_size(4, self.callTimestamp);
        }
        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.callId != 0 {
            os.write_uint64(1, self.callId)?;
        }
        if self.recipientId != 0 {
            os.write_uint64(2, self.recipientId)?;
        }
        if self.state != ::protobuf::EnumOrUnknown::new(ad_hoc_call::State::UNKNOWN_STATE) {
            os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.state))?;
        }
        if self.callTimestamp != 0 {
            os.write_uint64(4, self.callTimestamp)?;
        }
        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() -> AdHocCall {
        AdHocCall::new()
    }

    fn clear(&mut self) {
        self.callId = 0;
        self.recipientId = 0;
        self.state = ::protobuf::EnumOrUnknown::new(ad_hoc_call::State::UNKNOWN_STATE);
        self.callTimestamp = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static AdHocCall {
        static instance: AdHocCall = AdHocCall {
            callId: 0,
            recipientId: 0,
            state: ::protobuf::EnumOrUnknown::from_i32(0),
            callTimestamp: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `AdHocCall`
pub mod ad_hoc_call {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.AdHocCall.State)
    pub enum State {
        // @@protoc_insertion_point(enum_value:signal.backup.AdHocCall.State.UNKNOWN_STATE)
        UNKNOWN_STATE = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.AdHocCall.State.GENERIC)
        GENERIC = 1,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<State> {
            match value {
                0 => ::std::option::Option::Some(State::UNKNOWN_STATE),
                1 => ::std::option::Option::Some(State::GENERIC),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<State> {
            match str {
                "UNKNOWN_STATE" => ::std::option::Option::Some(State::UNKNOWN_STATE),
                "GENERIC" => ::std::option::Option::Some(State::GENERIC),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [State] = &[
            State::UNKNOWN_STATE,
            State::GENERIC,
        ];
    }

    impl ::std::default::Default for State {
        fn default() -> Self {
            State::UNKNOWN_STATE
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.DistributionListItem)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct DistributionListItem {
    // message fields
    #[field_name("distributionId")]
    // @@protoc_insertion_point(field:signal.backup.DistributionListItem.distributionId)
    pub distributionId: ::std::vec::Vec<u8>,
    // message oneof groups
    pub item: ::std::option::Option<distribution_list_item::Item>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.DistributionListItem.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // uint64 deletionTimestamp = 2;

    pub fn deletionTimestamp(&self) -> u64 {
        match self.item {
            ::std::option::Option::Some(distribution_list_item::Item::DeletionTimestamp(v)) => v,
            _ => 0,
        }
    }

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

    pub fn has_deletionTimestamp(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(distribution_list_item::Item::DeletionTimestamp(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_deletionTimestamp(&mut self, v: u64) {
        self.item = ::std::option::Option::Some(distribution_list_item::Item::DeletionTimestamp(v))
    }

    // .signal.backup.DistributionList distributionList = 3;

    pub fn distributionList(&self) -> &DistributionList {
        match self.item {
            ::std::option::Option::Some(distribution_list_item::Item::DistributionList(ref v)) => v,
            _ => <DistributionList as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_distributionList(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(distribution_list_item::Item::DistributionList(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_distributionList(&mut self, v: DistributionList) {
        self.item = ::std::option::Option::Some(distribution_list_item::Item::DistributionList(v))
    }

    // Mutable pointer to the field.
    pub fn mut_distributionList(&mut self) -> &mut DistributionList {
        if let ::std::option::Option::Some(distribution_list_item::Item::DistributionList(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(distribution_list_item::Item::DistributionList(DistributionList::new()));
        }
        match self.item {
            ::std::option::Option::Some(distribution_list_item::Item::DistributionList(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_distributionList(&mut self) -> DistributionList {
        if self.has_distributionList() {
            match self.item.take() {
                ::std::option::Option::Some(distribution_list_item::Item::DistributionList(v)) => v,
                _ => panic!(),
            }
        } else {
            DistributionList::new()
        }
    }
}

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

    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.distributionId = is.read_bytes()?;
                },
                16 => {
                    self.item = ::std::option::Option::Some(distribution_list_item::Item::DeletionTimestamp(is.read_uint64()?));
                },
                26 => {
                    self.item = ::std::option::Option::Some(distribution_list_item::Item::DistributionList(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 !self.distributionId.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.distributionId);
        }
        if let ::std::option::Option::Some(ref v) = self.item {
            match v {
                &distribution_list_item::Item::DeletionTimestamp(v) => {
                    my_size += ::protobuf::rt::uint64_size(2, v);
                },
                &distribution_list_item::Item::DistributionList(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 !self.distributionId.is_empty() {
            os.write_bytes(1, &self.distributionId)?;
        }
        if let ::std::option::Option::Some(ref v) = self.item {
            match v {
                &distribution_list_item::Item::DeletionTimestamp(v) => {
                    os.write_uint64(2, v)?;
                },
                &distribution_list_item::Item::DistributionList(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, 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() -> DistributionListItem {
        DistributionListItem::new()
    }

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

    fn default_instance() -> &'static DistributionListItem {
        static instance: DistributionListItem = DistributionListItem {
            distributionId: ::std::vec::Vec::new(),
            item: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `DistributionListItem`
pub mod distribution_list_item {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.DistributionListItem.item)
    pub enum Item {
        // @@protoc_insertion_point(oneof_field:signal.backup.DistributionListItem.deletionTimestamp)
        DeletionTimestamp(u64),
        // @@protoc_insertion_point(oneof_field:signal.backup.DistributionListItem.distributionList)
        DistributionList(super::DistributionList),
    }

    impl ::protobuf::Oneof for Item {
    }

    impl Item {
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.DistributionList)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct DistributionList {
    // message fields
    #[field_name("name")]
    // @@protoc_insertion_point(field:signal.backup.DistributionList.name)
    pub name: ::std::string::String,
    #[field_name("allowReplies")]
    // @@protoc_insertion_point(field:signal.backup.DistributionList.allowReplies)
    pub allowReplies: bool,
    #[field_name("privacyMode")]
    // @@protoc_insertion_point(field:signal.backup.DistributionList.privacyMode)
    pub privacyMode: ::protobuf::EnumOrUnknown<distribution_list::PrivacyMode>,
    #[field_name("memberRecipientIds")]
    // @@protoc_insertion_point(field:signal.backup.DistributionList.memberRecipientIds)
    pub memberRecipientIds: ::std::vec::Vec<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.DistributionList.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.name = is.read_string()?;
                },
                16 => {
                    self.allowReplies = is.read_bool()?;
                },
                24 => {
                    self.privacyMode = is.read_enum_or_unknown()?;
                },
                34 => {
                    is.read_repeated_packed_uint64_into(&mut self.memberRecipientIds)?;
                },
                32 => {
                    self.memberRecipientIds.push(is.read_uint64()?);
                },
                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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if self.allowReplies != false {
            my_size += 1 + 1;
        }
        if self.privacyMode != ::protobuf::EnumOrUnknown::new(distribution_list::PrivacyMode::UNKNOWN) {
            my_size += ::protobuf::rt::int32_size(3, self.privacyMode.value());
        }
        my_size += ::protobuf::rt::vec_packed_uint64_size(4, &self.memberRecipientIds);
        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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.allowReplies != false {
            os.write_bool(2, self.allowReplies)?;
        }
        if self.privacyMode != ::protobuf::EnumOrUnknown::new(distribution_list::PrivacyMode::UNKNOWN) {
            os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.privacyMode))?;
        }
        os.write_repeated_packed_uint64(4, &self.memberRecipientIds)?;
        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() -> DistributionList {
        DistributionList::new()
    }

    fn clear(&mut self) {
        self.name.clear();
        self.allowReplies = false;
        self.privacyMode = ::protobuf::EnumOrUnknown::new(distribution_list::PrivacyMode::UNKNOWN);
        self.memberRecipientIds.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static DistributionList {
        static instance: DistributionList = DistributionList {
            name: ::std::string::String::new(),
            allowReplies: false,
            privacyMode: ::protobuf::EnumOrUnknown::from_i32(0),
            memberRecipientIds: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `DistributionList`
pub mod distribution_list {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.DistributionList.PrivacyMode)
    pub enum PrivacyMode {
        // @@protoc_insertion_point(enum_value:signal.backup.DistributionList.PrivacyMode.UNKNOWN)
        UNKNOWN = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.DistributionList.PrivacyMode.ONLY_WITH)
        ONLY_WITH = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.DistributionList.PrivacyMode.ALL_EXCEPT)
        ALL_EXCEPT = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.DistributionList.PrivacyMode.ALL)
        ALL = 3,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<PrivacyMode> {
            match value {
                0 => ::std::option::Option::Some(PrivacyMode::UNKNOWN),
                1 => ::std::option::Option::Some(PrivacyMode::ONLY_WITH),
                2 => ::std::option::Option::Some(PrivacyMode::ALL_EXCEPT),
                3 => ::std::option::Option::Some(PrivacyMode::ALL),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<PrivacyMode> {
            match str {
                "UNKNOWN" => ::std::option::Option::Some(PrivacyMode::UNKNOWN),
                "ONLY_WITH" => ::std::option::Option::Some(PrivacyMode::ONLY_WITH),
                "ALL_EXCEPT" => ::std::option::Option::Some(PrivacyMode::ALL_EXCEPT),
                "ALL" => ::std::option::Option::Some(PrivacyMode::ALL),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [PrivacyMode] = &[
            PrivacyMode::UNKNOWN,
            PrivacyMode::ONLY_WITH,
            PrivacyMode::ALL_EXCEPT,
            PrivacyMode::ALL,
        ];
    }

    impl ::std::default::Default for PrivacyMode {
        fn default() -> Self {
            PrivacyMode::UNKNOWN
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ChatItem)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ChatItem {
    // message fields
    #[field_name("chatId")]
    // @@protoc_insertion_point(field:signal.backup.ChatItem.chatId)
    pub chatId: u64,
    #[field_name("authorId")]
    // @@protoc_insertion_point(field:signal.backup.ChatItem.authorId)
    pub authorId: u64,
    #[field_name("dateSent")]
    // @@protoc_insertion_point(field:signal.backup.ChatItem.dateSent)
    pub dateSent: u64,
    #[field_name("expireStartDate")]
    // @@protoc_insertion_point(field:signal.backup.ChatItem.expireStartDate)
    pub expireStartDate: ::std::option::Option<u64>,
    #[field_name("expiresInMs")]
    // @@protoc_insertion_point(field:signal.backup.ChatItem.expiresInMs)
    pub expiresInMs: ::std::option::Option<u64>,
    #[field_name("revisions")]
    // @@protoc_insertion_point(field:signal.backup.ChatItem.revisions)
    pub revisions: ::std::vec::Vec<ChatItem>,
    #[field_name("sms")]
    // @@protoc_insertion_point(field:signal.backup.ChatItem.sms)
    pub sms: bool,
    #[field_name("pinDetails")]
    // @@protoc_insertion_point(field:signal.backup.ChatItem.pinDetails)
    pub pinDetails: ::protobuf::MessageField<chat_item::PinDetails>,
    // message oneof groups
    pub directionalDetails: ::std::option::Option<chat_item::DirectionalDetails>,
    pub item: ::std::option::Option<chat_item::Item>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ChatItem.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .signal.backup.ChatItem.IncomingMessageDetails incoming = 8;

    pub fn incoming(&self) -> &chat_item::IncomingMessageDetails {
        match self.directionalDetails {
            ::std::option::Option::Some(chat_item::DirectionalDetails::Incoming(ref v)) => v,
            _ => <chat_item::IncomingMessageDetails as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_incoming(&self) -> bool {
        match self.directionalDetails {
            ::std::option::Option::Some(chat_item::DirectionalDetails::Incoming(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_incoming(&mut self, v: chat_item::IncomingMessageDetails) {
        self.directionalDetails = ::std::option::Option::Some(chat_item::DirectionalDetails::Incoming(v))
    }

    // Mutable pointer to the field.
    pub fn mut_incoming(&mut self) -> &mut chat_item::IncomingMessageDetails {
        if let ::std::option::Option::Some(chat_item::DirectionalDetails::Incoming(_)) = self.directionalDetails {
        } else {
            self.directionalDetails = ::std::option::Option::Some(chat_item::DirectionalDetails::Incoming(chat_item::IncomingMessageDetails::new()));
        }
        match self.directionalDetails {
            ::std::option::Option::Some(chat_item::DirectionalDetails::Incoming(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_incoming(&mut self) -> chat_item::IncomingMessageDetails {
        if self.has_incoming() {
            match self.directionalDetails.take() {
                ::std::option::Option::Some(chat_item::DirectionalDetails::Incoming(v)) => v,
                _ => panic!(),
            }
        } else {
            chat_item::IncomingMessageDetails::new()
        }
    }

    // .signal.backup.ChatItem.OutgoingMessageDetails outgoing = 9;

    pub fn outgoing(&self) -> &chat_item::OutgoingMessageDetails {
        match self.directionalDetails {
            ::std::option::Option::Some(chat_item::DirectionalDetails::Outgoing(ref v)) => v,
            _ => <chat_item::OutgoingMessageDetails as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_outgoing(&self) -> bool {
        match self.directionalDetails {
            ::std::option::Option::Some(chat_item::DirectionalDetails::Outgoing(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_outgoing(&mut self, v: chat_item::OutgoingMessageDetails) {
        self.directionalDetails = ::std::option::Option::Some(chat_item::DirectionalDetails::Outgoing(v))
    }

    // Mutable pointer to the field.
    pub fn mut_outgoing(&mut self) -> &mut chat_item::OutgoingMessageDetails {
        if let ::std::option::Option::Some(chat_item::DirectionalDetails::Outgoing(_)) = self.directionalDetails {
        } else {
            self.directionalDetails = ::std::option::Option::Some(chat_item::DirectionalDetails::Outgoing(chat_item::OutgoingMessageDetails::new()));
        }
        match self.directionalDetails {
            ::std::option::Option::Some(chat_item::DirectionalDetails::Outgoing(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_outgoing(&mut self) -> chat_item::OutgoingMessageDetails {
        if self.has_outgoing() {
            match self.directionalDetails.take() {
                ::std::option::Option::Some(chat_item::DirectionalDetails::Outgoing(v)) => v,
                _ => panic!(),
            }
        } else {
            chat_item::OutgoingMessageDetails::new()
        }
    }

    // .signal.backup.ChatItem.DirectionlessMessageDetails directionless = 10;

    pub fn directionless(&self) -> &chat_item::DirectionlessMessageDetails {
        match self.directionalDetails {
            ::std::option::Option::Some(chat_item::DirectionalDetails::Directionless(ref v)) => v,
            _ => <chat_item::DirectionlessMessageDetails as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_directionless(&self) -> bool {
        match self.directionalDetails {
            ::std::option::Option::Some(chat_item::DirectionalDetails::Directionless(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_directionless(&mut self, v: chat_item::DirectionlessMessageDetails) {
        self.directionalDetails = ::std::option::Option::Some(chat_item::DirectionalDetails::Directionless(v))
    }

    // Mutable pointer to the field.
    pub fn mut_directionless(&mut self) -> &mut chat_item::DirectionlessMessageDetails {
        if let ::std::option::Option::Some(chat_item::DirectionalDetails::Directionless(_)) = self.directionalDetails {
        } else {
            self.directionalDetails = ::std::option::Option::Some(chat_item::DirectionalDetails::Directionless(chat_item::DirectionlessMessageDetails::new()));
        }
        match self.directionalDetails {
            ::std::option::Option::Some(chat_item::DirectionalDetails::Directionless(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_directionless(&mut self) -> chat_item::DirectionlessMessageDetails {
        if self.has_directionless() {
            match self.directionalDetails.take() {
                ::std::option::Option::Some(chat_item::DirectionalDetails::Directionless(v)) => v,
                _ => panic!(),
            }
        } else {
            chat_item::DirectionlessMessageDetails::new()
        }
    }

    // .signal.backup.StandardMessage standardMessage = 11;

    pub fn standardMessage(&self) -> &StandardMessage {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::StandardMessage(ref v)) => v,
            _ => <StandardMessage as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_standardMessage(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::StandardMessage(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_standardMessage(&mut self, v: StandardMessage) {
        self.item = ::std::option::Option::Some(chat_item::Item::StandardMessage(v))
    }

    // Mutable pointer to the field.
    pub fn mut_standardMessage(&mut self) -> &mut StandardMessage {
        if let ::std::option::Option::Some(chat_item::Item::StandardMessage(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::StandardMessage(StandardMessage::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::StandardMessage(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_standardMessage(&mut self) -> StandardMessage {
        if self.has_standardMessage() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::StandardMessage(v)) => v,
                _ => panic!(),
            }
        } else {
            StandardMessage::new()
        }
    }

    // .signal.backup.ContactMessage contactMessage = 12;

    pub fn contactMessage(&self) -> &ContactMessage {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::ContactMessage(ref v)) => v,
            _ => <ContactMessage as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_contactMessage(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::ContactMessage(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_contactMessage(&mut self, v: ContactMessage) {
        self.item = ::std::option::Option::Some(chat_item::Item::ContactMessage(v))
    }

    // Mutable pointer to the field.
    pub fn mut_contactMessage(&mut self) -> &mut ContactMessage {
        if let ::std::option::Option::Some(chat_item::Item::ContactMessage(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::ContactMessage(ContactMessage::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::ContactMessage(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_contactMessage(&mut self) -> ContactMessage {
        if self.has_contactMessage() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::ContactMessage(v)) => v,
                _ => panic!(),
            }
        } else {
            ContactMessage::new()
        }
    }

    // .signal.backup.StickerMessage stickerMessage = 13;

    pub fn stickerMessage(&self) -> &StickerMessage {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::StickerMessage(ref v)) => v,
            _ => <StickerMessage as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_stickerMessage(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::StickerMessage(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_stickerMessage(&mut self, v: StickerMessage) {
        self.item = ::std::option::Option::Some(chat_item::Item::StickerMessage(v))
    }

    // Mutable pointer to the field.
    pub fn mut_stickerMessage(&mut self) -> &mut StickerMessage {
        if let ::std::option::Option::Some(chat_item::Item::StickerMessage(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::StickerMessage(StickerMessage::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::StickerMessage(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_stickerMessage(&mut self) -> StickerMessage {
        if self.has_stickerMessage() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::StickerMessage(v)) => v,
                _ => panic!(),
            }
        } else {
            StickerMessage::new()
        }
    }

    // .signal.backup.RemoteDeletedMessage remoteDeletedMessage = 14;

    pub fn remoteDeletedMessage(&self) -> &RemoteDeletedMessage {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::RemoteDeletedMessage(ref v)) => v,
            _ => <RemoteDeletedMessage as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_remoteDeletedMessage(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::RemoteDeletedMessage(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_remoteDeletedMessage(&mut self, v: RemoteDeletedMessage) {
        self.item = ::std::option::Option::Some(chat_item::Item::RemoteDeletedMessage(v))
    }

    // Mutable pointer to the field.
    pub fn mut_remoteDeletedMessage(&mut self) -> &mut RemoteDeletedMessage {
        if let ::std::option::Option::Some(chat_item::Item::RemoteDeletedMessage(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::RemoteDeletedMessage(RemoteDeletedMessage::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::RemoteDeletedMessage(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_remoteDeletedMessage(&mut self) -> RemoteDeletedMessage {
        if self.has_remoteDeletedMessage() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::RemoteDeletedMessage(v)) => v,
                _ => panic!(),
            }
        } else {
            RemoteDeletedMessage::new()
        }
    }

    // .signal.backup.ChatUpdateMessage updateMessage = 15;

    pub fn updateMessage(&self) -> &ChatUpdateMessage {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::UpdateMessage(ref v)) => v,
            _ => <ChatUpdateMessage as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_updateMessage(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::UpdateMessage(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_updateMessage(&mut self, v: ChatUpdateMessage) {
        self.item = ::std::option::Option::Some(chat_item::Item::UpdateMessage(v))
    }

    // Mutable pointer to the field.
    pub fn mut_updateMessage(&mut self) -> &mut ChatUpdateMessage {
        if let ::std::option::Option::Some(chat_item::Item::UpdateMessage(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::UpdateMessage(ChatUpdateMessage::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::UpdateMessage(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_updateMessage(&mut self) -> ChatUpdateMessage {
        if self.has_updateMessage() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::UpdateMessage(v)) => v,
                _ => panic!(),
            }
        } else {
            ChatUpdateMessage::new()
        }
    }

    // .signal.backup.PaymentNotification paymentNotification = 16;

    pub fn paymentNotification(&self) -> &PaymentNotification {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::PaymentNotification(ref v)) => v,
            _ => <PaymentNotification as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_paymentNotification(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::PaymentNotification(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_paymentNotification(&mut self, v: PaymentNotification) {
        self.item = ::std::option::Option::Some(chat_item::Item::PaymentNotification(v))
    }

    // Mutable pointer to the field.
    pub fn mut_paymentNotification(&mut self) -> &mut PaymentNotification {
        if let ::std::option::Option::Some(chat_item::Item::PaymentNotification(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::PaymentNotification(PaymentNotification::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::PaymentNotification(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_paymentNotification(&mut self) -> PaymentNotification {
        if self.has_paymentNotification() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::PaymentNotification(v)) => v,
                _ => panic!(),
            }
        } else {
            PaymentNotification::new()
        }
    }

    // .signal.backup.GiftBadge giftBadge = 17;

    pub fn giftBadge(&self) -> &GiftBadge {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::GiftBadge(ref v)) => v,
            _ => <GiftBadge as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_giftBadge(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::GiftBadge(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_giftBadge(&mut self, v: GiftBadge) {
        self.item = ::std::option::Option::Some(chat_item::Item::GiftBadge(v))
    }

    // Mutable pointer to the field.
    pub fn mut_giftBadge(&mut self) -> &mut GiftBadge {
        if let ::std::option::Option::Some(chat_item::Item::GiftBadge(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::GiftBadge(GiftBadge::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::GiftBadge(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_giftBadge(&mut self) -> GiftBadge {
        if self.has_giftBadge() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::GiftBadge(v)) => v,
                _ => panic!(),
            }
        } else {
            GiftBadge::new()
        }
    }

    // .signal.backup.ViewOnceMessage viewOnceMessage = 18;

    pub fn viewOnceMessage(&self) -> &ViewOnceMessage {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::ViewOnceMessage(ref v)) => v,
            _ => <ViewOnceMessage as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_viewOnceMessage(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::ViewOnceMessage(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_viewOnceMessage(&mut self, v: ViewOnceMessage) {
        self.item = ::std::option::Option::Some(chat_item::Item::ViewOnceMessage(v))
    }

    // Mutable pointer to the field.
    pub fn mut_viewOnceMessage(&mut self) -> &mut ViewOnceMessage {
        if let ::std::option::Option::Some(chat_item::Item::ViewOnceMessage(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::ViewOnceMessage(ViewOnceMessage::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::ViewOnceMessage(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_viewOnceMessage(&mut self) -> ViewOnceMessage {
        if self.has_viewOnceMessage() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::ViewOnceMessage(v)) => v,
                _ => panic!(),
            }
        } else {
            ViewOnceMessage::new()
        }
    }

    // .signal.backup.DirectStoryReplyMessage directStoryReplyMessage = 19;

    pub fn directStoryReplyMessage(&self) -> &DirectStoryReplyMessage {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::DirectStoryReplyMessage(ref v)) => v,
            _ => <DirectStoryReplyMessage as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_directStoryReplyMessage(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::DirectStoryReplyMessage(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_directStoryReplyMessage(&mut self, v: DirectStoryReplyMessage) {
        self.item = ::std::option::Option::Some(chat_item::Item::DirectStoryReplyMessage(v))
    }

    // Mutable pointer to the field.
    pub fn mut_directStoryReplyMessage(&mut self) -> &mut DirectStoryReplyMessage {
        if let ::std::option::Option::Some(chat_item::Item::DirectStoryReplyMessage(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::DirectStoryReplyMessage(DirectStoryReplyMessage::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::DirectStoryReplyMessage(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_directStoryReplyMessage(&mut self) -> DirectStoryReplyMessage {
        if self.has_directStoryReplyMessage() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::DirectStoryReplyMessage(v)) => v,
                _ => panic!(),
            }
        } else {
            DirectStoryReplyMessage::new()
        }
    }

    // .signal.backup.Poll poll = 20;

    pub fn poll(&self) -> &Poll {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::Poll(ref v)) => v,
            _ => <Poll as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_poll(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::Poll(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_poll(&mut self, v: Poll) {
        self.item = ::std::option::Option::Some(chat_item::Item::Poll(v))
    }

    // Mutable pointer to the field.
    pub fn mut_poll(&mut self) -> &mut Poll {
        if let ::std::option::Option::Some(chat_item::Item::Poll(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::Poll(Poll::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::Poll(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_poll(&mut self) -> Poll {
        if self.has_poll() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::Poll(v)) => v,
                _ => panic!(),
            }
        } else {
            Poll::new()
        }
    }

    // .signal.backup.AdminDeletedMessage adminDeletedMessage = 22;

    pub fn adminDeletedMessage(&self) -> &AdminDeletedMessage {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::AdminDeletedMessage(ref v)) => v,
            _ => <AdminDeletedMessage as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_adminDeletedMessage(&self) -> bool {
        match self.item {
            ::std::option::Option::Some(chat_item::Item::AdminDeletedMessage(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_adminDeletedMessage(&mut self, v: AdminDeletedMessage) {
        self.item = ::std::option::Option::Some(chat_item::Item::AdminDeletedMessage(v))
    }

    // Mutable pointer to the field.
    pub fn mut_adminDeletedMessage(&mut self) -> &mut AdminDeletedMessage {
        if let ::std::option::Option::Some(chat_item::Item::AdminDeletedMessage(_)) = self.item {
        } else {
            self.item = ::std::option::Option::Some(chat_item::Item::AdminDeletedMessage(AdminDeletedMessage::new()));
        }
        match self.item {
            ::std::option::Option::Some(chat_item::Item::AdminDeletedMessage(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_adminDeletedMessage(&mut self) -> AdminDeletedMessage {
        if self.has_adminDeletedMessage() {
            match self.item.take() {
                ::std::option::Option::Some(chat_item::Item::AdminDeletedMessage(v)) => v,
                _ => panic!(),
            }
        } else {
            AdminDeletedMessage::new()
        }
    }
}

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

    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.chatId = is.read_uint64()?;
                },
                16 => {
                    self.authorId = is.read_uint64()?;
                },
                24 => {
                    self.dateSent = is.read_uint64()?;
                },
                32 => {
                    self.expireStartDate = ::std::option::Option::Some(is.read_uint64()?);
                },
                40 => {
                    self.expiresInMs = ::std::option::Option::Some(is.read_uint64()?);
                },
                50 => {
                    self.revisions.push(is.read_message()?);
                },
                56 => {
                    self.sms = is.read_bool()?;
                },
                66 => {
                    self.directionalDetails = ::std::option::Option::Some(chat_item::DirectionalDetails::Incoming(is.read_message()?));
                },
                74 => {
                    self.directionalDetails = ::std::option::Option::Some(chat_item::DirectionalDetails::Outgoing(is.read_message()?));
                },
                82 => {
                    self.directionalDetails = ::std::option::Option::Some(chat_item::DirectionalDetails::Directionless(is.read_message()?));
                },
                90 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::StandardMessage(is.read_message()?));
                },
                98 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::ContactMessage(is.read_message()?));
                },
                106 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::StickerMessage(is.read_message()?));
                },
                114 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::RemoteDeletedMessage(is.read_message()?));
                },
                122 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::UpdateMessage(is.read_message()?));
                },
                130 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::PaymentNotification(is.read_message()?));
                },
                138 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::GiftBadge(is.read_message()?));
                },
                146 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::ViewOnceMessage(is.read_message()?));
                },
                154 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::DirectStoryReplyMessage(is.read_message()?));
                },
                162 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::Poll(is.read_message()?));
                },
                178 => {
                    self.item = ::std::option::Option::Some(chat_item::Item::AdminDeletedMessage(is.read_message()?));
                },
                170 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.pinDetails)?;
                },
                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.chatId != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.chatId);
        }
        if self.authorId != 0 {
            my_size += ::protobuf::rt::uint64_size(2, self.authorId);
        }
        if self.dateSent != 0 {
            my_size += ::protobuf::rt::uint64_size(3, self.dateSent);
        }
        if let Some(v) = self.expireStartDate {
            my_size += ::protobuf::rt::uint64_size(4, v);
        }
        if let Some(v) = self.expiresInMs {
            my_size += ::protobuf::rt::uint64_size(5, v);
        }
        for value in &self.revisions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if self.sms != false {
            my_size += 1 + 1;
        }
        if let Some(v) = self.pinDetails.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let ::std::option::Option::Some(ref v) = self.directionalDetails {
            match v {
                &chat_item::DirectionalDetails::Incoming(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::DirectionalDetails::Outgoing(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::DirectionalDetails::Directionless(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
            };
        }
        if let ::std::option::Option::Some(ref v) = self.item {
            match v {
                &chat_item::Item::StandardMessage(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::Item::ContactMessage(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::Item::StickerMessage(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::Item::RemoteDeletedMessage(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::Item::UpdateMessage(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::Item::PaymentNotification(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::Item::GiftBadge(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::Item::ViewOnceMessage(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::Item::DirectStoryReplyMessage(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::Item::Poll(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_item::Item::AdminDeletedMessage(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::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 self.chatId != 0 {
            os.write_uint64(1, self.chatId)?;
        }
        if self.authorId != 0 {
            os.write_uint64(2, self.authorId)?;
        }
        if self.dateSent != 0 {
            os.write_uint64(3, self.dateSent)?;
        }
        if let Some(v) = self.expireStartDate {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.expiresInMs {
            os.write_uint64(5, v)?;
        }
        for v in &self.revisions {
            ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        };
        if self.sms != false {
            os.write_bool(7, self.sms)?;
        }
        if let Some(v) = self.pinDetails.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(21, v, os)?;
        }
        if let ::std::option::Option::Some(ref v) = self.directionalDetails {
            match v {
                &chat_item::DirectionalDetails::Incoming(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
                },
                &chat_item::DirectionalDetails::Outgoing(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
                },
                &chat_item::DirectionalDetails::Directionless(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
                },
            };
        }
        if let ::std::option::Option::Some(ref v) = self.item {
            match v {
                &chat_item::Item::StandardMessage(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
                },
                &chat_item::Item::ContactMessage(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
                },
                &chat_item::Item::StickerMessage(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
                },
                &chat_item::Item::RemoteDeletedMessage(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
                },
                &chat_item::Item::UpdateMessage(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(15, v, os)?;
                },
                &chat_item::Item::PaymentNotification(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(16, v, os)?;
                },
                &chat_item::Item::GiftBadge(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(17, v, os)?;
                },
                &chat_item::Item::ViewOnceMessage(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(18, v, os)?;
                },
                &chat_item::Item::DirectStoryReplyMessage(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(19, v, os)?;
                },
                &chat_item::Item::Poll(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(20, v, os)?;
                },
                &chat_item::Item::AdminDeletedMessage(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(22, 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() -> ChatItem {
        ChatItem::new()
    }

    fn clear(&mut self) {
        self.chatId = 0;
        self.authorId = 0;
        self.dateSent = 0;
        self.expireStartDate = ::std::option::Option::None;
        self.expiresInMs = ::std::option::Option::None;
        self.revisions.clear();
        self.sms = false;
        self.directionalDetails = ::std::option::Option::None;
        self.directionalDetails = ::std::option::Option::None;
        self.directionalDetails = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.item = ::std::option::Option::None;
        self.pinDetails.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ChatItem {
        static instance: ChatItem = ChatItem {
            chatId: 0,
            authorId: 0,
            dateSent: 0,
            expireStartDate: ::std::option::Option::None,
            expiresInMs: ::std::option::Option::None,
            revisions: ::std::vec::Vec::new(),
            sms: false,
            pinDetails: ::protobuf::MessageField::none(),
            directionalDetails: ::std::option::Option::None,
            item: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `ChatItem`
pub mod chat_item {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.ChatItem.directionalDetails)
    pub enum DirectionalDetails {
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.incoming)
        Incoming(IncomingMessageDetails),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.outgoing)
        Outgoing(OutgoingMessageDetails),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.directionless)
        Directionless(DirectionlessMessageDetails),
    }

    impl ::protobuf::Oneof for DirectionalDetails {
    }

    impl DirectionalDetails {
    }

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.ChatItem.item)
    pub enum Item {
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.standardMessage)
        StandardMessage(super::StandardMessage),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.contactMessage)
        ContactMessage(super::ContactMessage),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.stickerMessage)
        StickerMessage(super::StickerMessage),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.remoteDeletedMessage)
        RemoteDeletedMessage(super::RemoteDeletedMessage),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.updateMessage)
        UpdateMessage(super::ChatUpdateMessage),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.paymentNotification)
        PaymentNotification(super::PaymentNotification),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.giftBadge)
        GiftBadge(super::GiftBadge),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.viewOnceMessage)
        ViewOnceMessage(super::ViewOnceMessage),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.directStoryReplyMessage)
        DirectStoryReplyMessage(super::DirectStoryReplyMessage),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.poll)
        Poll(super::Poll),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.adminDeletedMessage)
        AdminDeletedMessage(super::AdminDeletedMessage),
    }

    impl ::protobuf::Oneof for Item {
    }

    impl Item {
    }
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ChatItem.IncomingMessageDetails)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct IncomingMessageDetails {
        // message fields
        #[field_name("dateReceived")]
        // @@protoc_insertion_point(field:signal.backup.ChatItem.IncomingMessageDetails.dateReceived)
        pub dateReceived: u64,
        #[field_name("dateServerSent")]
        // @@protoc_insertion_point(field:signal.backup.ChatItem.IncomingMessageDetails.dateServerSent)
        pub dateServerSent: ::std::option::Option<u64>,
        #[field_name("read")]
        // @@protoc_insertion_point(field:signal.backup.ChatItem.IncomingMessageDetails.read)
        pub read: bool,
        #[field_name("sealedSender")]
        // @@protoc_insertion_point(field:signal.backup.ChatItem.IncomingMessageDetails.sealedSender)
        pub sealedSender: bool,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ChatItem.IncomingMessageDetails.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.dateReceived = is.read_uint64()?;
                    },
                    16 => {
                        self.dateServerSent = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    24 => {
                        self.read = is.read_bool()?;
                    },
                    32 => {
                        self.sealedSender = is.read_bool()?;
                    },
                    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.dateReceived != 0 {
                my_size += ::protobuf::rt::uint64_size(1, self.dateReceived);
            }
            if let Some(v) = self.dateServerSent {
                my_size += ::protobuf::rt::uint64_size(2, v);
            }
            if self.read != false {
                my_size += 1 + 1;
            }
            if self.sealedSender != false {
                my_size += 1 + 1;
            }
            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.dateReceived != 0 {
                os.write_uint64(1, self.dateReceived)?;
            }
            if let Some(v) = self.dateServerSent {
                os.write_uint64(2, v)?;
            }
            if self.read != false {
                os.write_bool(3, self.read)?;
            }
            if self.sealedSender != false {
                os.write_bool(4, self.sealedSender)?;
            }
            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() -> IncomingMessageDetails {
            IncomingMessageDetails::new()
        }

        fn clear(&mut self) {
            self.dateReceived = 0;
            self.dateServerSent = ::std::option::Option::None;
            self.read = false;
            self.sealedSender = false;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static IncomingMessageDetails {
            static instance: IncomingMessageDetails = IncomingMessageDetails {
                dateReceived: 0,
                dateServerSent: ::std::option::Option::None,
                read: false,
                sealedSender: false,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ChatItem.OutgoingMessageDetails)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct OutgoingMessageDetails {
        // message fields
        #[field_name("sendStatus")]
        // @@protoc_insertion_point(field:signal.backup.ChatItem.OutgoingMessageDetails.sendStatus)
        pub sendStatus: ::std::vec::Vec<super::SendStatus>,
        #[field_name("dateReceived")]
        // @@protoc_insertion_point(field:signal.backup.ChatItem.OutgoingMessageDetails.dateReceived)
        pub dateReceived: u64,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ChatItem.OutgoingMessageDetails.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.sendStatus.push(is.read_message()?);
                    },
                    16 => {
                        self.dateReceived = is.read_uint64()?;
                    },
                    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;
            for value in &self.sendStatus {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            if self.dateReceived != 0 {
                my_size += ::protobuf::rt::uint64_size(2, self.dateReceived);
            }
            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<()> {
            for v in &self.sendStatus {
                ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
            };
            if self.dateReceived != 0 {
                os.write_uint64(2, self.dateReceived)?;
            }
            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() -> OutgoingMessageDetails {
            OutgoingMessageDetails::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ChatItem.DirectionlessMessageDetails)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct DirectionlessMessageDetails {
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ChatItem.DirectionlessMessageDetails.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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() -> DirectionlessMessageDetails {
            DirectionlessMessageDetails::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ChatItem.PinDetails)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PinDetails {
        // message fields
        #[field_name("pinnedAtTimestamp")]
        // @@protoc_insertion_point(field:signal.backup.ChatItem.PinDetails.pinnedAtTimestamp)
        pub pinnedAtTimestamp: u64,
        // message oneof groups
        pub pinExpiry: ::std::option::Option<pin_details::PinExpiry>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ChatItem.PinDetails.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        // uint64 pinExpiresAtTimestamp = 2;

        pub fn pinExpiresAtTimestamp(&self) -> u64 {
            match self.pinExpiry {
                ::std::option::Option::Some(pin_details::PinExpiry::PinExpiresAtTimestamp(v)) => v,
                _ => 0,
            }
        }

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

        pub fn has_pinExpiresAtTimestamp(&self) -> bool {
            match self.pinExpiry {
                ::std::option::Option::Some(pin_details::PinExpiry::PinExpiresAtTimestamp(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_pinExpiresAtTimestamp(&mut self, v: u64) {
            self.pinExpiry = ::std::option::Option::Some(pin_details::PinExpiry::PinExpiresAtTimestamp(v))
        }

        // bool pinNeverExpires = 3;

        pub fn pinNeverExpires(&self) -> bool {
            match self.pinExpiry {
                ::std::option::Option::Some(pin_details::PinExpiry::PinNeverExpires(v)) => v,
                _ => false,
            }
        }

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

        pub fn has_pinNeverExpires(&self) -> bool {
            match self.pinExpiry {
                ::std::option::Option::Some(pin_details::PinExpiry::PinNeverExpires(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_pinNeverExpires(&mut self, v: bool) {
            self.pinExpiry = ::std::option::Option::Some(pin_details::PinExpiry::PinNeverExpires(v))
        }
    }

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

        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.pinnedAtTimestamp = is.read_uint64()?;
                    },
                    16 => {
                        self.pinExpiry = ::std::option::Option::Some(pin_details::PinExpiry::PinExpiresAtTimestamp(is.read_uint64()?));
                    },
                    24 => {
                        self.pinExpiry = ::std::option::Option::Some(pin_details::PinExpiry::PinNeverExpires(is.read_bool()?));
                    },
                    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.pinnedAtTimestamp != 0 {
                my_size += ::protobuf::rt::uint64_size(1, self.pinnedAtTimestamp);
            }
            if let ::std::option::Option::Some(ref v) = self.pinExpiry {
                match v {
                    &pin_details::PinExpiry::PinExpiresAtTimestamp(v) => {
                        my_size += ::protobuf::rt::uint64_size(2, v);
                    },
                    &pin_details::PinExpiry::PinNeverExpires(v) => {
                        my_size += 1 + 1;
                    },
                };
            }
            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.pinnedAtTimestamp != 0 {
                os.write_uint64(1, self.pinnedAtTimestamp)?;
            }
            if let ::std::option::Option::Some(ref v) = self.pinExpiry {
                match v {
                    &pin_details::PinExpiry::PinExpiresAtTimestamp(v) => {
                        os.write_uint64(2, v)?;
                    },
                    &pin_details::PinExpiry::PinNeverExpires(v) => {
                        os.write_bool(3, v)?;
                    },
                };
            }
            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() -> PinDetails {
            PinDetails::new()
        }

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

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

    /// Nested message and enums of message `PinDetails`
    pub mod pin_details {

        #[derive(Clone,PartialEq,Debug)]
        #[non_exhaustive]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(oneof:signal.backup.ChatItem.PinDetails.pinExpiry)
        pub enum PinExpiry {
            // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.PinDetails.pinExpiresAtTimestamp)
            PinExpiresAtTimestamp(u64),
            // @@protoc_insertion_point(oneof_field:signal.backup.ChatItem.PinDetails.pinNeverExpires)
            PinNeverExpires(bool),
        }

        impl ::protobuf::Oneof for PinExpiry {
        }

        impl PinExpiry {
        }
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.SendStatus)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SendStatus {
    // message fields
    #[field_name("recipientId")]
    // @@protoc_insertion_point(field:signal.backup.SendStatus.recipientId)
    pub recipientId: u64,
    #[field_name("timestamp")]
    // @@protoc_insertion_point(field:signal.backup.SendStatus.timestamp)
    pub timestamp: u64,
    // message oneof groups
    pub deliveryStatus: ::std::option::Option<send_status::DeliveryStatus>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.SendStatus.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .signal.backup.SendStatus.Pending pending = 3;

    pub fn pending(&self) -> &send_status::Pending {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Pending(ref v)) => v,
            _ => <send_status::Pending as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_pending(&self) -> bool {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Pending(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_pending(&mut self, v: send_status::Pending) {
        self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Pending(v))
    }

    // Mutable pointer to the field.
    pub fn mut_pending(&mut self) -> &mut send_status::Pending {
        if let ::std::option::Option::Some(send_status::DeliveryStatus::Pending(_)) = self.deliveryStatus {
        } else {
            self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Pending(send_status::Pending::new()));
        }
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Pending(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_pending(&mut self) -> send_status::Pending {
        if self.has_pending() {
            match self.deliveryStatus.take() {
                ::std::option::Option::Some(send_status::DeliveryStatus::Pending(v)) => v,
                _ => panic!(),
            }
        } else {
            send_status::Pending::new()
        }
    }

    // .signal.backup.SendStatus.Sent sent = 4;

    pub fn sent(&self) -> &send_status::Sent {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Sent(ref v)) => v,
            _ => <send_status::Sent as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_sent(&self) -> bool {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Sent(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_sent(&mut self, v: send_status::Sent) {
        self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Sent(v))
    }

    // Mutable pointer to the field.
    pub fn mut_sent(&mut self) -> &mut send_status::Sent {
        if let ::std::option::Option::Some(send_status::DeliveryStatus::Sent(_)) = self.deliveryStatus {
        } else {
            self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Sent(send_status::Sent::new()));
        }
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Sent(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_sent(&mut self) -> send_status::Sent {
        if self.has_sent() {
            match self.deliveryStatus.take() {
                ::std::option::Option::Some(send_status::DeliveryStatus::Sent(v)) => v,
                _ => panic!(),
            }
        } else {
            send_status::Sent::new()
        }
    }

    // .signal.backup.SendStatus.Delivered delivered = 5;

    pub fn delivered(&self) -> &send_status::Delivered {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Delivered(ref v)) => v,
            _ => <send_status::Delivered as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_delivered(&self) -> bool {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Delivered(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_delivered(&mut self, v: send_status::Delivered) {
        self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Delivered(v))
    }

    // Mutable pointer to the field.
    pub fn mut_delivered(&mut self) -> &mut send_status::Delivered {
        if let ::std::option::Option::Some(send_status::DeliveryStatus::Delivered(_)) = self.deliveryStatus {
        } else {
            self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Delivered(send_status::Delivered::new()));
        }
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Delivered(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_delivered(&mut self) -> send_status::Delivered {
        if self.has_delivered() {
            match self.deliveryStatus.take() {
                ::std::option::Option::Some(send_status::DeliveryStatus::Delivered(v)) => v,
                _ => panic!(),
            }
        } else {
            send_status::Delivered::new()
        }
    }

    // .signal.backup.SendStatus.Read read = 6;

    pub fn read(&self) -> &send_status::Read {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Read(ref v)) => v,
            _ => <send_status::Read as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_read(&self) -> bool {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Read(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_read(&mut self, v: send_status::Read) {
        self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Read(v))
    }

    // Mutable pointer to the field.
    pub fn mut_read(&mut self) -> &mut send_status::Read {
        if let ::std::option::Option::Some(send_status::DeliveryStatus::Read(_)) = self.deliveryStatus {
        } else {
            self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Read(send_status::Read::new()));
        }
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Read(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_read(&mut self) -> send_status::Read {
        if self.has_read() {
            match self.deliveryStatus.take() {
                ::std::option::Option::Some(send_status::DeliveryStatus::Read(v)) => v,
                _ => panic!(),
            }
        } else {
            send_status::Read::new()
        }
    }

    // .signal.backup.SendStatus.Viewed viewed = 7;

    pub fn viewed(&self) -> &send_status::Viewed {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Viewed(ref v)) => v,
            _ => <send_status::Viewed as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_viewed(&self) -> bool {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Viewed(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_viewed(&mut self, v: send_status::Viewed) {
        self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Viewed(v))
    }

    // Mutable pointer to the field.
    pub fn mut_viewed(&mut self) -> &mut send_status::Viewed {
        if let ::std::option::Option::Some(send_status::DeliveryStatus::Viewed(_)) = self.deliveryStatus {
        } else {
            self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Viewed(send_status::Viewed::new()));
        }
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Viewed(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_viewed(&mut self) -> send_status::Viewed {
        if self.has_viewed() {
            match self.deliveryStatus.take() {
                ::std::option::Option::Some(send_status::DeliveryStatus::Viewed(v)) => v,
                _ => panic!(),
            }
        } else {
            send_status::Viewed::new()
        }
    }

    // .signal.backup.SendStatus.Skipped skipped = 8;

    pub fn skipped(&self) -> &send_status::Skipped {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Skipped(ref v)) => v,
            _ => <send_status::Skipped as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_skipped(&self) -> bool {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Skipped(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_skipped(&mut self, v: send_status::Skipped) {
        self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Skipped(v))
    }

    // Mutable pointer to the field.
    pub fn mut_skipped(&mut self) -> &mut send_status::Skipped {
        if let ::std::option::Option::Some(send_status::DeliveryStatus::Skipped(_)) = self.deliveryStatus {
        } else {
            self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Skipped(send_status::Skipped::new()));
        }
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Skipped(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_skipped(&mut self) -> send_status::Skipped {
        if self.has_skipped() {
            match self.deliveryStatus.take() {
                ::std::option::Option::Some(send_status::DeliveryStatus::Skipped(v)) => v,
                _ => panic!(),
            }
        } else {
            send_status::Skipped::new()
        }
    }

    // .signal.backup.SendStatus.Failed failed = 9;

    pub fn failed(&self) -> &send_status::Failed {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Failed(ref v)) => v,
            _ => <send_status::Failed as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_failed(&self) -> bool {
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Failed(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_failed(&mut self, v: send_status::Failed) {
        self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Failed(v))
    }

    // Mutable pointer to the field.
    pub fn mut_failed(&mut self) -> &mut send_status::Failed {
        if let ::std::option::Option::Some(send_status::DeliveryStatus::Failed(_)) = self.deliveryStatus {
        } else {
            self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Failed(send_status::Failed::new()));
        }
        match self.deliveryStatus {
            ::std::option::Option::Some(send_status::DeliveryStatus::Failed(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_failed(&mut self) -> send_status::Failed {
        if self.has_failed() {
            match self.deliveryStatus.take() {
                ::std::option::Option::Some(send_status::DeliveryStatus::Failed(v)) => v,
                _ => panic!(),
            }
        } else {
            send_status::Failed::new()
        }
    }
}

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

    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.recipientId = is.read_uint64()?;
                },
                16 => {
                    self.timestamp = is.read_uint64()?;
                },
                26 => {
                    self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Pending(is.read_message()?));
                },
                34 => {
                    self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Sent(is.read_message()?));
                },
                42 => {
                    self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Delivered(is.read_message()?));
                },
                50 => {
                    self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Read(is.read_message()?));
                },
                58 => {
                    self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Viewed(is.read_message()?));
                },
                66 => {
                    self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Skipped(is.read_message()?));
                },
                74 => {
                    self.deliveryStatus = ::std::option::Option::Some(send_status::DeliveryStatus::Failed(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 self.recipientId != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.recipientId);
        }
        if self.timestamp != 0 {
            my_size += ::protobuf::rt::uint64_size(2, self.timestamp);
        }
        if let ::std::option::Option::Some(ref v) = self.deliveryStatus {
            match v {
                &send_status::DeliveryStatus::Pending(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &send_status::DeliveryStatus::Sent(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &send_status::DeliveryStatus::Delivered(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &send_status::DeliveryStatus::Read(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &send_status::DeliveryStatus::Viewed(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &send_status::DeliveryStatus::Skipped(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &send_status::DeliveryStatus::Failed(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 self.recipientId != 0 {
            os.write_uint64(1, self.recipientId)?;
        }
        if self.timestamp != 0 {
            os.write_uint64(2, self.timestamp)?;
        }
        if let ::std::option::Option::Some(ref v) = self.deliveryStatus {
            match v {
                &send_status::DeliveryStatus::Pending(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &send_status::DeliveryStatus::Sent(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &send_status::DeliveryStatus::Delivered(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &send_status::DeliveryStatus::Read(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &send_status::DeliveryStatus::Viewed(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
                &send_status::DeliveryStatus::Skipped(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
                },
                &send_status::DeliveryStatus::Failed(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(9, 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() -> SendStatus {
        SendStatus::new()
    }

    fn clear(&mut self) {
        self.recipientId = 0;
        self.timestamp = 0;
        self.deliveryStatus = ::std::option::Option::None;
        self.deliveryStatus = ::std::option::Option::None;
        self.deliveryStatus = ::std::option::Option::None;
        self.deliveryStatus = ::std::option::Option::None;
        self.deliveryStatus = ::std::option::Option::None;
        self.deliveryStatus = ::std::option::Option::None;
        self.deliveryStatus = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static SendStatus {
        static instance: SendStatus = SendStatus {
            recipientId: 0,
            timestamp: 0,
            deliveryStatus: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `SendStatus`
pub mod send_status {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.SendStatus.deliveryStatus)
    pub enum DeliveryStatus {
        // @@protoc_insertion_point(oneof_field:signal.backup.SendStatus.pending)
        Pending(Pending),
        // @@protoc_insertion_point(oneof_field:signal.backup.SendStatus.sent)
        Sent(Sent),
        // @@protoc_insertion_point(oneof_field:signal.backup.SendStatus.delivered)
        Delivered(Delivered),
        // @@protoc_insertion_point(oneof_field:signal.backup.SendStatus.read)
        Read(Read),
        // @@protoc_insertion_point(oneof_field:signal.backup.SendStatus.viewed)
        Viewed(Viewed),
        // @@protoc_insertion_point(oneof_field:signal.backup.SendStatus.skipped)
        Skipped(Skipped),
        // @@protoc_insertion_point(oneof_field:signal.backup.SendStatus.failed)
        Failed(Failed),
    }

    impl ::protobuf::Oneof for DeliveryStatus {
    }

    impl DeliveryStatus {
    }
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.SendStatus.Pending)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Pending {
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.SendStatus.Pending.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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() -> Pending {
            Pending::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.SendStatus.Sent)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Sent {
        // message fields
        #[field_name("sealedSender")]
        // @@protoc_insertion_point(field:signal.backup.SendStatus.Sent.sealedSender)
        pub sealedSender: bool,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.SendStatus.Sent.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.sealedSender = is.read_bool()?;
                    },
                    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.sealedSender != false {
                my_size += 1 + 1;
            }
            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.sealedSender != false {
                os.write_bool(1, self.sealedSender)?;
            }
            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() -> Sent {
            Sent::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.SendStatus.Delivered)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Delivered {
        // message fields
        #[field_name("sealedSender")]
        // @@protoc_insertion_point(field:signal.backup.SendStatus.Delivered.sealedSender)
        pub sealedSender: bool,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.SendStatus.Delivered.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.sealedSender = is.read_bool()?;
                    },
                    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.sealedSender != false {
                my_size += 1 + 1;
            }
            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.sealedSender != false {
                os.write_bool(1, self.sealedSender)?;
            }
            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() -> Delivered {
            Delivered::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.SendStatus.Read)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Read {
        // message fields
        #[field_name("sealedSender")]
        // @@protoc_insertion_point(field:signal.backup.SendStatus.Read.sealedSender)
        pub sealedSender: bool,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.SendStatus.Read.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.sealedSender = is.read_bool()?;
                    },
                    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.sealedSender != false {
                my_size += 1 + 1;
            }
            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.sealedSender != false {
                os.write_bool(1, self.sealedSender)?;
            }
            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() -> Read {
            Read::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.SendStatus.Viewed)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Viewed {
        // message fields
        #[field_name("sealedSender")]
        // @@protoc_insertion_point(field:signal.backup.SendStatus.Viewed.sealedSender)
        pub sealedSender: bool,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.SendStatus.Viewed.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.sealedSender = is.read_bool()?;
                    },
                    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.sealedSender != false {
                my_size += 1 + 1;
            }
            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.sealedSender != false {
                os.write_bool(1, self.sealedSender)?;
            }
            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() -> Viewed {
            Viewed::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.SendStatus.Skipped)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Skipped {
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.SendStatus.Skipped.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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() -> Skipped {
            Skipped::new()
        }

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

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

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.SendStatus.Failed)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Failed {
        // message fields
        #[field_name("reason")]
        // @@protoc_insertion_point(field:signal.backup.SendStatus.Failed.reason)
        pub reason: ::protobuf::EnumOrUnknown<failed::FailureReason>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.SendStatus.Failed.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.reason = 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.reason != ::protobuf::EnumOrUnknown::new(failed::FailureReason::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(1, self.reason.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.reason != ::protobuf::EnumOrUnknown::new(failed::FailureReason::UNKNOWN) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.reason))?;
            }
            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() -> Failed {
            Failed::new()
        }

        fn clear(&mut self) {
            self.reason = ::protobuf::EnumOrUnknown::new(failed::FailureReason::UNKNOWN);
            self.special_fields.clear();
        }

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

    /// Nested message and enums of message `Failed`
    pub mod failed {
        #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(enum:signal.backup.SendStatus.Failed.FailureReason)
        pub enum FailureReason {
            // @@protoc_insertion_point(enum_value:signal.backup.SendStatus.Failed.FailureReason.UNKNOWN)
            UNKNOWN = 0,
            // @@protoc_insertion_point(enum_value:signal.backup.SendStatus.Failed.FailureReason.NETWORK)
            NETWORK = 1,
            // @@protoc_insertion_point(enum_value:signal.backup.SendStatus.Failed.FailureReason.IDENTITY_KEY_MISMATCH)
            IDENTITY_KEY_MISMATCH = 2,
        }

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

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

            fn from_i32(value: i32) -> ::std::option::Option<FailureReason> {
                match value {
                    0 => ::std::option::Option::Some(FailureReason::UNKNOWN),
                    1 => ::std::option::Option::Some(FailureReason::NETWORK),
                    2 => ::std::option::Option::Some(FailureReason::IDENTITY_KEY_MISMATCH),
                    _ => ::std::option::Option::None
                }
            }

            fn from_str(str: &str) -> ::std::option::Option<FailureReason> {
                match str {
                    "UNKNOWN" => ::std::option::Option::Some(FailureReason::UNKNOWN),
                    "NETWORK" => ::std::option::Option::Some(FailureReason::NETWORK),
                    "IDENTITY_KEY_MISMATCH" => ::std::option::Option::Some(FailureReason::IDENTITY_KEY_MISMATCH),
                    _ => ::std::option::Option::None
                }
            }

            const VALUES: &'static [FailureReason] = &[
                FailureReason::UNKNOWN,
                FailureReason::NETWORK,
                FailureReason::IDENTITY_KEY_MISMATCH,
            ];
        }

        impl ::std::default::Default for FailureReason {
            fn default() -> Self {
                FailureReason::UNKNOWN
            }
        }

    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Text)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Text {
    // message fields
    #[field_name("body")]
    // @@protoc_insertion_point(field:signal.backup.Text.body)
    pub body: ::std::string::String,
    #[field_name("bodyRanges")]
    // @@protoc_insertion_point(field:signal.backup.Text.bodyRanges)
    pub bodyRanges: ::std::vec::Vec<BodyRange>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Text.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.body = is.read_string()?;
                },
                18 => {
                    self.bodyRanges.push(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 !self.body.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.body);
        }
        for value in &self.bodyRanges {
            let len = value.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 !self.body.is_empty() {
            os.write_string(1, &self.body)?;
        }
        for v in &self.bodyRanges {
            ::protobuf::rt::write_message_field_with_cached_size(2, 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() -> Text {
        Text::new()
    }

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

    fn default_instance() -> &'static Text {
        static instance: Text = Text {
            body: ::std::string::String::new(),
            bodyRanges: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.StandardMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct StandardMessage {
    // message fields
    #[field_name("quote")]
    // @@protoc_insertion_point(field:signal.backup.StandardMessage.quote)
    pub quote: ::protobuf::MessageField<Quote>,
    #[field_name("text")]
    // @@protoc_insertion_point(field:signal.backup.StandardMessage.text)
    pub text: ::protobuf::MessageField<Text>,
    #[field_name("attachments")]
    // @@protoc_insertion_point(field:signal.backup.StandardMessage.attachments)
    pub attachments: ::std::vec::Vec<MessageAttachment>,
    #[field_name("linkPreview")]
    // @@protoc_insertion_point(field:signal.backup.StandardMessage.linkPreview)
    pub linkPreview: ::std::vec::Vec<LinkPreview>,
    #[field_name("longText")]
    // @@protoc_insertion_point(field:signal.backup.StandardMessage.longText)
    pub longText: ::protobuf::MessageField<FilePointer>,
    #[field_name("reactions")]
    // @@protoc_insertion_point(field:signal.backup.StandardMessage.reactions)
    pub reactions: ::std::vec::Vec<Reaction>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.StandardMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.quote)?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.text)?;
                },
                26 => {
                    self.attachments.push(is.read_message()?);
                },
                34 => {
                    self.linkPreview.push(is.read_message()?);
                },
                42 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.longText)?;
                },
                50 => {
                    self.reactions.push(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 Some(v) = self.quote.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.text.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.attachments {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.linkPreview {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.longText.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.reactions {
            let len = value.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 Some(v) = self.quote.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.text.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        for v in &self.attachments {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        for v in &self.linkPreview {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        if let Some(v) = self.longText.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        for v in &self.reactions {
            ::protobuf::rt::write_message_field_with_cached_size(6, 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() -> StandardMessage {
        StandardMessage::new()
    }

    fn clear(&mut self) {
        self.quote.clear();
        self.text.clear();
        self.attachments.clear();
        self.linkPreview.clear();
        self.longText.clear();
        self.reactions.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static StandardMessage {
        static instance: StandardMessage = StandardMessage {
            quote: ::protobuf::MessageField::none(),
            text: ::protobuf::MessageField::none(),
            attachments: ::std::vec::Vec::new(),
            linkPreview: ::std::vec::Vec::new(),
            longText: ::protobuf::MessageField::none(),
            reactions: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ContactMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ContactMessage {
    // message fields
    #[field_name("contact")]
    // @@protoc_insertion_point(field:signal.backup.ContactMessage.contact)
    pub contact: ::protobuf::MessageField<ContactAttachment>,
    #[field_name("reactions")]
    // @@protoc_insertion_point(field:signal.backup.ContactMessage.reactions)
    pub reactions: ::std::vec::Vec<Reaction>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ContactMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.contact)?;
                },
                18 => {
                    self.reactions.push(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 Some(v) = self.contact.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.reactions {
            let len = value.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 Some(v) = self.contact.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.reactions {
            ::protobuf::rt::write_message_field_with_cached_size(2, 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() -> ContactMessage {
        ContactMessage::new()
    }

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

    fn default_instance() -> &'static ContactMessage {
        static instance: ContactMessage = ContactMessage {
            contact: ::protobuf::MessageField::none(),
            reactions: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.DirectStoryReplyMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct DirectStoryReplyMessage {
    // message fields
    #[field_name("reactions")]
    // @@protoc_insertion_point(field:signal.backup.DirectStoryReplyMessage.reactions)
    pub reactions: ::std::vec::Vec<Reaction>,
    // message oneof groups
    pub reply: ::std::option::Option<direct_story_reply_message::Reply>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.DirectStoryReplyMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .signal.backup.DirectStoryReplyMessage.TextReply textReply = 1;

    pub fn textReply(&self) -> &direct_story_reply_message::TextReply {
        match self.reply {
            ::std::option::Option::Some(direct_story_reply_message::Reply::TextReply(ref v)) => v,
            _ => <direct_story_reply_message::TextReply as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_textReply(&self) -> bool {
        match self.reply {
            ::std::option::Option::Some(direct_story_reply_message::Reply::TextReply(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_textReply(&mut self, v: direct_story_reply_message::TextReply) {
        self.reply = ::std::option::Option::Some(direct_story_reply_message::Reply::TextReply(v))
    }

    // Mutable pointer to the field.
    pub fn mut_textReply(&mut self) -> &mut direct_story_reply_message::TextReply {
        if let ::std::option::Option::Some(direct_story_reply_message::Reply::TextReply(_)) = self.reply {
        } else {
            self.reply = ::std::option::Option::Some(direct_story_reply_message::Reply::TextReply(direct_story_reply_message::TextReply::new()));
        }
        match self.reply {
            ::std::option::Option::Some(direct_story_reply_message::Reply::TextReply(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_textReply(&mut self) -> direct_story_reply_message::TextReply {
        if self.has_textReply() {
            match self.reply.take() {
                ::std::option::Option::Some(direct_story_reply_message::Reply::TextReply(v)) => v,
                _ => panic!(),
            }
        } else {
            direct_story_reply_message::TextReply::new()
        }
    }

    // string emoji = 2;

    pub fn emoji(&self) -> &str {
        match self.reply {
            ::std::option::Option::Some(direct_story_reply_message::Reply::Emoji(ref v)) => v,
            _ => "",
        }
    }

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

    pub fn has_emoji(&self) -> bool {
        match self.reply {
            ::std::option::Option::Some(direct_story_reply_message::Reply::Emoji(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_emoji(&mut self, v: ::std::string::String) {
        self.reply = ::std::option::Option::Some(direct_story_reply_message::Reply::Emoji(v))
    }

    // Mutable pointer to the field.
    pub fn mut_emoji(&mut self) -> &mut ::std::string::String {
        if let ::std::option::Option::Some(direct_story_reply_message::Reply::Emoji(_)) = self.reply {
        } else {
            self.reply = ::std::option::Option::Some(direct_story_reply_message::Reply::Emoji(::std::string::String::new()));
        }
        match self.reply {
            ::std::option::Option::Some(direct_story_reply_message::Reply::Emoji(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_emoji(&mut self) -> ::std::string::String {
        if self.has_emoji() {
            match self.reply.take() {
                ::std::option::Option::Some(direct_story_reply_message::Reply::Emoji(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }
}

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

    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.reply = ::std::option::Option::Some(direct_story_reply_message::Reply::TextReply(is.read_message()?));
                },
                18 => {
                    self.reply = ::std::option::Option::Some(direct_story_reply_message::Reply::Emoji(is.read_string()?));
                },
                26 => {
                    self.reactions.push(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;
        for value in &self.reactions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let ::std::option::Option::Some(ref v) = self.reply {
            match v {
                &direct_story_reply_message::Reply::TextReply(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &direct_story_reply_message::Reply::Emoji(ref v) => {
                    my_size += ::protobuf::rt::string_size(2, &v);
                },
            };
        }
        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<()> {
        for v in &self.reactions {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        if let ::std::option::Option::Some(ref v) = self.reply {
            match v {
                &direct_story_reply_message::Reply::TextReply(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                },
                &direct_story_reply_message::Reply::Emoji(ref v) => {
                    os.write_string(2, v)?;
                },
            };
        }
        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() -> DirectStoryReplyMessage {
        DirectStoryReplyMessage::new()
    }

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

    fn default_instance() -> &'static DirectStoryReplyMessage {
        static instance: DirectStoryReplyMessage = DirectStoryReplyMessage {
            reactions: ::std::vec::Vec::new(),
            reply: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `DirectStoryReplyMessage`
pub mod direct_story_reply_message {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.DirectStoryReplyMessage.reply)
    pub enum Reply {
        // @@protoc_insertion_point(oneof_field:signal.backup.DirectStoryReplyMessage.textReply)
        TextReply(TextReply),
        // @@protoc_insertion_point(oneof_field:signal.backup.DirectStoryReplyMessage.emoji)
        Emoji(::std::string::String),
    }

    impl ::protobuf::Oneof for Reply {
    }

    impl Reply {
    }
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.DirectStoryReplyMessage.TextReply)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct TextReply {
        // message fields
        #[field_name("text")]
        // @@protoc_insertion_point(field:signal.backup.DirectStoryReplyMessage.TextReply.text)
        pub text: ::protobuf::MessageField<super::Text>,
        #[field_name("longText")]
        // @@protoc_insertion_point(field:signal.backup.DirectStoryReplyMessage.TextReply.longText)
        pub longText: ::protobuf::MessageField<super::FilePointer>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.DirectStoryReplyMessage.TextReply.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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 => {
                        ::protobuf::rt::read_singular_message_into_field(is, &mut self.text)?;
                    },
                    18 => {
                        ::protobuf::rt::read_singular_message_into_field(is, &mut self.longText)?;
                    },
                    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 Some(v) = self.text.as_ref() {
                let len = v.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            }
            if let Some(v) = self.longText.as_ref() {
                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 Some(v) = self.text.as_ref() {
                ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
            }
            if let Some(v) = self.longText.as_ref() {
                ::protobuf::rt::write_message_field_with_cached_size(2, 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() -> TextReply {
            TextReply::new()
        }

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

        fn default_instance() -> &'static TextReply {
            static instance: TextReply = TextReply {
                text: ::protobuf::MessageField::none(),
                longText: ::protobuf::MessageField::none(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.PaymentNotification)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PaymentNotification {
    // message fields
    #[field_name("amountMob")]
    // @@protoc_insertion_point(field:signal.backup.PaymentNotification.amountMob)
    pub amountMob: ::std::option::Option<::std::string::String>,
    #[field_name("feeMob")]
    // @@protoc_insertion_point(field:signal.backup.PaymentNotification.feeMob)
    pub feeMob: ::std::option::Option<::std::string::String>,
    #[field_name("note")]
    // @@protoc_insertion_point(field:signal.backup.PaymentNotification.note)
    pub note: ::std::option::Option<::std::string::String>,
    #[field_name("transactionDetails")]
    // @@protoc_insertion_point(field:signal.backup.PaymentNotification.transactionDetails)
    pub transactionDetails: ::protobuf::MessageField<payment_notification::TransactionDetails>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.PaymentNotification.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.amountMob = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.feeMob = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.note = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.transactionDetails)?;
                },
                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 Some(v) = self.amountMob.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.feeMob.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.note.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.transactionDetails.as_ref() {
            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 Some(v) = self.amountMob.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.feeMob.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.note.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.transactionDetails.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(4, 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() -> PaymentNotification {
        PaymentNotification::new()
    }

    fn clear(&mut self) {
        self.amountMob = ::std::option::Option::None;
        self.feeMob = ::std::option::Option::None;
        self.note = ::std::option::Option::None;
        self.transactionDetails.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static PaymentNotification {
        static instance: PaymentNotification = PaymentNotification {
            amountMob: ::std::option::Option::None,
            feeMob: ::std::option::Option::None,
            note: ::std::option::Option::None,
            transactionDetails: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `PaymentNotification`
pub mod payment_notification {
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.PaymentNotification.TransactionDetails)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct TransactionDetails {
        // message oneof groups
        pub payment: ::std::option::Option<transaction_details::Payment>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.PaymentNotification.TransactionDetails.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        // .signal.backup.PaymentNotification.TransactionDetails.Transaction transaction = 1;

        pub fn transaction(&self) -> &transaction_details::Transaction {
            match self.payment {
                ::std::option::Option::Some(transaction_details::Payment::Transaction(ref v)) => v,
                _ => <transaction_details::Transaction as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_transaction(&self) -> bool {
            match self.payment {
                ::std::option::Option::Some(transaction_details::Payment::Transaction(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_transaction(&mut self, v: transaction_details::Transaction) {
            self.payment = ::std::option::Option::Some(transaction_details::Payment::Transaction(v))
        }

        // Mutable pointer to the field.
        pub fn mut_transaction(&mut self) -> &mut transaction_details::Transaction {
            if let ::std::option::Option::Some(transaction_details::Payment::Transaction(_)) = self.payment {
            } else {
                self.payment = ::std::option::Option::Some(transaction_details::Payment::Transaction(transaction_details::Transaction::new()));
            }
            match self.payment {
                ::std::option::Option::Some(transaction_details::Payment::Transaction(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_transaction(&mut self) -> transaction_details::Transaction {
            if self.has_transaction() {
                match self.payment.take() {
                    ::std::option::Option::Some(transaction_details::Payment::Transaction(v)) => v,
                    _ => panic!(),
                }
            } else {
                transaction_details::Transaction::new()
            }
        }

        // .signal.backup.PaymentNotification.TransactionDetails.FailedTransaction failedTransaction = 2;

        pub fn failedTransaction(&self) -> &transaction_details::FailedTransaction {
            match self.payment {
                ::std::option::Option::Some(transaction_details::Payment::FailedTransaction(ref v)) => v,
                _ => <transaction_details::FailedTransaction as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_failedTransaction(&self) -> bool {
            match self.payment {
                ::std::option::Option::Some(transaction_details::Payment::FailedTransaction(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_failedTransaction(&mut self, v: transaction_details::FailedTransaction) {
            self.payment = ::std::option::Option::Some(transaction_details::Payment::FailedTransaction(v))
        }

        // Mutable pointer to the field.
        pub fn mut_failedTransaction(&mut self) -> &mut transaction_details::FailedTransaction {
            if let ::std::option::Option::Some(transaction_details::Payment::FailedTransaction(_)) = self.payment {
            } else {
                self.payment = ::std::option::Option::Some(transaction_details::Payment::FailedTransaction(transaction_details::FailedTransaction::new()));
            }
            match self.payment {
                ::std::option::Option::Some(transaction_details::Payment::FailedTransaction(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_failedTransaction(&mut self) -> transaction_details::FailedTransaction {
            if self.has_failedTransaction() {
                match self.payment.take() {
                    ::std::option::Option::Some(transaction_details::Payment::FailedTransaction(v)) => v,
                    _ => panic!(),
                }
            } else {
                transaction_details::FailedTransaction::new()
            }
        }
    }

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

        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.payment = ::std::option::Option::Some(transaction_details::Payment::Transaction(is.read_message()?));
                    },
                    18 => {
                        self.payment = ::std::option::Option::Some(transaction_details::Payment::FailedTransaction(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.payment {
                match v {
                    &transaction_details::Payment::Transaction(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &transaction_details::Payment::FailedTransaction(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.payment {
                match v {
                    &transaction_details::Payment::Transaction(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                    },
                    &transaction_details::Payment::FailedTransaction(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(2, 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() -> TransactionDetails {
            TransactionDetails::new()
        }

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

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

    /// Nested message and enums of message `TransactionDetails`
    pub mod transaction_details {

        #[derive(Clone,PartialEq,Debug)]
        #[non_exhaustive]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(oneof:signal.backup.PaymentNotification.TransactionDetails.payment)
        pub enum Payment {
            // @@protoc_insertion_point(oneof_field:signal.backup.PaymentNotification.TransactionDetails.transaction)
            Transaction(Transaction),
            // @@protoc_insertion_point(oneof_field:signal.backup.PaymentNotification.TransactionDetails.failedTransaction)
            FailedTransaction(FailedTransaction),
        }

        impl ::protobuf::Oneof for Payment {
        }

        impl Payment {
        }
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(message:signal.backup.PaymentNotification.TransactionDetails.MobileCoinTxoIdentification)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct MobileCoinTxoIdentification {
            // message fields
            #[field_name("publicKey")]
            // @@protoc_insertion_point(field:signal.backup.PaymentNotification.TransactionDetails.MobileCoinTxoIdentification.publicKey)
            pub publicKey: ::std::vec::Vec<::std::vec::Vec<u8>>,
            #[field_name("keyImages")]
            // @@protoc_insertion_point(field:signal.backup.PaymentNotification.TransactionDetails.MobileCoinTxoIdentification.keyImages)
            pub keyImages: ::std::vec::Vec<::std::vec::Vec<u8>>,
            // special fields
            // @@protoc_insertion_point(special_field:signal.backup.PaymentNotification.TransactionDetails.MobileCoinTxoIdentification.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

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

            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.publicKey.push(is.read_bytes()?);
                        },
                        18 => {
                            self.keyImages.push(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;
                for value in &self.publicKey {
                    my_size += ::protobuf::rt::bytes_size(1, &value);
                };
                for value in &self.keyImages {
                    my_size += ::protobuf::rt::bytes_size(2, &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<()> {
                for v in &self.publicKey {
                    os.write_bytes(1, &v)?;
                };
                for v in &self.keyImages {
                    os.write_bytes(2, &v)?;
                };
                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() -> MobileCoinTxoIdentification {
                MobileCoinTxoIdentification::new()
            }

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

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

        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(message:signal.backup.PaymentNotification.TransactionDetails.FailedTransaction)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct FailedTransaction {
            // message fields
            #[field_name("reason")]
            // @@protoc_insertion_point(field:signal.backup.PaymentNotification.TransactionDetails.FailedTransaction.reason)
            pub reason: ::protobuf::EnumOrUnknown<failed_transaction::FailureReason>,
            // special fields
            // @@protoc_insertion_point(special_field:signal.backup.PaymentNotification.TransactionDetails.FailedTransaction.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

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

            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.reason = 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.reason != ::protobuf::EnumOrUnknown::new(failed_transaction::FailureReason::GENERIC) {
                    my_size += ::protobuf::rt::int32_size(1, self.reason.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.reason != ::protobuf::EnumOrUnknown::new(failed_transaction::FailureReason::GENERIC) {
                    os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.reason))?;
                }
                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() -> FailedTransaction {
                FailedTransaction::new()
            }

            fn clear(&mut self) {
                self.reason = ::protobuf::EnumOrUnknown::new(failed_transaction::FailureReason::GENERIC);
                self.special_fields.clear();
            }

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

        /// Nested message and enums of message `FailedTransaction`
        pub mod failed_transaction {
            #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
            #[derive(crate::unknown::visit_static::VisitUnknownFields)]
            // @@protoc_insertion_point(enum:signal.backup.PaymentNotification.TransactionDetails.FailedTransaction.FailureReason)
            pub enum FailureReason {
                // @@protoc_insertion_point(enum_value:signal.backup.PaymentNotification.TransactionDetails.FailedTransaction.FailureReason.GENERIC)
                GENERIC = 0,
                // @@protoc_insertion_point(enum_value:signal.backup.PaymentNotification.TransactionDetails.FailedTransaction.FailureReason.NETWORK)
                NETWORK = 1,
                // @@protoc_insertion_point(enum_value:signal.backup.PaymentNotification.TransactionDetails.FailedTransaction.FailureReason.INSUFFICIENT_FUNDS)
                INSUFFICIENT_FUNDS = 2,
            }

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

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

                fn from_i32(value: i32) -> ::std::option::Option<FailureReason> {
                    match value {
                        0 => ::std::option::Option::Some(FailureReason::GENERIC),
                        1 => ::std::option::Option::Some(FailureReason::NETWORK),
                        2 => ::std::option::Option::Some(FailureReason::INSUFFICIENT_FUNDS),
                        _ => ::std::option::Option::None
                    }
                }

                fn from_str(str: &str) -> ::std::option::Option<FailureReason> {
                    match str {
                        "GENERIC" => ::std::option::Option::Some(FailureReason::GENERIC),
                        "NETWORK" => ::std::option::Option::Some(FailureReason::NETWORK),
                        "INSUFFICIENT_FUNDS" => ::std::option::Option::Some(FailureReason::INSUFFICIENT_FUNDS),
                        _ => ::std::option::Option::None
                    }
                }

                const VALUES: &'static [FailureReason] = &[
                    FailureReason::GENERIC,
                    FailureReason::NETWORK,
                    FailureReason::INSUFFICIENT_FUNDS,
                ];
            }

            impl ::std::default::Default for FailureReason {
                fn default() -> Self {
                    FailureReason::GENERIC
                }
            }

        }

        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(message:signal.backup.PaymentNotification.TransactionDetails.Transaction)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct Transaction {
            // message fields
            #[field_name("status")]
            // @@protoc_insertion_point(field:signal.backup.PaymentNotification.TransactionDetails.Transaction.status)
            pub status: ::protobuf::EnumOrUnknown<transaction::Status>,
            #[field_name("mobileCoinIdentification")]
            // @@protoc_insertion_point(field:signal.backup.PaymentNotification.TransactionDetails.Transaction.mobileCoinIdentification)
            pub mobileCoinIdentification: ::protobuf::MessageField<MobileCoinTxoIdentification>,
            #[field_name("timestamp")]
            // @@protoc_insertion_point(field:signal.backup.PaymentNotification.TransactionDetails.Transaction.timestamp)
            pub timestamp: ::std::option::Option<u64>,
            #[field_name("blockIndex")]
            // @@protoc_insertion_point(field:signal.backup.PaymentNotification.TransactionDetails.Transaction.blockIndex)
            pub blockIndex: ::std::option::Option<u64>,
            #[field_name("blockTimestamp")]
            // @@protoc_insertion_point(field:signal.backup.PaymentNotification.TransactionDetails.Transaction.blockTimestamp)
            pub blockTimestamp: ::std::option::Option<u64>,
            #[field_name("transaction")]
            // @@protoc_insertion_point(field:signal.backup.PaymentNotification.TransactionDetails.Transaction.transaction)
            pub transaction: ::std::option::Option<::std::vec::Vec<u8>>,
            #[field_name("receipt")]
            // @@protoc_insertion_point(field:signal.backup.PaymentNotification.TransactionDetails.Transaction.receipt)
            pub receipt: ::std::option::Option<::std::vec::Vec<u8>>,
            // special fields
            // @@protoc_insertion_point(special_field:signal.backup.PaymentNotification.TransactionDetails.Transaction.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

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

            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 => {
                            ::protobuf::rt::read_singular_message_into_field(is, &mut self.mobileCoinIdentification)?;
                        },
                        24 => {
                            self.timestamp = ::std::option::Option::Some(is.read_uint64()?);
                        },
                        32 => {
                            self.blockIndex = ::std::option::Option::Some(is.read_uint64()?);
                        },
                        40 => {
                            self.blockTimestamp = ::std::option::Option::Some(is.read_uint64()?);
                        },
                        50 => {
                            self.transaction = ::std::option::Option::Some(is.read_bytes()?);
                        },
                        58 => {
                            self.receipt = ::std::option::Option::Some(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(transaction::Status::INITIAL) {
                    my_size += ::protobuf::rt::int32_size(1, self.status.value());
                }
                if let Some(v) = self.mobileCoinIdentification.as_ref() {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                }
                if let Some(v) = self.timestamp {
                    my_size += ::protobuf::rt::uint64_size(3, v);
                }
                if let Some(v) = self.blockIndex {
                    my_size += ::protobuf::rt::uint64_size(4, v);
                }
                if let Some(v) = self.blockTimestamp {
                    my_size += ::protobuf::rt::uint64_size(5, v);
                }
                if let Some(v) = self.transaction.as_ref() {
                    my_size += ::protobuf::rt::bytes_size(6, &v);
                }
                if let Some(v) = self.receipt.as_ref() {
                    my_size += ::protobuf::rt::bytes_size(7, &v);
                }
                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(transaction::Status::INITIAL) {
                    os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.status))?;
                }
                if let Some(v) = self.mobileCoinIdentification.as_ref() {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                }
                if let Some(v) = self.timestamp {
                    os.write_uint64(3, v)?;
                }
                if let Some(v) = self.blockIndex {
                    os.write_uint64(4, v)?;
                }
                if let Some(v) = self.blockTimestamp {
                    os.write_uint64(5, v)?;
                }
                if let Some(v) = self.transaction.as_ref() {
                    os.write_bytes(6, v)?;
                }
                if let Some(v) = self.receipt.as_ref() {
                    os.write_bytes(7, v)?;
                }
                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() -> Transaction {
                Transaction::new()
            }

            fn clear(&mut self) {
                self.status = ::protobuf::EnumOrUnknown::new(transaction::Status::INITIAL);
                self.mobileCoinIdentification.clear();
                self.timestamp = ::std::option::Option::None;
                self.blockIndex = ::std::option::Option::None;
                self.blockTimestamp = ::std::option::Option::None;
                self.transaction = ::std::option::Option::None;
                self.receipt = ::std::option::Option::None;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static Transaction {
                static instance: Transaction = Transaction {
                    status: ::protobuf::EnumOrUnknown::from_i32(0),
                    mobileCoinIdentification: ::protobuf::MessageField::none(),
                    timestamp: ::std::option::Option::None,
                    blockIndex: ::std::option::Option::None,
                    blockTimestamp: ::std::option::Option::None,
                    transaction: ::std::option::Option::None,
                    receipt: ::std::option::Option::None,
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        /// Nested message and enums of message `Transaction`
        pub mod transaction {
            #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
            #[derive(crate::unknown::visit_static::VisitUnknownFields)]
            // @@protoc_insertion_point(enum:signal.backup.PaymentNotification.TransactionDetails.Transaction.Status)
            pub enum Status {
                // @@protoc_insertion_point(enum_value:signal.backup.PaymentNotification.TransactionDetails.Transaction.Status.INITIAL)
                INITIAL = 0,
                // @@protoc_insertion_point(enum_value:signal.backup.PaymentNotification.TransactionDetails.Transaction.Status.SUBMITTED)
                SUBMITTED = 1,
                // @@protoc_insertion_point(enum_value:signal.backup.PaymentNotification.TransactionDetails.Transaction.Status.SUCCESSFUL)
                SUCCESSFUL = 2,
            }

            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::INITIAL),
                        1 => ::std::option::Option::Some(Status::SUBMITTED),
                        2 => ::std::option::Option::Some(Status::SUCCESSFUL),
                        _ => ::std::option::Option::None
                    }
                }

                fn from_str(str: &str) -> ::std::option::Option<Status> {
                    match str {
                        "INITIAL" => ::std::option::Option::Some(Status::INITIAL),
                        "SUBMITTED" => ::std::option::Option::Some(Status::SUBMITTED),
                        "SUCCESSFUL" => ::std::option::Option::Some(Status::SUCCESSFUL),
                        _ => ::std::option::Option::None
                    }
                }

                const VALUES: &'static [Status] = &[
                    Status::INITIAL,
                    Status::SUBMITTED,
                    Status::SUCCESSFUL,
                ];
            }

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

        }
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GiftBadge)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GiftBadge {
    // message fields
    #[field_name("receiptCredentialPresentation")]
    // @@protoc_insertion_point(field:signal.backup.GiftBadge.receiptCredentialPresentation)
    pub receiptCredentialPresentation: ::std::vec::Vec<u8>,
    #[field_name("state")]
    // @@protoc_insertion_point(field:signal.backup.GiftBadge.state)
    pub state: ::protobuf::EnumOrUnknown<gift_badge::State>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GiftBadge.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.receiptCredentialPresentation = is.read_bytes()?;
                },
                16 => {
                    self.state = 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.receiptCredentialPresentation.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.receiptCredentialPresentation);
        }
        if self.state != ::protobuf::EnumOrUnknown::new(gift_badge::State::UNOPENED) {
            my_size += ::protobuf::rt::int32_size(2, self.state.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.receiptCredentialPresentation.is_empty() {
            os.write_bytes(1, &self.receiptCredentialPresentation)?;
        }
        if self.state != ::protobuf::EnumOrUnknown::new(gift_badge::State::UNOPENED) {
            os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.state))?;
        }
        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() -> GiftBadge {
        GiftBadge::new()
    }

    fn clear(&mut self) {
        self.receiptCredentialPresentation.clear();
        self.state = ::protobuf::EnumOrUnknown::new(gift_badge::State::UNOPENED);
        self.special_fields.clear();
    }

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

/// Nested message and enums of message `GiftBadge`
pub mod gift_badge {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.GiftBadge.State)
    pub enum State {
        // @@protoc_insertion_point(enum_value:signal.backup.GiftBadge.State.UNOPENED)
        UNOPENED = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.GiftBadge.State.OPENED)
        OPENED = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.GiftBadge.State.REDEEMED)
        REDEEMED = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.GiftBadge.State.FAILED)
        FAILED = 3,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<State> {
            match value {
                0 => ::std::option::Option::Some(State::UNOPENED),
                1 => ::std::option::Option::Some(State::OPENED),
                2 => ::std::option::Option::Some(State::REDEEMED),
                3 => ::std::option::Option::Some(State::FAILED),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<State> {
            match str {
                "UNOPENED" => ::std::option::Option::Some(State::UNOPENED),
                "OPENED" => ::std::option::Option::Some(State::OPENED),
                "REDEEMED" => ::std::option::Option::Some(State::REDEEMED),
                "FAILED" => ::std::option::Option::Some(State::FAILED),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [State] = &[
            State::UNOPENED,
            State::OPENED,
            State::REDEEMED,
            State::FAILED,
        ];
    }

    impl ::std::default::Default for State {
        fn default() -> Self {
            State::UNOPENED
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ViewOnceMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ViewOnceMessage {
    // message fields
    #[field_name("attachment")]
    // @@protoc_insertion_point(field:signal.backup.ViewOnceMessage.attachment)
    pub attachment: ::protobuf::MessageField<MessageAttachment>,
    #[field_name("reactions")]
    // @@protoc_insertion_point(field:signal.backup.ViewOnceMessage.reactions)
    pub reactions: ::std::vec::Vec<Reaction>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ViewOnceMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.attachment)?;
                },
                18 => {
                    self.reactions.push(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 Some(v) = self.attachment.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.reactions {
            let len = value.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 Some(v) = self.attachment.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.reactions {
            ::protobuf::rt::write_message_field_with_cached_size(2, 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() -> ViewOnceMessage {
        ViewOnceMessage::new()
    }

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

    fn default_instance() -> &'static ViewOnceMessage {
        static instance: ViewOnceMessage = ViewOnceMessage {
            attachment: ::protobuf::MessageField::none(),
            reactions: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ContactAttachment)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ContactAttachment {
    // message fields
    #[field_name("name")]
    // @@protoc_insertion_point(field:signal.backup.ContactAttachment.name)
    pub name: ::protobuf::MessageField<contact_attachment::Name>,
    #[field_name("number")]
    // @@protoc_insertion_point(field:signal.backup.ContactAttachment.number)
    pub number: ::std::vec::Vec<contact_attachment::Phone>,
    #[field_name("email")]
    // @@protoc_insertion_point(field:signal.backup.ContactAttachment.email)
    pub email: ::std::vec::Vec<contact_attachment::Email>,
    #[field_name("address")]
    // @@protoc_insertion_point(field:signal.backup.ContactAttachment.address)
    pub address: ::std::vec::Vec<contact_attachment::PostalAddress>,
    #[field_name("avatar")]
    // @@protoc_insertion_point(field:signal.backup.ContactAttachment.avatar)
    pub avatar: ::protobuf::MessageField<FilePointer>,
    #[field_name("organization")]
    // @@protoc_insertion_point(field:signal.backup.ContactAttachment.organization)
    pub organization: ::std::string::String,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ContactAttachment.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.name)?;
                },
                26 => {
                    self.number.push(is.read_message()?);
                },
                34 => {
                    self.email.push(is.read_message()?);
                },
                42 => {
                    self.address.push(is.read_message()?);
                },
                50 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.avatar)?;
                },
                58 => {
                    self.organization = is.read_string()?;
                },
                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 Some(v) = self.name.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.number {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.email {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.address {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.avatar.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.organization.is_empty() {
            my_size += ::protobuf::rt::string_size(7, &self.organization);
        }
        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 Some(v) = self.name.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.number {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        for v in &self.email {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        for v in &self.address {
            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        };
        if let Some(v) = self.avatar.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        }
        if !self.organization.is_empty() {
            os.write_string(7, &self.organization)?;
        }
        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() -> ContactAttachment {
        ContactAttachment::new()
    }

    fn clear(&mut self) {
        self.name.clear();
        self.number.clear();
        self.email.clear();
        self.address.clear();
        self.avatar.clear();
        self.organization.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ContactAttachment {
        static instance: ContactAttachment = ContactAttachment {
            name: ::protobuf::MessageField::none(),
            number: ::std::vec::Vec::new(),
            email: ::std::vec::Vec::new(),
            address: ::std::vec::Vec::new(),
            avatar: ::protobuf::MessageField::none(),
            organization: ::std::string::String::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `ContactAttachment`
pub mod contact_attachment {
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ContactAttachment.Name)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Name {
        // message fields
        #[field_name("givenName")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Name.givenName)
        pub givenName: ::std::string::String,
        #[field_name("familyName")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Name.familyName)
        pub familyName: ::std::string::String,
        #[field_name("prefix")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Name.prefix)
        pub prefix: ::std::string::String,
        #[field_name("suffix")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Name.suffix)
        pub suffix: ::std::string::String,
        #[field_name("middleName")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Name.middleName)
        pub middleName: ::std::string::String,
        #[field_name("nickname")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Name.nickname)
        pub nickname: ::std::string::String,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ContactAttachment.Name.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.givenName = is.read_string()?;
                    },
                    18 => {
                        self.familyName = is.read_string()?;
                    },
                    26 => {
                        self.prefix = is.read_string()?;
                    },
                    34 => {
                        self.suffix = is.read_string()?;
                    },
                    42 => {
                        self.middleName = is.read_string()?;
                    },
                    50 => {
                        self.nickname = is.read_string()?;
                    },
                    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.givenName.is_empty() {
                my_size += ::protobuf::rt::string_size(1, &self.givenName);
            }
            if !self.familyName.is_empty() {
                my_size += ::protobuf::rt::string_size(2, &self.familyName);
            }
            if !self.prefix.is_empty() {
                my_size += ::protobuf::rt::string_size(3, &self.prefix);
            }
            if !self.suffix.is_empty() {
                my_size += ::protobuf::rt::string_size(4, &self.suffix);
            }
            if !self.middleName.is_empty() {
                my_size += ::protobuf::rt::string_size(5, &self.middleName);
            }
            if !self.nickname.is_empty() {
                my_size += ::protobuf::rt::string_size(6, &self.nickname);
            }
            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.givenName.is_empty() {
                os.write_string(1, &self.givenName)?;
            }
            if !self.familyName.is_empty() {
                os.write_string(2, &self.familyName)?;
            }
            if !self.prefix.is_empty() {
                os.write_string(3, &self.prefix)?;
            }
            if !self.suffix.is_empty() {
                os.write_string(4, &self.suffix)?;
            }
            if !self.middleName.is_empty() {
                os.write_string(5, &self.middleName)?;
            }
            if !self.nickname.is_empty() {
                os.write_string(6, &self.nickname)?;
            }
            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() -> Name {
            Name::new()
        }

        fn clear(&mut self) {
            self.givenName.clear();
            self.familyName.clear();
            self.prefix.clear();
            self.suffix.clear();
            self.middleName.clear();
            self.nickname.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Name {
            static instance: Name = Name {
                givenName: ::std::string::String::new(),
                familyName: ::std::string::String::new(),
                prefix: ::std::string::String::new(),
                suffix: ::std::string::String::new(),
                middleName: ::std::string::String::new(),
                nickname: ::std::string::String::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ContactAttachment.Phone)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Phone {
        // message fields
        #[field_name("value")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Phone.value)
        pub value: ::std::string::String,
        #[field_name("type")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Phone.type)
        pub type_: ::protobuf::EnumOrUnknown<phone::Type>,
        #[field_name("label")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Phone.label)
        pub label: ::std::string::String,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ContactAttachment.Phone.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.value = is.read_string()?;
                    },
                    16 => {
                        self.type_ = is.read_enum_or_unknown()?;
                    },
                    26 => {
                        self.label = is.read_string()?;
                    },
                    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.value.is_empty() {
                my_size += ::protobuf::rt::string_size(1, &self.value);
            }
            if self.type_ != ::protobuf::EnumOrUnknown::new(phone::Type::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(2, self.type_.value());
            }
            if !self.label.is_empty() {
                my_size += ::protobuf::rt::string_size(3, &self.label);
            }
            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.value.is_empty() {
                os.write_string(1, &self.value)?;
            }
            if self.type_ != ::protobuf::EnumOrUnknown::new(phone::Type::UNKNOWN) {
                os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.type_))?;
            }
            if !self.label.is_empty() {
                os.write_string(3, &self.label)?;
            }
            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() -> Phone {
            Phone::new()
        }

        fn clear(&mut self) {
            self.value.clear();
            self.type_ = ::protobuf::EnumOrUnknown::new(phone::Type::UNKNOWN);
            self.label.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Phone {
            static instance: Phone = Phone {
                value: ::std::string::String::new(),
                type_: ::protobuf::EnumOrUnknown::from_i32(0),
                label: ::std::string::String::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `Phone`
    pub mod phone {
        #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(enum:signal.backup.ContactAttachment.Phone.Type)
        pub enum Type {
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.Phone.Type.UNKNOWN)
            UNKNOWN = 0,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.Phone.Type.HOME)
            HOME = 1,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.Phone.Type.MOBILE)
            MOBILE = 2,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.Phone.Type.WORK)
            WORK = 3,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.Phone.Type.CUSTOM)
            CUSTOM = 4,
        }

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

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

            fn from_i32(value: i32) -> ::std::option::Option<Type> {
                match value {
                    0 => ::std::option::Option::Some(Type::UNKNOWN),
                    1 => ::std::option::Option::Some(Type::HOME),
                    2 => ::std::option::Option::Some(Type::MOBILE),
                    3 => ::std::option::Option::Some(Type::WORK),
                    4 => ::std::option::Option::Some(Type::CUSTOM),
                    _ => ::std::option::Option::None
                }
            }

            fn from_str(str: &str) -> ::std::option::Option<Type> {
                match str {
                    "UNKNOWN" => ::std::option::Option::Some(Type::UNKNOWN),
                    "HOME" => ::std::option::Option::Some(Type::HOME),
                    "MOBILE" => ::std::option::Option::Some(Type::MOBILE),
                    "WORK" => ::std::option::Option::Some(Type::WORK),
                    "CUSTOM" => ::std::option::Option::Some(Type::CUSTOM),
                    _ => ::std::option::Option::None
                }
            }

            const VALUES: &'static [Type] = &[
                Type::UNKNOWN,
                Type::HOME,
                Type::MOBILE,
                Type::WORK,
                Type::CUSTOM,
            ];
        }

        impl ::std::default::Default for Type {
            fn default() -> Self {
                Type::UNKNOWN
            }
        }

    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ContactAttachment.Email)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Email {
        // message fields
        #[field_name("value")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Email.value)
        pub value: ::std::string::String,
        #[field_name("type")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Email.type)
        pub type_: ::protobuf::EnumOrUnknown<email::Type>,
        #[field_name("label")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.Email.label)
        pub label: ::std::string::String,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ContactAttachment.Email.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.value = is.read_string()?;
                    },
                    16 => {
                        self.type_ = is.read_enum_or_unknown()?;
                    },
                    26 => {
                        self.label = is.read_string()?;
                    },
                    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.value.is_empty() {
                my_size += ::protobuf::rt::string_size(1, &self.value);
            }
            if self.type_ != ::protobuf::EnumOrUnknown::new(email::Type::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(2, self.type_.value());
            }
            if !self.label.is_empty() {
                my_size += ::protobuf::rt::string_size(3, &self.label);
            }
            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.value.is_empty() {
                os.write_string(1, &self.value)?;
            }
            if self.type_ != ::protobuf::EnumOrUnknown::new(email::Type::UNKNOWN) {
                os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.type_))?;
            }
            if !self.label.is_empty() {
                os.write_string(3, &self.label)?;
            }
            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() -> Email {
            Email::new()
        }

        fn clear(&mut self) {
            self.value.clear();
            self.type_ = ::protobuf::EnumOrUnknown::new(email::Type::UNKNOWN);
            self.label.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Email {
            static instance: Email = Email {
                value: ::std::string::String::new(),
                type_: ::protobuf::EnumOrUnknown::from_i32(0),
                label: ::std::string::String::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `Email`
    pub mod email {
        #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(enum:signal.backup.ContactAttachment.Email.Type)
        pub enum Type {
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.Email.Type.UNKNOWN)
            UNKNOWN = 0,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.Email.Type.HOME)
            HOME = 1,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.Email.Type.MOBILE)
            MOBILE = 2,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.Email.Type.WORK)
            WORK = 3,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.Email.Type.CUSTOM)
            CUSTOM = 4,
        }

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

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

            fn from_i32(value: i32) -> ::std::option::Option<Type> {
                match value {
                    0 => ::std::option::Option::Some(Type::UNKNOWN),
                    1 => ::std::option::Option::Some(Type::HOME),
                    2 => ::std::option::Option::Some(Type::MOBILE),
                    3 => ::std::option::Option::Some(Type::WORK),
                    4 => ::std::option::Option::Some(Type::CUSTOM),
                    _ => ::std::option::Option::None
                }
            }

            fn from_str(str: &str) -> ::std::option::Option<Type> {
                match str {
                    "UNKNOWN" => ::std::option::Option::Some(Type::UNKNOWN),
                    "HOME" => ::std::option::Option::Some(Type::HOME),
                    "MOBILE" => ::std::option::Option::Some(Type::MOBILE),
                    "WORK" => ::std::option::Option::Some(Type::WORK),
                    "CUSTOM" => ::std::option::Option::Some(Type::CUSTOM),
                    _ => ::std::option::Option::None
                }
            }

            const VALUES: &'static [Type] = &[
                Type::UNKNOWN,
                Type::HOME,
                Type::MOBILE,
                Type::WORK,
                Type::CUSTOM,
            ];
        }

        impl ::std::default::Default for Type {
            fn default() -> Self {
                Type::UNKNOWN
            }
        }

    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ContactAttachment.PostalAddress)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PostalAddress {
        // message fields
        #[field_name("type")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.PostalAddress.type)
        pub type_: ::protobuf::EnumOrUnknown<postal_address::Type>,
        #[field_name("label")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.PostalAddress.label)
        pub label: ::std::string::String,
        #[field_name("street")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.PostalAddress.street)
        pub street: ::std::string::String,
        #[field_name("pobox")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.PostalAddress.pobox)
        pub pobox: ::std::string::String,
        #[field_name("neighborhood")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.PostalAddress.neighborhood)
        pub neighborhood: ::std::string::String,
        #[field_name("city")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.PostalAddress.city)
        pub city: ::std::string::String,
        #[field_name("region")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.PostalAddress.region)
        pub region: ::std::string::String,
        #[field_name("postcode")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.PostalAddress.postcode)
        pub postcode: ::std::string::String,
        #[field_name("country")]
        // @@protoc_insertion_point(field:signal.backup.ContactAttachment.PostalAddress.country)
        pub country: ::std::string::String,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ContactAttachment.PostalAddress.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.type_ = is.read_enum_or_unknown()?;
                    },
                    18 => {
                        self.label = is.read_string()?;
                    },
                    26 => {
                        self.street = is.read_string()?;
                    },
                    34 => {
                        self.pobox = is.read_string()?;
                    },
                    42 => {
                        self.neighborhood = is.read_string()?;
                    },
                    50 => {
                        self.city = is.read_string()?;
                    },
                    58 => {
                        self.region = is.read_string()?;
                    },
                    66 => {
                        self.postcode = is.read_string()?;
                    },
                    74 => {
                        self.country = is.read_string()?;
                    },
                    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.type_ != ::protobuf::EnumOrUnknown::new(postal_address::Type::UNKNOWN) {
                my_size += ::protobuf::rt::int32_size(1, self.type_.value());
            }
            if !self.label.is_empty() {
                my_size += ::protobuf::rt::string_size(2, &self.label);
            }
            if !self.street.is_empty() {
                my_size += ::protobuf::rt::string_size(3, &self.street);
            }
            if !self.pobox.is_empty() {
                my_size += ::protobuf::rt::string_size(4, &self.pobox);
            }
            if !self.neighborhood.is_empty() {
                my_size += ::protobuf::rt::string_size(5, &self.neighborhood);
            }
            if !self.city.is_empty() {
                my_size += ::protobuf::rt::string_size(6, &self.city);
            }
            if !self.region.is_empty() {
                my_size += ::protobuf::rt::string_size(7, &self.region);
            }
            if !self.postcode.is_empty() {
                my_size += ::protobuf::rt::string_size(8, &self.postcode);
            }
            if !self.country.is_empty() {
                my_size += ::protobuf::rt::string_size(9, &self.country);
            }
            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.type_ != ::protobuf::EnumOrUnknown::new(postal_address::Type::UNKNOWN) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.type_))?;
            }
            if !self.label.is_empty() {
                os.write_string(2, &self.label)?;
            }
            if !self.street.is_empty() {
                os.write_string(3, &self.street)?;
            }
            if !self.pobox.is_empty() {
                os.write_string(4, &self.pobox)?;
            }
            if !self.neighborhood.is_empty() {
                os.write_string(5, &self.neighborhood)?;
            }
            if !self.city.is_empty() {
                os.write_string(6, &self.city)?;
            }
            if !self.region.is_empty() {
                os.write_string(7, &self.region)?;
            }
            if !self.postcode.is_empty() {
                os.write_string(8, &self.postcode)?;
            }
            if !self.country.is_empty() {
                os.write_string(9, &self.country)?;
            }
            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() -> PostalAddress {
            PostalAddress::new()
        }

        fn clear(&mut self) {
            self.type_ = ::protobuf::EnumOrUnknown::new(postal_address::Type::UNKNOWN);
            self.label.clear();
            self.street.clear();
            self.pobox.clear();
            self.neighborhood.clear();
            self.city.clear();
            self.region.clear();
            self.postcode.clear();
            self.country.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static PostalAddress {
            static instance: PostalAddress = PostalAddress {
                type_: ::protobuf::EnumOrUnknown::from_i32(0),
                label: ::std::string::String::new(),
                street: ::std::string::String::new(),
                pobox: ::std::string::String::new(),
                neighborhood: ::std::string::String::new(),
                city: ::std::string::String::new(),
                region: ::std::string::String::new(),
                postcode: ::std::string::String::new(),
                country: ::std::string::String::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `PostalAddress`
    pub mod postal_address {
        #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(enum:signal.backup.ContactAttachment.PostalAddress.Type)
        pub enum Type {
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.PostalAddress.Type.UNKNOWN)
            UNKNOWN = 0,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.PostalAddress.Type.HOME)
            HOME = 1,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.PostalAddress.Type.WORK)
            WORK = 2,
            // @@protoc_insertion_point(enum_value:signal.backup.ContactAttachment.PostalAddress.Type.CUSTOM)
            CUSTOM = 3,
        }

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

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

            fn from_i32(value: i32) -> ::std::option::Option<Type> {
                match value {
                    0 => ::std::option::Option::Some(Type::UNKNOWN),
                    1 => ::std::option::Option::Some(Type::HOME),
                    2 => ::std::option::Option::Some(Type::WORK),
                    3 => ::std::option::Option::Some(Type::CUSTOM),
                    _ => ::std::option::Option::None
                }
            }

            fn from_str(str: &str) -> ::std::option::Option<Type> {
                match str {
                    "UNKNOWN" => ::std::option::Option::Some(Type::UNKNOWN),
                    "HOME" => ::std::option::Option::Some(Type::HOME),
                    "WORK" => ::std::option::Option::Some(Type::WORK),
                    "CUSTOM" => ::std::option::Option::Some(Type::CUSTOM),
                    _ => ::std::option::Option::None
                }
            }

            const VALUES: &'static [Type] = &[
                Type::UNKNOWN,
                Type::HOME,
                Type::WORK,
                Type::CUSTOM,
            ];
        }

        impl ::std::default::Default for Type {
            fn default() -> Self {
                Type::UNKNOWN
            }
        }

    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.StickerMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct StickerMessage {
    // message fields
    #[field_name("sticker")]
    // @@protoc_insertion_point(field:signal.backup.StickerMessage.sticker)
    pub sticker: ::protobuf::MessageField<Sticker>,
    #[field_name("reactions")]
    // @@protoc_insertion_point(field:signal.backup.StickerMessage.reactions)
    pub reactions: ::std::vec::Vec<Reaction>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.StickerMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.sticker)?;
                },
                18 => {
                    self.reactions.push(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 Some(v) = self.sticker.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.reactions {
            let len = value.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 Some(v) = self.sticker.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.reactions {
            ::protobuf::rt::write_message_field_with_cached_size(2, 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() -> StickerMessage {
        StickerMessage::new()
    }

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

    fn default_instance() -> &'static StickerMessage {
        static instance: StickerMessage = StickerMessage {
            sticker: ::protobuf::MessageField::none(),
            reactions: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.RemoteDeletedMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct RemoteDeletedMessage {
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.RemoteDeletedMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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() -> RemoteDeletedMessage {
        RemoteDeletedMessage::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Sticker)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Sticker {
    // message fields
    #[field_name("packId")]
    // @@protoc_insertion_point(field:signal.backup.Sticker.packId)
    pub packId: ::std::vec::Vec<u8>,
    #[field_name("packKey")]
    // @@protoc_insertion_point(field:signal.backup.Sticker.packKey)
    pub packKey: ::std::vec::Vec<u8>,
    #[field_name("stickerId")]
    // @@protoc_insertion_point(field:signal.backup.Sticker.stickerId)
    pub stickerId: u32,
    #[field_name("emoji")]
    // @@protoc_insertion_point(field:signal.backup.Sticker.emoji)
    pub emoji: ::std::option::Option<::std::string::String>,
    #[field_name("data")]
    // @@protoc_insertion_point(field:signal.backup.Sticker.data)
    pub data: ::protobuf::MessageField<FilePointer>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Sticker.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.packId = is.read_bytes()?;
                },
                18 => {
                    self.packKey = is.read_bytes()?;
                },
                24 => {
                    self.stickerId = is.read_uint32()?;
                },
                34 => {
                    self.emoji = ::std::option::Option::Some(is.read_string()?);
                },
                42 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.data)?;
                },
                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.packId.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.packId);
        }
        if !self.packKey.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.packKey);
        }
        if self.stickerId != 0 {
            my_size += ::protobuf::rt::uint32_size(3, self.stickerId);
        }
        if let Some(v) = self.emoji.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.data.as_ref() {
            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 !self.packId.is_empty() {
            os.write_bytes(1, &self.packId)?;
        }
        if !self.packKey.is_empty() {
            os.write_bytes(2, &self.packKey)?;
        }
        if self.stickerId != 0 {
            os.write_uint32(3, self.stickerId)?;
        }
        if let Some(v) = self.emoji.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.data.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(5, 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() -> Sticker {
        Sticker::new()
    }

    fn clear(&mut self) {
        self.packId.clear();
        self.packKey.clear();
        self.stickerId = 0;
        self.emoji = ::std::option::Option::None;
        self.data.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Sticker {
        static instance: Sticker = Sticker {
            packId: ::std::vec::Vec::new(),
            packKey: ::std::vec::Vec::new(),
            stickerId: 0,
            emoji: ::std::option::Option::None,
            data: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.LinkPreview)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct LinkPreview {
    // message fields
    #[field_name("url")]
    // @@protoc_insertion_point(field:signal.backup.LinkPreview.url)
    pub url: ::std::string::String,
    #[field_name("title")]
    // @@protoc_insertion_point(field:signal.backup.LinkPreview.title)
    pub title: ::std::option::Option<::std::string::String>,
    #[field_name("image")]
    // @@protoc_insertion_point(field:signal.backup.LinkPreview.image)
    pub image: ::protobuf::MessageField<FilePointer>,
    #[field_name("description")]
    // @@protoc_insertion_point(field:signal.backup.LinkPreview.description)
    pub description: ::std::option::Option<::std::string::String>,
    #[field_name("date")]
    // @@protoc_insertion_point(field:signal.backup.LinkPreview.date)
    pub date: ::std::option::Option<u64>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.LinkPreview.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.url = is.read_string()?;
                },
                18 => {
                    self.title = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.image)?;
                },
                34 => {
                    self.description = ::std::option::Option::Some(is.read_string()?);
                },
                40 => {
                    self.date = ::std::option::Option::Some(is.read_uint64()?);
                },
                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.url.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.url);
        }
        if let Some(v) = self.title.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.image.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.description.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.date {
            my_size += ::protobuf::rt::uint64_size(5, v);
        }
        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.url.is_empty() {
            os.write_string(1, &self.url)?;
        }
        if let Some(v) = self.title.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.image.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if let Some(v) = self.description.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.date {
            os.write_uint64(5, v)?;
        }
        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() -> LinkPreview {
        LinkPreview::new()
    }

    fn clear(&mut self) {
        self.url.clear();
        self.title = ::std::option::Option::None;
        self.image.clear();
        self.description = ::std::option::Option::None;
        self.date = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static LinkPreview {
        static instance: LinkPreview = LinkPreview {
            url: ::std::string::String::new(),
            title: ::std::option::Option::None,
            image: ::protobuf::MessageField::none(),
            description: ::std::option::Option::None,
            date: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.MessageAttachment)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct MessageAttachment {
    // message fields
    #[field_name("pointer")]
    // @@protoc_insertion_point(field:signal.backup.MessageAttachment.pointer)
    pub pointer: ::protobuf::MessageField<FilePointer>,
    #[field_name("flag")]
    // @@protoc_insertion_point(field:signal.backup.MessageAttachment.flag)
    pub flag: ::protobuf::EnumOrUnknown<message_attachment::Flag>,
    #[field_name("wasDownloaded")]
    // @@protoc_insertion_point(field:signal.backup.MessageAttachment.wasDownloaded)
    pub wasDownloaded: bool,
    #[field_name("clientUuid")]
    // @@protoc_insertion_point(field:signal.backup.MessageAttachment.clientUuid)
    pub clientUuid: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.MessageAttachment.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.pointer)?;
                },
                16 => {
                    self.flag = is.read_enum_or_unknown()?;
                },
                24 => {
                    self.wasDownloaded = is.read_bool()?;
                },
                34 => {
                    self.clientUuid = ::std::option::Option::Some(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 let Some(v) = self.pointer.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.flag != ::protobuf::EnumOrUnknown::new(message_attachment::Flag::NONE) {
            my_size += ::protobuf::rt::int32_size(2, self.flag.value());
        }
        if self.wasDownloaded != false {
            my_size += 1 + 1;
        }
        if let Some(v) = self.clientUuid.as_ref() {
            my_size += ::protobuf::rt::bytes_size(4, &v);
        }
        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 Some(v) = self.pointer.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if self.flag != ::protobuf::EnumOrUnknown::new(message_attachment::Flag::NONE) {
            os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.flag))?;
        }
        if self.wasDownloaded != false {
            os.write_bool(3, self.wasDownloaded)?;
        }
        if let Some(v) = self.clientUuid.as_ref() {
            os.write_bytes(4, v)?;
        }
        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() -> MessageAttachment {
        MessageAttachment::new()
    }

    fn clear(&mut self) {
        self.pointer.clear();
        self.flag = ::protobuf::EnumOrUnknown::new(message_attachment::Flag::NONE);
        self.wasDownloaded = false;
        self.clientUuid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static MessageAttachment {
        static instance: MessageAttachment = MessageAttachment {
            pointer: ::protobuf::MessageField::none(),
            flag: ::protobuf::EnumOrUnknown::from_i32(0),
            wasDownloaded: false,
            clientUuid: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `MessageAttachment`
pub mod message_attachment {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.MessageAttachment.Flag)
    pub enum Flag {
        // @@protoc_insertion_point(enum_value:signal.backup.MessageAttachment.Flag.NONE)
        NONE = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.MessageAttachment.Flag.VOICE_MESSAGE)
        VOICE_MESSAGE = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.MessageAttachment.Flag.BORDERLESS)
        BORDERLESS = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.MessageAttachment.Flag.GIF)
        GIF = 3,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<Flag> {
            match value {
                0 => ::std::option::Option::Some(Flag::NONE),
                1 => ::std::option::Option::Some(Flag::VOICE_MESSAGE),
                2 => ::std::option::Option::Some(Flag::BORDERLESS),
                3 => ::std::option::Option::Some(Flag::GIF),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Flag> {
            match str {
                "NONE" => ::std::option::Option::Some(Flag::NONE),
                "VOICE_MESSAGE" => ::std::option::Option::Some(Flag::VOICE_MESSAGE),
                "BORDERLESS" => ::std::option::Option::Some(Flag::BORDERLESS),
                "GIF" => ::std::option::Option::Some(Flag::GIF),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Flag] = &[
            Flag::NONE,
            Flag::VOICE_MESSAGE,
            Flag::BORDERLESS,
            Flag::GIF,
        ];
    }

    impl ::std::default::Default for Flag {
        fn default() -> Self {
            Flag::NONE
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.FilePointer)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct FilePointer {
    // message fields
    #[field_name("contentType")]
    // @@protoc_insertion_point(field:signal.backup.FilePointer.contentType)
    pub contentType: ::std::option::Option<::std::string::String>,
    #[field_name("incrementalMac")]
    // @@protoc_insertion_point(field:signal.backup.FilePointer.incrementalMac)
    pub incrementalMac: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("incrementalMacChunkSize")]
    // @@protoc_insertion_point(field:signal.backup.FilePointer.incrementalMacChunkSize)
    pub incrementalMacChunkSize: ::std::option::Option<u32>,
    #[field_name("fileName")]
    // @@protoc_insertion_point(field:signal.backup.FilePointer.fileName)
    pub fileName: ::std::option::Option<::std::string::String>,
    #[field_name("width")]
    // @@protoc_insertion_point(field:signal.backup.FilePointer.width)
    pub width: ::std::option::Option<u32>,
    #[field_name("height")]
    // @@protoc_insertion_point(field:signal.backup.FilePointer.height)
    pub height: ::std::option::Option<u32>,
    #[field_name("caption")]
    // @@protoc_insertion_point(field:signal.backup.FilePointer.caption)
    pub caption: ::std::option::Option<::std::string::String>,
    #[field_name("blurHash")]
    // @@protoc_insertion_point(field:signal.backup.FilePointer.blurHash)
    pub blurHash: ::std::option::Option<::std::string::String>,
    #[field_name("locatorInfo")]
    // @@protoc_insertion_point(field:signal.backup.FilePointer.locatorInfo)
    pub locatorInfo: ::protobuf::MessageField<file_pointer::LocatorInfo>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.FilePointer.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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 {
                34 => {
                    self.contentType = ::std::option::Option::Some(is.read_string()?);
                },
                42 => {
                    self.incrementalMac = ::std::option::Option::Some(is.read_bytes()?);
                },
                48 => {
                    self.incrementalMacChunkSize = ::std::option::Option::Some(is.read_uint32()?);
                },
                58 => {
                    self.fileName = ::std::option::Option::Some(is.read_string()?);
                },
                64 => {
                    self.width = ::std::option::Option::Some(is.read_uint32()?);
                },
                72 => {
                    self.height = ::std::option::Option::Some(is.read_uint32()?);
                },
                82 => {
                    self.caption = ::std::option::Option::Some(is.read_string()?);
                },
                90 => {
                    self.blurHash = ::std::option::Option::Some(is.read_string()?);
                },
                106 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.locatorInfo)?;
                },
                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 Some(v) = self.contentType.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.incrementalMac.as_ref() {
            my_size += ::protobuf::rt::bytes_size(5, &v);
        }
        if let Some(v) = self.incrementalMacChunkSize {
            my_size += ::protobuf::rt::uint32_size(6, v);
        }
        if let Some(v) = self.fileName.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.width {
            my_size += ::protobuf::rt::uint32_size(8, v);
        }
        if let Some(v) = self.height {
            my_size += ::protobuf::rt::uint32_size(9, v);
        }
        if let Some(v) = self.caption.as_ref() {
            my_size += ::protobuf::rt::string_size(10, &v);
        }
        if let Some(v) = self.blurHash.as_ref() {
            my_size += ::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.locatorInfo.as_ref() {
            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 Some(v) = self.contentType.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.incrementalMac.as_ref() {
            os.write_bytes(5, v)?;
        }
        if let Some(v) = self.incrementalMacChunkSize {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.fileName.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.width {
            os.write_uint32(8, v)?;
        }
        if let Some(v) = self.height {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.caption.as_ref() {
            os.write_string(10, v)?;
        }
        if let Some(v) = self.blurHash.as_ref() {
            os.write_string(11, v)?;
        }
        if let Some(v) = self.locatorInfo.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(13, 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() -> FilePointer {
        FilePointer::new()
    }

    fn clear(&mut self) {
        self.contentType = ::std::option::Option::None;
        self.incrementalMac = ::std::option::Option::None;
        self.incrementalMacChunkSize = ::std::option::Option::None;
        self.fileName = ::std::option::Option::None;
        self.width = ::std::option::Option::None;
        self.height = ::std::option::Option::None;
        self.caption = ::std::option::Option::None;
        self.blurHash = ::std::option::Option::None;
        self.locatorInfo.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static FilePointer {
        static instance: FilePointer = FilePointer {
            contentType: ::std::option::Option::None,
            incrementalMac: ::std::option::Option::None,
            incrementalMacChunkSize: ::std::option::Option::None,
            fileName: ::std::option::Option::None,
            width: ::std::option::Option::None,
            height: ::std::option::Option::None,
            caption: ::std::option::Option::None,
            blurHash: ::std::option::Option::None,
            locatorInfo: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `FilePointer`
pub mod file_pointer {
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.FilePointer.LocatorInfo)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct LocatorInfo {
        // message fields
        #[field_name("key")]
        // @@protoc_insertion_point(field:signal.backup.FilePointer.LocatorInfo.key)
        pub key: ::std::vec::Vec<u8>,
        #[field_name("size")]
        // @@protoc_insertion_point(field:signal.backup.FilePointer.LocatorInfo.size)
        pub size: u32,
        #[field_name("transitCdnKey")]
        // @@protoc_insertion_point(field:signal.backup.FilePointer.LocatorInfo.transitCdnKey)
        pub transitCdnKey: ::std::option::Option<::std::string::String>,
        #[field_name("transitCdnNumber")]
        // @@protoc_insertion_point(field:signal.backup.FilePointer.LocatorInfo.transitCdnNumber)
        pub transitCdnNumber: ::std::option::Option<u32>,
        #[field_name("transitTierUploadTimestamp")]
        // @@protoc_insertion_point(field:signal.backup.FilePointer.LocatorInfo.transitTierUploadTimestamp)
        pub transitTierUploadTimestamp: ::std::option::Option<u64>,
        #[field_name("mediaTierCdnNumber")]
        // @@protoc_insertion_point(field:signal.backup.FilePointer.LocatorInfo.mediaTierCdnNumber)
        pub mediaTierCdnNumber: ::std::option::Option<u32>,
        #[field_name("localKey")]
        // @@protoc_insertion_point(field:signal.backup.FilePointer.LocatorInfo.localKey)
        pub localKey: ::std::option::Option<::std::vec::Vec<u8>>,
        // message oneof groups
        pub integrityCheck: ::std::option::Option<locator_info::IntegrityCheck>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.FilePointer.LocatorInfo.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        // bytes plaintextHash = 10;

        pub fn plaintextHash(&self) -> &[u8] {
            match self.integrityCheck {
                ::std::option::Option::Some(locator_info::IntegrityCheck::PlaintextHash(ref v)) => v,
                _ => &[],
            }
        }

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

        pub fn has_plaintextHash(&self) -> bool {
            match self.integrityCheck {
                ::std::option::Option::Some(locator_info::IntegrityCheck::PlaintextHash(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_plaintextHash(&mut self, v: ::std::vec::Vec<u8>) {
            self.integrityCheck = ::std::option::Option::Some(locator_info::IntegrityCheck::PlaintextHash(v))
        }

        // Mutable pointer to the field.
        pub fn mut_plaintextHash(&mut self) -> &mut ::std::vec::Vec<u8> {
            if let ::std::option::Option::Some(locator_info::IntegrityCheck::PlaintextHash(_)) = self.integrityCheck {
            } else {
                self.integrityCheck = ::std::option::Option::Some(locator_info::IntegrityCheck::PlaintextHash(::std::vec::Vec::new()));
            }
            match self.integrityCheck {
                ::std::option::Option::Some(locator_info::IntegrityCheck::PlaintextHash(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_plaintextHash(&mut self) -> ::std::vec::Vec<u8> {
            if self.has_plaintextHash() {
                match self.integrityCheck.take() {
                    ::std::option::Option::Some(locator_info::IntegrityCheck::PlaintextHash(v)) => v,
                    _ => panic!(),
                }
            } else {
                ::std::vec::Vec::new()
            }
        }

        // bytes encryptedDigest = 11;

        pub fn encryptedDigest(&self) -> &[u8] {
            match self.integrityCheck {
                ::std::option::Option::Some(locator_info::IntegrityCheck::EncryptedDigest(ref v)) => v,
                _ => &[],
            }
        }

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

        pub fn has_encryptedDigest(&self) -> bool {
            match self.integrityCheck {
                ::std::option::Option::Some(locator_info::IntegrityCheck::EncryptedDigest(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_encryptedDigest(&mut self, v: ::std::vec::Vec<u8>) {
            self.integrityCheck = ::std::option::Option::Some(locator_info::IntegrityCheck::EncryptedDigest(v))
        }

        // Mutable pointer to the field.
        pub fn mut_encryptedDigest(&mut self) -> &mut ::std::vec::Vec<u8> {
            if let ::std::option::Option::Some(locator_info::IntegrityCheck::EncryptedDigest(_)) = self.integrityCheck {
            } else {
                self.integrityCheck = ::std::option::Option::Some(locator_info::IntegrityCheck::EncryptedDigest(::std::vec::Vec::new()));
            }
            match self.integrityCheck {
                ::std::option::Option::Some(locator_info::IntegrityCheck::EncryptedDigest(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_encryptedDigest(&mut self) -> ::std::vec::Vec<u8> {
            if self.has_encryptedDigest() {
                match self.integrityCheck.take() {
                    ::std::option::Option::Some(locator_info::IntegrityCheck::EncryptedDigest(v)) => v,
                    _ => panic!(),
                }
            } else {
                ::std::vec::Vec::new()
            }
        }
    }

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

        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.key = is.read_bytes()?;
                    },
                    82 => {
                        self.integrityCheck = ::std::option::Option::Some(locator_info::IntegrityCheck::PlaintextHash(is.read_bytes()?));
                    },
                    90 => {
                        self.integrityCheck = ::std::option::Option::Some(locator_info::IntegrityCheck::EncryptedDigest(is.read_bytes()?));
                    },
                    24 => {
                        self.size = is.read_uint32()?;
                    },
                    34 => {
                        self.transitCdnKey = ::std::option::Option::Some(is.read_string()?);
                    },
                    40 => {
                        self.transitCdnNumber = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    48 => {
                        self.transitTierUploadTimestamp = ::std::option::Option::Some(is.read_uint64()?);
                    },
                    56 => {
                        self.mediaTierCdnNumber = ::std::option::Option::Some(is.read_uint32()?);
                    },
                    74 => {
                        self.localKey = ::std::option::Option::Some(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.key.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.key);
            }
            if self.size != 0 {
                my_size += ::protobuf::rt::uint32_size(3, self.size);
            }
            if let Some(v) = self.transitCdnKey.as_ref() {
                my_size += ::protobuf::rt::string_size(4, &v);
            }
            if let Some(v) = self.transitCdnNumber {
                my_size += ::protobuf::rt::uint32_size(5, v);
            }
            if let Some(v) = self.transitTierUploadTimestamp {
                my_size += ::protobuf::rt::uint64_size(6, v);
            }
            if let Some(v) = self.mediaTierCdnNumber {
                my_size += ::protobuf::rt::uint32_size(7, v);
            }
            if let Some(v) = self.localKey.as_ref() {
                my_size += ::protobuf::rt::bytes_size(9, &v);
            }
            if let ::std::option::Option::Some(ref v) = self.integrityCheck {
                match v {
                    &locator_info::IntegrityCheck::PlaintextHash(ref v) => {
                        my_size += ::protobuf::rt::bytes_size(10, &v);
                    },
                    &locator_info::IntegrityCheck::EncryptedDigest(ref v) => {
                        my_size += ::protobuf::rt::bytes_size(11, &v);
                    },
                };
            }
            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.key.is_empty() {
                os.write_bytes(1, &self.key)?;
            }
            if self.size != 0 {
                os.write_uint32(3, self.size)?;
            }
            if let Some(v) = self.transitCdnKey.as_ref() {
                os.write_string(4, v)?;
            }
            if let Some(v) = self.transitCdnNumber {
                os.write_uint32(5, v)?;
            }
            if let Some(v) = self.transitTierUploadTimestamp {
                os.write_uint64(6, v)?;
            }
            if let Some(v) = self.mediaTierCdnNumber {
                os.write_uint32(7, v)?;
            }
            if let Some(v) = self.localKey.as_ref() {
                os.write_bytes(9, v)?;
            }
            if let ::std::option::Option::Some(ref v) = self.integrityCheck {
                match v {
                    &locator_info::IntegrityCheck::PlaintextHash(ref v) => {
                        os.write_bytes(10, v)?;
                    },
                    &locator_info::IntegrityCheck::EncryptedDigest(ref v) => {
                        os.write_bytes(11, v)?;
                    },
                };
            }
            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() -> LocatorInfo {
            LocatorInfo::new()
        }

        fn clear(&mut self) {
            self.key.clear();
            self.integrityCheck = ::std::option::Option::None;
            self.integrityCheck = ::std::option::Option::None;
            self.size = 0;
            self.transitCdnKey = ::std::option::Option::None;
            self.transitCdnNumber = ::std::option::Option::None;
            self.transitTierUploadTimestamp = ::std::option::Option::None;
            self.mediaTierCdnNumber = ::std::option::Option::None;
            self.localKey = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static LocatorInfo {
            static instance: LocatorInfo = LocatorInfo {
                key: ::std::vec::Vec::new(),
                size: 0,
                transitCdnKey: ::std::option::Option::None,
                transitCdnNumber: ::std::option::Option::None,
                transitTierUploadTimestamp: ::std::option::Option::None,
                mediaTierCdnNumber: ::std::option::Option::None,
                localKey: ::std::option::Option::None,
                integrityCheck: ::std::option::Option::None,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `LocatorInfo`
    pub mod locator_info {

        #[derive(Clone,PartialEq,Debug)]
        #[non_exhaustive]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(oneof:signal.backup.FilePointer.LocatorInfo.integrityCheck)
        pub enum IntegrityCheck {
            // @@protoc_insertion_point(oneof_field:signal.backup.FilePointer.LocatorInfo.plaintextHash)
            PlaintextHash(::std::vec::Vec<u8>),
            // @@protoc_insertion_point(oneof_field:signal.backup.FilePointer.LocatorInfo.encryptedDigest)
            EncryptedDigest(::std::vec::Vec<u8>),
        }

        impl ::protobuf::Oneof for IntegrityCheck {
        }

        impl IntegrityCheck {
        }
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Quote)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Quote {
    // message fields
    #[field_name("targetSentTimestamp")]
    // @@protoc_insertion_point(field:signal.backup.Quote.targetSentTimestamp)
    pub targetSentTimestamp: ::std::option::Option<u64>,
    #[field_name("authorId")]
    // @@protoc_insertion_point(field:signal.backup.Quote.authorId)
    pub authorId: u64,
    #[field_name("text")]
    // @@protoc_insertion_point(field:signal.backup.Quote.text)
    pub text: ::protobuf::MessageField<Text>,
    #[field_name("attachments")]
    // @@protoc_insertion_point(field:signal.backup.Quote.attachments)
    pub attachments: ::std::vec::Vec<quote::QuotedAttachment>,
    #[field_name("type")]
    // @@protoc_insertion_point(field:signal.backup.Quote.type)
    pub type_: ::protobuf::EnumOrUnknown<quote::Type>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Quote.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.targetSentTimestamp = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.authorId = is.read_uint64()?;
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.text)?;
                },
                34 => {
                    self.attachments.push(is.read_message()?);
                },
                40 => {
                    self.type_ = 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 let Some(v) = self.targetSentTimestamp {
            my_size += ::protobuf::rt::uint64_size(1, v);
        }
        if self.authorId != 0 {
            my_size += ::protobuf::rt::uint64_size(2, self.authorId);
        }
        if let Some(v) = self.text.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.attachments {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if self.type_ != ::protobuf::EnumOrUnknown::new(quote::Type::UNKNOWN) {
            my_size += ::protobuf::rt::int32_size(5, self.type_.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 let Some(v) = self.targetSentTimestamp {
            os.write_uint64(1, v)?;
        }
        if self.authorId != 0 {
            os.write_uint64(2, self.authorId)?;
        }
        if let Some(v) = self.text.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        for v in &self.attachments {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        if self.type_ != ::protobuf::EnumOrUnknown::new(quote::Type::UNKNOWN) {
            os.write_enum(5, ::protobuf::EnumOrUnknown::value(&self.type_))?;
        }
        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() -> Quote {
        Quote::new()
    }

    fn clear(&mut self) {
        self.targetSentTimestamp = ::std::option::Option::None;
        self.authorId = 0;
        self.text.clear();
        self.attachments.clear();
        self.type_ = ::protobuf::EnumOrUnknown::new(quote::Type::UNKNOWN);
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Quote {
        static instance: Quote = Quote {
            targetSentTimestamp: ::std::option::Option::None,
            authorId: 0,
            text: ::protobuf::MessageField::none(),
            attachments: ::std::vec::Vec::new(),
            type_: ::protobuf::EnumOrUnknown::from_i32(0),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `Quote`
pub mod quote {
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Quote.QuotedAttachment)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct QuotedAttachment {
        // message fields
        #[field_name("contentType")]
        // @@protoc_insertion_point(field:signal.backup.Quote.QuotedAttachment.contentType)
        pub contentType: ::std::option::Option<::std::string::String>,
        #[field_name("fileName")]
        // @@protoc_insertion_point(field:signal.backup.Quote.QuotedAttachment.fileName)
        pub fileName: ::std::option::Option<::std::string::String>,
        #[field_name("thumbnail")]
        // @@protoc_insertion_point(field:signal.backup.Quote.QuotedAttachment.thumbnail)
        pub thumbnail: ::protobuf::MessageField<super::MessageAttachment>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Quote.QuotedAttachment.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.contentType = ::std::option::Option::Some(is.read_string()?);
                    },
                    18 => {
                        self.fileName = ::std::option::Option::Some(is.read_string()?);
                    },
                    26 => {
                        ::protobuf::rt::read_singular_message_into_field(is, &mut self.thumbnail)?;
                    },
                    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 Some(v) = self.contentType.as_ref() {
                my_size += ::protobuf::rt::string_size(1, &v);
            }
            if let Some(v) = self.fileName.as_ref() {
                my_size += ::protobuf::rt::string_size(2, &v);
            }
            if let Some(v) = self.thumbnail.as_ref() {
                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 Some(v) = self.contentType.as_ref() {
                os.write_string(1, v)?;
            }
            if let Some(v) = self.fileName.as_ref() {
                os.write_string(2, v)?;
            }
            if let Some(v) = self.thumbnail.as_ref() {
                ::protobuf::rt::write_message_field_with_cached_size(3, 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() -> QuotedAttachment {
            QuotedAttachment::new()
        }

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

        fn default_instance() -> &'static QuotedAttachment {
            static instance: QuotedAttachment = QuotedAttachment {
                contentType: ::std::option::Option::None,
                fileName: ::std::option::Option::None,
                thumbnail: ::protobuf::MessageField::none(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.Quote.Type)
    pub enum Type {
        // @@protoc_insertion_point(enum_value:signal.backup.Quote.Type.UNKNOWN)
        UNKNOWN = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.Quote.Type.NORMAL)
        NORMAL = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.Quote.Type.GIFT_BADGE)
        GIFT_BADGE = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.Quote.Type.VIEW_ONCE)
        VIEW_ONCE = 3,
        // @@protoc_insertion_point(enum_value:signal.backup.Quote.Type.POLL)
        POLL = 4,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<Type> {
            match value {
                0 => ::std::option::Option::Some(Type::UNKNOWN),
                1 => ::std::option::Option::Some(Type::NORMAL),
                2 => ::std::option::Option::Some(Type::GIFT_BADGE),
                3 => ::std::option::Option::Some(Type::VIEW_ONCE),
                4 => ::std::option::Option::Some(Type::POLL),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Type> {
            match str {
                "UNKNOWN" => ::std::option::Option::Some(Type::UNKNOWN),
                "NORMAL" => ::std::option::Option::Some(Type::NORMAL),
                "GIFT_BADGE" => ::std::option::Option::Some(Type::GIFT_BADGE),
                "VIEW_ONCE" => ::std::option::Option::Some(Type::VIEW_ONCE),
                "POLL" => ::std::option::Option::Some(Type::POLL),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Type] = &[
            Type::UNKNOWN,
            Type::NORMAL,
            Type::GIFT_BADGE,
            Type::VIEW_ONCE,
            Type::POLL,
        ];
    }

    impl ::std::default::Default for Type {
        fn default() -> Self {
            Type::UNKNOWN
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.BodyRange)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct BodyRange {
    // message fields
    #[field_name("start")]
    // @@protoc_insertion_point(field:signal.backup.BodyRange.start)
    pub start: u32,
    #[field_name("length")]
    // @@protoc_insertion_point(field:signal.backup.BodyRange.length)
    pub length: u32,
    // message oneof groups
    pub associatedValue: ::std::option::Option<body_range::AssociatedValue>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.BodyRange.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // bytes mentionAci = 3;

    pub fn mentionAci(&self) -> &[u8] {
        match self.associatedValue {
            ::std::option::Option::Some(body_range::AssociatedValue::MentionAci(ref v)) => v,
            _ => &[],
        }
    }

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

    pub fn has_mentionAci(&self) -> bool {
        match self.associatedValue {
            ::std::option::Option::Some(body_range::AssociatedValue::MentionAci(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_mentionAci(&mut self, v: ::std::vec::Vec<u8>) {
        self.associatedValue = ::std::option::Option::Some(body_range::AssociatedValue::MentionAci(v))
    }

    // Mutable pointer to the field.
    pub fn mut_mentionAci(&mut self) -> &mut ::std::vec::Vec<u8> {
        if let ::std::option::Option::Some(body_range::AssociatedValue::MentionAci(_)) = self.associatedValue {
        } else {
            self.associatedValue = ::std::option::Option::Some(body_range::AssociatedValue::MentionAci(::std::vec::Vec::new()));
        }
        match self.associatedValue {
            ::std::option::Option::Some(body_range::AssociatedValue::MentionAci(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_mentionAci(&mut self) -> ::std::vec::Vec<u8> {
        if self.has_mentionAci() {
            match self.associatedValue.take() {
                ::std::option::Option::Some(body_range::AssociatedValue::MentionAci(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::vec::Vec::new()
        }
    }

    // .signal.backup.BodyRange.Style style = 4;

    pub fn style(&self) -> body_range::Style {
        match self.associatedValue {
            ::std::option::Option::Some(body_range::AssociatedValue::Style(v)) => ::protobuf::EnumOrUnknown::enum_value_or_default(&v),
            _ => body_range::Style::NONE,
        }
    }

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

    pub fn has_style(&self) -> bool {
        match self.associatedValue {
            ::std::option::Option::Some(body_range::AssociatedValue::Style(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_style(&mut self, v: body_range::Style) {
        self.associatedValue = ::std::option::Option::Some(body_range::AssociatedValue::Style(::protobuf::EnumOrUnknown::new(v)))
    }
}

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

    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.start = is.read_uint32()?;
                },
                16 => {
                    self.length = is.read_uint32()?;
                },
                26 => {
                    self.associatedValue = ::std::option::Option::Some(body_range::AssociatedValue::MentionAci(is.read_bytes()?));
                },
                32 => {
                    self.associatedValue = ::std::option::Option::Some(body_range::AssociatedValue::Style(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.start != 0 {
            my_size += ::protobuf::rt::uint32_size(1, self.start);
        }
        if self.length != 0 {
            my_size += ::protobuf::rt::uint32_size(2, self.length);
        }
        if let ::std::option::Option::Some(ref v) = self.associatedValue {
            match v {
                &body_range::AssociatedValue::MentionAci(ref v) => {
                    my_size += ::protobuf::rt::bytes_size(3, &v);
                },
                &body_range::AssociatedValue::Style(v) => {
                    my_size += ::protobuf::rt::int32_size(4, v.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.start != 0 {
            os.write_uint32(1, self.start)?;
        }
        if self.length != 0 {
            os.write_uint32(2, self.length)?;
        }
        if let ::std::option::Option::Some(ref v) = self.associatedValue {
            match v {
                &body_range::AssociatedValue::MentionAci(ref v) => {
                    os.write_bytes(3, v)?;
                },
                &body_range::AssociatedValue::Style(v) => {
                    os.write_enum(4, ::protobuf::EnumOrUnknown::value(&v))?;
                },
            };
        }
        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() -> BodyRange {
        BodyRange::new()
    }

    fn clear(&mut self) {
        self.start = 0;
        self.length = 0;
        self.associatedValue = ::std::option::Option::None;
        self.associatedValue = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static BodyRange {
        static instance: BodyRange = BodyRange {
            start: 0,
            length: 0,
            associatedValue: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `BodyRange`
pub mod body_range {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.BodyRange.associatedValue)
    pub enum AssociatedValue {
        // @@protoc_insertion_point(oneof_field:signal.backup.BodyRange.mentionAci)
        MentionAci(::std::vec::Vec<u8>),
        // @@protoc_insertion_point(oneof_field:signal.backup.BodyRange.style)
        Style(::protobuf::EnumOrUnknown<Style>),
    }

    impl ::protobuf::Oneof for AssociatedValue {
    }

    impl AssociatedValue {
    }
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.BodyRange.Style)
    pub enum Style {
        // @@protoc_insertion_point(enum_value:signal.backup.BodyRange.Style.NONE)
        NONE = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.BodyRange.Style.BOLD)
        BOLD = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.BodyRange.Style.ITALIC)
        ITALIC = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.BodyRange.Style.SPOILER)
        SPOILER = 3,
        // @@protoc_insertion_point(enum_value:signal.backup.BodyRange.Style.STRIKETHROUGH)
        STRIKETHROUGH = 4,
        // @@protoc_insertion_point(enum_value:signal.backup.BodyRange.Style.MONOSPACE)
        MONOSPACE = 5,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<Style> {
            match value {
                0 => ::std::option::Option::Some(Style::NONE),
                1 => ::std::option::Option::Some(Style::BOLD),
                2 => ::std::option::Option::Some(Style::ITALIC),
                3 => ::std::option::Option::Some(Style::SPOILER),
                4 => ::std::option::Option::Some(Style::STRIKETHROUGH),
                5 => ::std::option::Option::Some(Style::MONOSPACE),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Style> {
            match str {
                "NONE" => ::std::option::Option::Some(Style::NONE),
                "BOLD" => ::std::option::Option::Some(Style::BOLD),
                "ITALIC" => ::std::option::Option::Some(Style::ITALIC),
                "SPOILER" => ::std::option::Option::Some(Style::SPOILER),
                "STRIKETHROUGH" => ::std::option::Option::Some(Style::STRIKETHROUGH),
                "MONOSPACE" => ::std::option::Option::Some(Style::MONOSPACE),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Style] = &[
            Style::NONE,
            Style::BOLD,
            Style::ITALIC,
            Style::SPOILER,
            Style::STRIKETHROUGH,
            Style::MONOSPACE,
        ];
    }

    impl ::std::default::Default for Style {
        fn default() -> Self {
            Style::NONE
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Reaction)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Reaction {
    // message fields
    #[field_name("emoji")]
    // @@protoc_insertion_point(field:signal.backup.Reaction.emoji)
    pub emoji: ::std::string::String,
    #[field_name("authorId")]
    // @@protoc_insertion_point(field:signal.backup.Reaction.authorId)
    pub authorId: u64,
    #[field_name("sentTimestamp")]
    // @@protoc_insertion_point(field:signal.backup.Reaction.sentTimestamp)
    pub sentTimestamp: u64,
    #[field_name("sortOrder")]
    // @@protoc_insertion_point(field:signal.backup.Reaction.sortOrder)
    pub sortOrder: u64,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Reaction.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.emoji = is.read_string()?;
                },
                16 => {
                    self.authorId = is.read_uint64()?;
                },
                24 => {
                    self.sentTimestamp = is.read_uint64()?;
                },
                32 => {
                    self.sortOrder = is.read_uint64()?;
                },
                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.emoji.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.emoji);
        }
        if self.authorId != 0 {
            my_size += ::protobuf::rt::uint64_size(2, self.authorId);
        }
        if self.sentTimestamp != 0 {
            my_size += ::protobuf::rt::uint64_size(3, self.sentTimestamp);
        }
        if self.sortOrder != 0 {
            my_size += ::protobuf::rt::uint64_size(4, self.sortOrder);
        }
        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.emoji.is_empty() {
            os.write_string(1, &self.emoji)?;
        }
        if self.authorId != 0 {
            os.write_uint64(2, self.authorId)?;
        }
        if self.sentTimestamp != 0 {
            os.write_uint64(3, self.sentTimestamp)?;
        }
        if self.sortOrder != 0 {
            os.write_uint64(4, self.sortOrder)?;
        }
        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() -> Reaction {
        Reaction::new()
    }

    fn clear(&mut self) {
        self.emoji.clear();
        self.authorId = 0;
        self.sentTimestamp = 0;
        self.sortOrder = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Reaction {
        static instance: Reaction = Reaction {
            emoji: ::std::string::String::new(),
            authorId: 0,
            sentTimestamp: 0,
            sortOrder: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.Poll)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Poll {
    // message fields
    #[field_name("question")]
    // @@protoc_insertion_point(field:signal.backup.Poll.question)
    pub question: ::std::string::String,
    #[field_name("allowMultiple")]
    // @@protoc_insertion_point(field:signal.backup.Poll.allowMultiple)
    pub allowMultiple: bool,
    #[field_name("options")]
    // @@protoc_insertion_point(field:signal.backup.Poll.options)
    pub options: ::std::vec::Vec<poll::PollOption>,
    #[field_name("hasEnded")]
    // @@protoc_insertion_point(field:signal.backup.Poll.hasEnded)
    pub hasEnded: bool,
    #[field_name("reactions")]
    // @@protoc_insertion_point(field:signal.backup.Poll.reactions)
    pub reactions: ::std::vec::Vec<Reaction>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.Poll.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.question = is.read_string()?;
                },
                16 => {
                    self.allowMultiple = is.read_bool()?;
                },
                26 => {
                    self.options.push(is.read_message()?);
                },
                32 => {
                    self.hasEnded = is.read_bool()?;
                },
                42 => {
                    self.reactions.push(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 !self.question.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.question);
        }
        if self.allowMultiple != false {
            my_size += 1 + 1;
        }
        for value in &self.options {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if self.hasEnded != false {
            my_size += 1 + 1;
        }
        for value in &self.reactions {
            let len = value.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 !self.question.is_empty() {
            os.write_string(1, &self.question)?;
        }
        if self.allowMultiple != false {
            os.write_bool(2, self.allowMultiple)?;
        }
        for v in &self.options {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        if self.hasEnded != false {
            os.write_bool(4, self.hasEnded)?;
        }
        for v in &self.reactions {
            ::protobuf::rt::write_message_field_with_cached_size(5, 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() -> Poll {
        Poll::new()
    }

    fn clear(&mut self) {
        self.question.clear();
        self.allowMultiple = false;
        self.options.clear();
        self.hasEnded = false;
        self.reactions.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Poll {
        static instance: Poll = Poll {
            question: ::std::string::String::new(),
            allowMultiple: false,
            options: ::std::vec::Vec::new(),
            hasEnded: false,
            reactions: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `Poll`
pub mod poll {
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.Poll.PollOption)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PollOption {
        // message fields
        #[field_name("option")]
        // @@protoc_insertion_point(field:signal.backup.Poll.PollOption.option)
        pub option: ::std::string::String,
        #[field_name("votes")]
        // @@protoc_insertion_point(field:signal.backup.Poll.PollOption.votes)
        pub votes: ::std::vec::Vec<poll_option::PollVote>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.Poll.PollOption.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.option = is.read_string()?;
                    },
                    18 => {
                        self.votes.push(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 !self.option.is_empty() {
                my_size += ::protobuf::rt::string_size(1, &self.option);
            }
            for value in &self.votes {
                let len = value.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 !self.option.is_empty() {
                os.write_string(1, &self.option)?;
            }
            for v in &self.votes {
                ::protobuf::rt::write_message_field_with_cached_size(2, 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() -> PollOption {
            PollOption::new()
        }

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

        fn default_instance() -> &'static PollOption {
            static instance: PollOption = PollOption {
                option: ::std::string::String::new(),
                votes: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    /// Nested message and enums of message `PollOption`
    pub mod poll_option {
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(message:signal.backup.Poll.PollOption.PollVote)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct PollVote {
            // message fields
            #[field_name("voterId")]
            // @@protoc_insertion_point(field:signal.backup.Poll.PollOption.PollVote.voterId)
            pub voterId: u64,
            #[field_name("voteCount")]
            // @@protoc_insertion_point(field:signal.backup.Poll.PollOption.PollVote.voteCount)
            pub voteCount: u32,
            // special fields
            // @@protoc_insertion_point(special_field:signal.backup.Poll.PollOption.PollVote.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

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

            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.voterId = is.read_uint64()?;
                        },
                        16 => {
                            self.voteCount = 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.voterId != 0 {
                    my_size += ::protobuf::rt::uint64_size(1, self.voterId);
                }
                if self.voteCount != 0 {
                    my_size += ::protobuf::rt::uint32_size(2, self.voteCount);
                }
                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.voterId != 0 {
                    os.write_uint64(1, self.voterId)?;
                }
                if self.voteCount != 0 {
                    os.write_uint32(2, self.voteCount)?;
                }
                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() -> PollVote {
                PollVote::new()
            }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.AdminDeletedMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AdminDeletedMessage {
    // message fields
    #[field_name("adminId")]
    // @@protoc_insertion_point(field:signal.backup.AdminDeletedMessage.adminId)
    pub adminId: u64,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.AdminDeletedMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.adminId = is.read_uint64()?;
                },
                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.adminId != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.adminId);
        }
        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.adminId != 0 {
            os.write_uint64(1, self.adminId)?;
        }
        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() -> AdminDeletedMessage {
        AdminDeletedMessage::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ChatUpdateMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ChatUpdateMessage {
    // message oneof groups
    pub update: ::std::option::Option<chat_update_message::Update>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ChatUpdateMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .signal.backup.SimpleChatUpdate simpleUpdate = 1;

    pub fn simpleUpdate(&self) -> &SimpleChatUpdate {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::SimpleUpdate(ref v)) => v,
            _ => <SimpleChatUpdate as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_simpleUpdate(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::SimpleUpdate(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_simpleUpdate(&mut self, v: SimpleChatUpdate) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::SimpleUpdate(v))
    }

    // Mutable pointer to the field.
    pub fn mut_simpleUpdate(&mut self) -> &mut SimpleChatUpdate {
        if let ::std::option::Option::Some(chat_update_message::Update::SimpleUpdate(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::SimpleUpdate(SimpleChatUpdate::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::SimpleUpdate(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_simpleUpdate(&mut self) -> SimpleChatUpdate {
        if self.has_simpleUpdate() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::SimpleUpdate(v)) => v,
                _ => panic!(),
            }
        } else {
            SimpleChatUpdate::new()
        }
    }

    // .signal.backup.GroupChangeChatUpdate groupChange = 2;

    pub fn groupChange(&self) -> &GroupChangeChatUpdate {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::GroupChange(ref v)) => v,
            _ => <GroupChangeChatUpdate as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_groupChange(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::GroupChange(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_groupChange(&mut self, v: GroupChangeChatUpdate) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::GroupChange(v))
    }

    // Mutable pointer to the field.
    pub fn mut_groupChange(&mut self) -> &mut GroupChangeChatUpdate {
        if let ::std::option::Option::Some(chat_update_message::Update::GroupChange(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::GroupChange(GroupChangeChatUpdate::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::GroupChange(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_groupChange(&mut self) -> GroupChangeChatUpdate {
        if self.has_groupChange() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::GroupChange(v)) => v,
                _ => panic!(),
            }
        } else {
            GroupChangeChatUpdate::new()
        }
    }

    // .signal.backup.ExpirationTimerChatUpdate expirationTimerChange = 3;

    pub fn expirationTimerChange(&self) -> &ExpirationTimerChatUpdate {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::ExpirationTimerChange(ref v)) => v,
            _ => <ExpirationTimerChatUpdate as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_expirationTimerChange(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::ExpirationTimerChange(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_expirationTimerChange(&mut self, v: ExpirationTimerChatUpdate) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::ExpirationTimerChange(v))
    }

    // Mutable pointer to the field.
    pub fn mut_expirationTimerChange(&mut self) -> &mut ExpirationTimerChatUpdate {
        if let ::std::option::Option::Some(chat_update_message::Update::ExpirationTimerChange(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::ExpirationTimerChange(ExpirationTimerChatUpdate::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::ExpirationTimerChange(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_expirationTimerChange(&mut self) -> ExpirationTimerChatUpdate {
        if self.has_expirationTimerChange() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::ExpirationTimerChange(v)) => v,
                _ => panic!(),
            }
        } else {
            ExpirationTimerChatUpdate::new()
        }
    }

    // .signal.backup.ProfileChangeChatUpdate profileChange = 4;

    pub fn profileChange(&self) -> &ProfileChangeChatUpdate {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::ProfileChange(ref v)) => v,
            _ => <ProfileChangeChatUpdate as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_profileChange(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::ProfileChange(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_profileChange(&mut self, v: ProfileChangeChatUpdate) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::ProfileChange(v))
    }

    // Mutable pointer to the field.
    pub fn mut_profileChange(&mut self) -> &mut ProfileChangeChatUpdate {
        if let ::std::option::Option::Some(chat_update_message::Update::ProfileChange(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::ProfileChange(ProfileChangeChatUpdate::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::ProfileChange(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_profileChange(&mut self) -> ProfileChangeChatUpdate {
        if self.has_profileChange() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::ProfileChange(v)) => v,
                _ => panic!(),
            }
        } else {
            ProfileChangeChatUpdate::new()
        }
    }

    // .signal.backup.ThreadMergeChatUpdate threadMerge = 5;

    pub fn threadMerge(&self) -> &ThreadMergeChatUpdate {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::ThreadMerge(ref v)) => v,
            _ => <ThreadMergeChatUpdate as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_threadMerge(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::ThreadMerge(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_threadMerge(&mut self, v: ThreadMergeChatUpdate) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::ThreadMerge(v))
    }

    // Mutable pointer to the field.
    pub fn mut_threadMerge(&mut self) -> &mut ThreadMergeChatUpdate {
        if let ::std::option::Option::Some(chat_update_message::Update::ThreadMerge(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::ThreadMerge(ThreadMergeChatUpdate::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::ThreadMerge(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_threadMerge(&mut self) -> ThreadMergeChatUpdate {
        if self.has_threadMerge() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::ThreadMerge(v)) => v,
                _ => panic!(),
            }
        } else {
            ThreadMergeChatUpdate::new()
        }
    }

    // .signal.backup.SessionSwitchoverChatUpdate sessionSwitchover = 6;

    pub fn sessionSwitchover(&self) -> &SessionSwitchoverChatUpdate {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::SessionSwitchover(ref v)) => v,
            _ => <SessionSwitchoverChatUpdate as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_sessionSwitchover(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::SessionSwitchover(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_sessionSwitchover(&mut self, v: SessionSwitchoverChatUpdate) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::SessionSwitchover(v))
    }

    // Mutable pointer to the field.
    pub fn mut_sessionSwitchover(&mut self) -> &mut SessionSwitchoverChatUpdate {
        if let ::std::option::Option::Some(chat_update_message::Update::SessionSwitchover(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::SessionSwitchover(SessionSwitchoverChatUpdate::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::SessionSwitchover(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_sessionSwitchover(&mut self) -> SessionSwitchoverChatUpdate {
        if self.has_sessionSwitchover() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::SessionSwitchover(v)) => v,
                _ => panic!(),
            }
        } else {
            SessionSwitchoverChatUpdate::new()
        }
    }

    // .signal.backup.IndividualCall individualCall = 7;

    pub fn individualCall(&self) -> &IndividualCall {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::IndividualCall(ref v)) => v,
            _ => <IndividualCall as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_individualCall(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::IndividualCall(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_individualCall(&mut self, v: IndividualCall) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::IndividualCall(v))
    }

    // Mutable pointer to the field.
    pub fn mut_individualCall(&mut self) -> &mut IndividualCall {
        if let ::std::option::Option::Some(chat_update_message::Update::IndividualCall(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::IndividualCall(IndividualCall::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::IndividualCall(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_individualCall(&mut self) -> IndividualCall {
        if self.has_individualCall() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::IndividualCall(v)) => v,
                _ => panic!(),
            }
        } else {
            IndividualCall::new()
        }
    }

    // .signal.backup.GroupCall groupCall = 8;

    pub fn groupCall(&self) -> &GroupCall {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::GroupCall(ref v)) => v,
            _ => <GroupCall as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_groupCall(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::GroupCall(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_groupCall(&mut self, v: GroupCall) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::GroupCall(v))
    }

    // Mutable pointer to the field.
    pub fn mut_groupCall(&mut self) -> &mut GroupCall {
        if let ::std::option::Option::Some(chat_update_message::Update::GroupCall(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::GroupCall(GroupCall::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::GroupCall(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_groupCall(&mut self) -> GroupCall {
        if self.has_groupCall() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::GroupCall(v)) => v,
                _ => panic!(),
            }
        } else {
            GroupCall::new()
        }
    }

    // .signal.backup.LearnedProfileChatUpdate learnedProfileChange = 9;

    pub fn learnedProfileChange(&self) -> &LearnedProfileChatUpdate {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::LearnedProfileChange(ref v)) => v,
            _ => <LearnedProfileChatUpdate as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_learnedProfileChange(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::LearnedProfileChange(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_learnedProfileChange(&mut self, v: LearnedProfileChatUpdate) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::LearnedProfileChange(v))
    }

    // Mutable pointer to the field.
    pub fn mut_learnedProfileChange(&mut self) -> &mut LearnedProfileChatUpdate {
        if let ::std::option::Option::Some(chat_update_message::Update::LearnedProfileChange(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::LearnedProfileChange(LearnedProfileChatUpdate::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::LearnedProfileChange(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_learnedProfileChange(&mut self) -> LearnedProfileChatUpdate {
        if self.has_learnedProfileChange() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::LearnedProfileChange(v)) => v,
                _ => panic!(),
            }
        } else {
            LearnedProfileChatUpdate::new()
        }
    }

    // .signal.backup.PollTerminateUpdate pollTerminate = 10;

    pub fn pollTerminate(&self) -> &PollTerminateUpdate {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::PollTerminate(ref v)) => v,
            _ => <PollTerminateUpdate as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_pollTerminate(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::PollTerminate(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_pollTerminate(&mut self, v: PollTerminateUpdate) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::PollTerminate(v))
    }

    // Mutable pointer to the field.
    pub fn mut_pollTerminate(&mut self) -> &mut PollTerminateUpdate {
        if let ::std::option::Option::Some(chat_update_message::Update::PollTerminate(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::PollTerminate(PollTerminateUpdate::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::PollTerminate(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_pollTerminate(&mut self) -> PollTerminateUpdate {
        if self.has_pollTerminate() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::PollTerminate(v)) => v,
                _ => panic!(),
            }
        } else {
            PollTerminateUpdate::new()
        }
    }

    // .signal.backup.PinMessageUpdate pinMessage = 11;

    pub fn pinMessage(&self) -> &PinMessageUpdate {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::PinMessage(ref v)) => v,
            _ => <PinMessageUpdate as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_pinMessage(&self) -> bool {
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::PinMessage(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_pinMessage(&mut self, v: PinMessageUpdate) {
        self.update = ::std::option::Option::Some(chat_update_message::Update::PinMessage(v))
    }

    // Mutable pointer to the field.
    pub fn mut_pinMessage(&mut self) -> &mut PinMessageUpdate {
        if let ::std::option::Option::Some(chat_update_message::Update::PinMessage(_)) = self.update {
        } else {
            self.update = ::std::option::Option::Some(chat_update_message::Update::PinMessage(PinMessageUpdate::new()));
        }
        match self.update {
            ::std::option::Option::Some(chat_update_message::Update::PinMessage(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_pinMessage(&mut self) -> PinMessageUpdate {
        if self.has_pinMessage() {
            match self.update.take() {
                ::std::option::Option::Some(chat_update_message::Update::PinMessage(v)) => v,
                _ => panic!(),
            }
        } else {
            PinMessageUpdate::new()
        }
    }
}

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

    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.update = ::std::option::Option::Some(chat_update_message::Update::SimpleUpdate(is.read_message()?));
                },
                18 => {
                    self.update = ::std::option::Option::Some(chat_update_message::Update::GroupChange(is.read_message()?));
                },
                26 => {
                    self.update = ::std::option::Option::Some(chat_update_message::Update::ExpirationTimerChange(is.read_message()?));
                },
                34 => {
                    self.update = ::std::option::Option::Some(chat_update_message::Update::ProfileChange(is.read_message()?));
                },
                42 => {
                    self.update = ::std::option::Option::Some(chat_update_message::Update::ThreadMerge(is.read_message()?));
                },
                50 => {
                    self.update = ::std::option::Option::Some(chat_update_message::Update::SessionSwitchover(is.read_message()?));
                },
                58 => {
                    self.update = ::std::option::Option::Some(chat_update_message::Update::IndividualCall(is.read_message()?));
                },
                66 => {
                    self.update = ::std::option::Option::Some(chat_update_message::Update::GroupCall(is.read_message()?));
                },
                74 => {
                    self.update = ::std::option::Option::Some(chat_update_message::Update::LearnedProfileChange(is.read_message()?));
                },
                82 => {
                    self.update = ::std::option::Option::Some(chat_update_message::Update::PollTerminate(is.read_message()?));
                },
                90 => {
                    self.update = ::std::option::Option::Some(chat_update_message::Update::PinMessage(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.update {
            match v {
                &chat_update_message::Update::SimpleUpdate(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_update_message::Update::GroupChange(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_update_message::Update::ExpirationTimerChange(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_update_message::Update::ProfileChange(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_update_message::Update::ThreadMerge(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_update_message::Update::SessionSwitchover(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_update_message::Update::IndividualCall(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_update_message::Update::GroupCall(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_update_message::Update::LearnedProfileChange(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_update_message::Update::PollTerminate(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_update_message::Update::PinMessage(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.update {
            match v {
                &chat_update_message::Update::SimpleUpdate(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                },
                &chat_update_message::Update::GroupChange(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
                &chat_update_message::Update::ExpirationTimerChange(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &chat_update_message::Update::ProfileChange(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &chat_update_message::Update::ThreadMerge(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &chat_update_message::Update::SessionSwitchover(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &chat_update_message::Update::IndividualCall(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
                &chat_update_message::Update::GroupCall(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
                },
                &chat_update_message::Update::LearnedProfileChange(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
                },
                &chat_update_message::Update::PollTerminate(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
                },
                &chat_update_message::Update::PinMessage(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(11, 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() -> ChatUpdateMessage {
        ChatUpdateMessage::new()
    }

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

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

/// Nested message and enums of message `ChatUpdateMessage`
pub mod chat_update_message {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.ChatUpdateMessage.update)
    pub enum Update {
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.simpleUpdate)
        SimpleUpdate(super::SimpleChatUpdate),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.groupChange)
        GroupChange(super::GroupChangeChatUpdate),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.expirationTimerChange)
        ExpirationTimerChange(super::ExpirationTimerChatUpdate),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.profileChange)
        ProfileChange(super::ProfileChangeChatUpdate),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.threadMerge)
        ThreadMerge(super::ThreadMergeChatUpdate),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.sessionSwitchover)
        SessionSwitchover(super::SessionSwitchoverChatUpdate),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.individualCall)
        IndividualCall(super::IndividualCall),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.groupCall)
        GroupCall(super::GroupCall),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.learnedProfileChange)
        LearnedProfileChange(super::LearnedProfileChatUpdate),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.pollTerminate)
        PollTerminate(super::PollTerminateUpdate),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatUpdateMessage.pinMessage)
        PinMessage(super::PinMessageUpdate),
    }

    impl ::protobuf::Oneof for Update {
    }

    impl Update {
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.IndividualCall)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct IndividualCall {
    // message fields
    #[field_name("callId")]
    // @@protoc_insertion_point(field:signal.backup.IndividualCall.callId)
    pub callId: ::std::option::Option<u64>,
    #[field_name("type")]
    // @@protoc_insertion_point(field:signal.backup.IndividualCall.type)
    pub type_: ::protobuf::EnumOrUnknown<individual_call::Type>,
    #[field_name("direction")]
    // @@protoc_insertion_point(field:signal.backup.IndividualCall.direction)
    pub direction: ::protobuf::EnumOrUnknown<individual_call::Direction>,
    #[field_name("state")]
    // @@protoc_insertion_point(field:signal.backup.IndividualCall.state)
    pub state: ::protobuf::EnumOrUnknown<individual_call::State>,
    #[field_name("startedCallTimestamp")]
    // @@protoc_insertion_point(field:signal.backup.IndividualCall.startedCallTimestamp)
    pub startedCallTimestamp: u64,
    #[field_name("read")]
    // @@protoc_insertion_point(field:signal.backup.IndividualCall.read)
    pub read: bool,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.IndividualCall.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.callId = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.type_ = is.read_enum_or_unknown()?;
                },
                24 => {
                    self.direction = is.read_enum_or_unknown()?;
                },
                32 => {
                    self.state = is.read_enum_or_unknown()?;
                },
                40 => {
                    self.startedCallTimestamp = is.read_uint64()?;
                },
                48 => {
                    self.read = is.read_bool()?;
                },
                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 Some(v) = self.callId {
            my_size += ::protobuf::rt::uint64_size(1, v);
        }
        if self.type_ != ::protobuf::EnumOrUnknown::new(individual_call::Type::UNKNOWN_TYPE) {
            my_size += ::protobuf::rt::int32_size(2, self.type_.value());
        }
        if self.direction != ::protobuf::EnumOrUnknown::new(individual_call::Direction::UNKNOWN_DIRECTION) {
            my_size += ::protobuf::rt::int32_size(3, self.direction.value());
        }
        if self.state != ::protobuf::EnumOrUnknown::new(individual_call::State::UNKNOWN_STATE) {
            my_size += ::protobuf::rt::int32_size(4, self.state.value());
        }
        if self.startedCallTimestamp != 0 {
            my_size += ::protobuf::rt::uint64_size(5, self.startedCallTimestamp);
        }
        if self.read != false {
            my_size += 1 + 1;
        }
        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 Some(v) = self.callId {
            os.write_uint64(1, v)?;
        }
        if self.type_ != ::protobuf::EnumOrUnknown::new(individual_call::Type::UNKNOWN_TYPE) {
            os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.type_))?;
        }
        if self.direction != ::protobuf::EnumOrUnknown::new(individual_call::Direction::UNKNOWN_DIRECTION) {
            os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.direction))?;
        }
        if self.state != ::protobuf::EnumOrUnknown::new(individual_call::State::UNKNOWN_STATE) {
            os.write_enum(4, ::protobuf::EnumOrUnknown::value(&self.state))?;
        }
        if self.startedCallTimestamp != 0 {
            os.write_uint64(5, self.startedCallTimestamp)?;
        }
        if self.read != false {
            os.write_bool(6, self.read)?;
        }
        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() -> IndividualCall {
        IndividualCall::new()
    }

    fn clear(&mut self) {
        self.callId = ::std::option::Option::None;
        self.type_ = ::protobuf::EnumOrUnknown::new(individual_call::Type::UNKNOWN_TYPE);
        self.direction = ::protobuf::EnumOrUnknown::new(individual_call::Direction::UNKNOWN_DIRECTION);
        self.state = ::protobuf::EnumOrUnknown::new(individual_call::State::UNKNOWN_STATE);
        self.startedCallTimestamp = 0;
        self.read = false;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static IndividualCall {
        static instance: IndividualCall = IndividualCall {
            callId: ::std::option::Option::None,
            type_: ::protobuf::EnumOrUnknown::from_i32(0),
            direction: ::protobuf::EnumOrUnknown::from_i32(0),
            state: ::protobuf::EnumOrUnknown::from_i32(0),
            startedCallTimestamp: 0,
            read: false,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `IndividualCall`
pub mod individual_call {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.IndividualCall.Type)
    pub enum Type {
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.Type.UNKNOWN_TYPE)
        UNKNOWN_TYPE = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.Type.AUDIO_CALL)
        AUDIO_CALL = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.Type.VIDEO_CALL)
        VIDEO_CALL = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<Type> {
            match value {
                0 => ::std::option::Option::Some(Type::UNKNOWN_TYPE),
                1 => ::std::option::Option::Some(Type::AUDIO_CALL),
                2 => ::std::option::Option::Some(Type::VIDEO_CALL),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Type> {
            match str {
                "UNKNOWN_TYPE" => ::std::option::Option::Some(Type::UNKNOWN_TYPE),
                "AUDIO_CALL" => ::std::option::Option::Some(Type::AUDIO_CALL),
                "VIDEO_CALL" => ::std::option::Option::Some(Type::VIDEO_CALL),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Type] = &[
            Type::UNKNOWN_TYPE,
            Type::AUDIO_CALL,
            Type::VIDEO_CALL,
        ];
    }

    impl ::std::default::Default for Type {
        fn default() -> Self {
            Type::UNKNOWN_TYPE
        }
    }


    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.IndividualCall.Direction)
    pub enum Direction {
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.Direction.UNKNOWN_DIRECTION)
        UNKNOWN_DIRECTION = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.Direction.INCOMING)
        INCOMING = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.Direction.OUTGOING)
        OUTGOING = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<Direction> {
            match value {
                0 => ::std::option::Option::Some(Direction::UNKNOWN_DIRECTION),
                1 => ::std::option::Option::Some(Direction::INCOMING),
                2 => ::std::option::Option::Some(Direction::OUTGOING),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Direction> {
            match str {
                "UNKNOWN_DIRECTION" => ::std::option::Option::Some(Direction::UNKNOWN_DIRECTION),
                "INCOMING" => ::std::option::Option::Some(Direction::INCOMING),
                "OUTGOING" => ::std::option::Option::Some(Direction::OUTGOING),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Direction] = &[
            Direction::UNKNOWN_DIRECTION,
            Direction::INCOMING,
            Direction::OUTGOING,
        ];
    }

    impl ::std::default::Default for Direction {
        fn default() -> Self {
            Direction::UNKNOWN_DIRECTION
        }
    }


    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.IndividualCall.State)
    pub enum State {
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.State.UNKNOWN_STATE)
        UNKNOWN_STATE = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.State.ACCEPTED)
        ACCEPTED = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.State.NOT_ACCEPTED)
        NOT_ACCEPTED = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.State.MISSED)
        MISSED = 3,
        // @@protoc_insertion_point(enum_value:signal.backup.IndividualCall.State.MISSED_NOTIFICATION_PROFILE)
        MISSED_NOTIFICATION_PROFILE = 4,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<State> {
            match value {
                0 => ::std::option::Option::Some(State::UNKNOWN_STATE),
                1 => ::std::option::Option::Some(State::ACCEPTED),
                2 => ::std::option::Option::Some(State::NOT_ACCEPTED),
                3 => ::std::option::Option::Some(State::MISSED),
                4 => ::std::option::Option::Some(State::MISSED_NOTIFICATION_PROFILE),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<State> {
            match str {
                "UNKNOWN_STATE" => ::std::option::Option::Some(State::UNKNOWN_STATE),
                "ACCEPTED" => ::std::option::Option::Some(State::ACCEPTED),
                "NOT_ACCEPTED" => ::std::option::Option::Some(State::NOT_ACCEPTED),
                "MISSED" => ::std::option::Option::Some(State::MISSED),
                "MISSED_NOTIFICATION_PROFILE" => ::std::option::Option::Some(State::MISSED_NOTIFICATION_PROFILE),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [State] = &[
            State::UNKNOWN_STATE,
            State::ACCEPTED,
            State::NOT_ACCEPTED,
            State::MISSED,
            State::MISSED_NOTIFICATION_PROFILE,
        ];
    }

    impl ::std::default::Default for State {
        fn default() -> Self {
            State::UNKNOWN_STATE
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupCall)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupCall {
    // message fields
    #[field_name("callId")]
    // @@protoc_insertion_point(field:signal.backup.GroupCall.callId)
    pub callId: ::std::option::Option<u64>,
    #[field_name("state")]
    // @@protoc_insertion_point(field:signal.backup.GroupCall.state)
    pub state: ::protobuf::EnumOrUnknown<group_call::State>,
    #[field_name("ringerRecipientId")]
    // @@protoc_insertion_point(field:signal.backup.GroupCall.ringerRecipientId)
    pub ringerRecipientId: ::std::option::Option<u64>,
    #[field_name("startedCallRecipientId")]
    // @@protoc_insertion_point(field:signal.backup.GroupCall.startedCallRecipientId)
    pub startedCallRecipientId: ::std::option::Option<u64>,
    #[field_name("startedCallTimestamp")]
    // @@protoc_insertion_point(field:signal.backup.GroupCall.startedCallTimestamp)
    pub startedCallTimestamp: u64,
    #[field_name("endedCallTimestamp")]
    // @@protoc_insertion_point(field:signal.backup.GroupCall.endedCallTimestamp)
    pub endedCallTimestamp: ::std::option::Option<u64>,
    #[field_name("read")]
    // @@protoc_insertion_point(field:signal.backup.GroupCall.read)
    pub read: bool,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupCall.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.callId = ::std::option::Option::Some(is.read_uint64()?);
                },
                16 => {
                    self.state = is.read_enum_or_unknown()?;
                },
                24 => {
                    self.ringerRecipientId = ::std::option::Option::Some(is.read_uint64()?);
                },
                32 => {
                    self.startedCallRecipientId = ::std::option::Option::Some(is.read_uint64()?);
                },
                40 => {
                    self.startedCallTimestamp = is.read_uint64()?;
                },
                48 => {
                    self.endedCallTimestamp = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.read = is.read_bool()?;
                },
                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 Some(v) = self.callId {
            my_size += ::protobuf::rt::uint64_size(1, v);
        }
        if self.state != ::protobuf::EnumOrUnknown::new(group_call::State::UNKNOWN_STATE) {
            my_size += ::protobuf::rt::int32_size(2, self.state.value());
        }
        if let Some(v) = self.ringerRecipientId {
            my_size += ::protobuf::rt::uint64_size(3, v);
        }
        if let Some(v) = self.startedCallRecipientId {
            my_size += ::protobuf::rt::uint64_size(4, v);
        }
        if self.startedCallTimestamp != 0 {
            my_size += ::protobuf::rt::uint64_size(5, self.startedCallTimestamp);
        }
        if let Some(v) = self.endedCallTimestamp {
            my_size += ::protobuf::rt::uint64_size(6, v);
        }
        if self.read != false {
            my_size += 1 + 1;
        }
        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 Some(v) = self.callId {
            os.write_uint64(1, v)?;
        }
        if self.state != ::protobuf::EnumOrUnknown::new(group_call::State::UNKNOWN_STATE) {
            os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.state))?;
        }
        if let Some(v) = self.ringerRecipientId {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.startedCallRecipientId {
            os.write_uint64(4, v)?;
        }
        if self.startedCallTimestamp != 0 {
            os.write_uint64(5, self.startedCallTimestamp)?;
        }
        if let Some(v) = self.endedCallTimestamp {
            os.write_uint64(6, v)?;
        }
        if self.read != false {
            os.write_bool(7, self.read)?;
        }
        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() -> GroupCall {
        GroupCall::new()
    }

    fn clear(&mut self) {
        self.callId = ::std::option::Option::None;
        self.state = ::protobuf::EnumOrUnknown::new(group_call::State::UNKNOWN_STATE);
        self.ringerRecipientId = ::std::option::Option::None;
        self.startedCallRecipientId = ::std::option::Option::None;
        self.startedCallTimestamp = 0;
        self.endedCallTimestamp = ::std::option::Option::None;
        self.read = false;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GroupCall {
        static instance: GroupCall = GroupCall {
            callId: ::std::option::Option::None,
            state: ::protobuf::EnumOrUnknown::from_i32(0),
            ringerRecipientId: ::std::option::Option::None,
            startedCallRecipientId: ::std::option::Option::None,
            startedCallTimestamp: 0,
            endedCallTimestamp: ::std::option::Option::None,
            read: false,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `GroupCall`
pub mod group_call {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.GroupCall.State)
    pub enum State {
        // @@protoc_insertion_point(enum_value:signal.backup.GroupCall.State.UNKNOWN_STATE)
        UNKNOWN_STATE = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.GroupCall.State.GENERIC)
        GENERIC = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.GroupCall.State.JOINED)
        JOINED = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.GroupCall.State.RINGING)
        RINGING = 3,
        // @@protoc_insertion_point(enum_value:signal.backup.GroupCall.State.ACCEPTED)
        ACCEPTED = 4,
        // @@protoc_insertion_point(enum_value:signal.backup.GroupCall.State.DECLINED)
        DECLINED = 5,
        // @@protoc_insertion_point(enum_value:signal.backup.GroupCall.State.MISSED)
        MISSED = 6,
        // @@protoc_insertion_point(enum_value:signal.backup.GroupCall.State.MISSED_NOTIFICATION_PROFILE)
        MISSED_NOTIFICATION_PROFILE = 7,
        // @@protoc_insertion_point(enum_value:signal.backup.GroupCall.State.OUTGOING_RING)
        OUTGOING_RING = 8,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<State> {
            match value {
                0 => ::std::option::Option::Some(State::UNKNOWN_STATE),
                1 => ::std::option::Option::Some(State::GENERIC),
                2 => ::std::option::Option::Some(State::JOINED),
                3 => ::std::option::Option::Some(State::RINGING),
                4 => ::std::option::Option::Some(State::ACCEPTED),
                5 => ::std::option::Option::Some(State::DECLINED),
                6 => ::std::option::Option::Some(State::MISSED),
                7 => ::std::option::Option::Some(State::MISSED_NOTIFICATION_PROFILE),
                8 => ::std::option::Option::Some(State::OUTGOING_RING),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<State> {
            match str {
                "UNKNOWN_STATE" => ::std::option::Option::Some(State::UNKNOWN_STATE),
                "GENERIC" => ::std::option::Option::Some(State::GENERIC),
                "JOINED" => ::std::option::Option::Some(State::JOINED),
                "RINGING" => ::std::option::Option::Some(State::RINGING),
                "ACCEPTED" => ::std::option::Option::Some(State::ACCEPTED),
                "DECLINED" => ::std::option::Option::Some(State::DECLINED),
                "MISSED" => ::std::option::Option::Some(State::MISSED),
                "MISSED_NOTIFICATION_PROFILE" => ::std::option::Option::Some(State::MISSED_NOTIFICATION_PROFILE),
                "OUTGOING_RING" => ::std::option::Option::Some(State::OUTGOING_RING),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [State] = &[
            State::UNKNOWN_STATE,
            State::GENERIC,
            State::JOINED,
            State::RINGING,
            State::ACCEPTED,
            State::DECLINED,
            State::MISSED,
            State::MISSED_NOTIFICATION_PROFILE,
            State::OUTGOING_RING,
        ];
    }

    impl ::std::default::Default for State {
        fn default() -> Self {
            State::UNKNOWN_STATE
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.SimpleChatUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SimpleChatUpdate {
    // message fields
    #[field_name("type")]
    // @@protoc_insertion_point(field:signal.backup.SimpleChatUpdate.type)
    pub type_: ::protobuf::EnumOrUnknown<simple_chat_update::Type>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.SimpleChatUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.type_ = 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.type_ != ::protobuf::EnumOrUnknown::new(simple_chat_update::Type::UNKNOWN) {
            my_size += ::protobuf::rt::int32_size(1, self.type_.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.type_ != ::protobuf::EnumOrUnknown::new(simple_chat_update::Type::UNKNOWN) {
            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.type_))?;
        }
        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() -> SimpleChatUpdate {
        SimpleChatUpdate::new()
    }

    fn clear(&mut self) {
        self.type_ = ::protobuf::EnumOrUnknown::new(simple_chat_update::Type::UNKNOWN);
        self.special_fields.clear();
    }

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

/// Nested message and enums of message `SimpleChatUpdate`
pub mod simple_chat_update {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.SimpleChatUpdate.Type)
    pub enum Type {
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.UNKNOWN)
        UNKNOWN = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.JOINED_SIGNAL)
        JOINED_SIGNAL = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.IDENTITY_UPDATE)
        IDENTITY_UPDATE = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.IDENTITY_VERIFIED)
        IDENTITY_VERIFIED = 3,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.IDENTITY_DEFAULT)
        IDENTITY_DEFAULT = 4,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.CHANGE_NUMBER)
        CHANGE_NUMBER = 5,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.RELEASE_CHANNEL_DONATION_REQUEST)
        RELEASE_CHANNEL_DONATION_REQUEST = 6,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.END_SESSION)
        END_SESSION = 7,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.CHAT_SESSION_REFRESH)
        CHAT_SESSION_REFRESH = 8,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.BAD_DECRYPT)
        BAD_DECRYPT = 9,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.PAYMENTS_ACTIVATED)
        PAYMENTS_ACTIVATED = 10,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.PAYMENT_ACTIVATION_REQUEST)
        PAYMENT_ACTIVATION_REQUEST = 11,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.UNSUPPORTED_PROTOCOL_MESSAGE)
        UNSUPPORTED_PROTOCOL_MESSAGE = 12,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.REPORTED_SPAM)
        REPORTED_SPAM = 13,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.BLOCKED)
        BLOCKED = 14,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.UNBLOCKED)
        UNBLOCKED = 15,
        // @@protoc_insertion_point(enum_value:signal.backup.SimpleChatUpdate.Type.MESSAGE_REQUEST_ACCEPTED)
        MESSAGE_REQUEST_ACCEPTED = 16,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<Type> {
            match value {
                0 => ::std::option::Option::Some(Type::UNKNOWN),
                1 => ::std::option::Option::Some(Type::JOINED_SIGNAL),
                2 => ::std::option::Option::Some(Type::IDENTITY_UPDATE),
                3 => ::std::option::Option::Some(Type::IDENTITY_VERIFIED),
                4 => ::std::option::Option::Some(Type::IDENTITY_DEFAULT),
                5 => ::std::option::Option::Some(Type::CHANGE_NUMBER),
                6 => ::std::option::Option::Some(Type::RELEASE_CHANNEL_DONATION_REQUEST),
                7 => ::std::option::Option::Some(Type::END_SESSION),
                8 => ::std::option::Option::Some(Type::CHAT_SESSION_REFRESH),
                9 => ::std::option::Option::Some(Type::BAD_DECRYPT),
                10 => ::std::option::Option::Some(Type::PAYMENTS_ACTIVATED),
                11 => ::std::option::Option::Some(Type::PAYMENT_ACTIVATION_REQUEST),
                12 => ::std::option::Option::Some(Type::UNSUPPORTED_PROTOCOL_MESSAGE),
                13 => ::std::option::Option::Some(Type::REPORTED_SPAM),
                14 => ::std::option::Option::Some(Type::BLOCKED),
                15 => ::std::option::Option::Some(Type::UNBLOCKED),
                16 => ::std::option::Option::Some(Type::MESSAGE_REQUEST_ACCEPTED),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Type> {
            match str {
                "UNKNOWN" => ::std::option::Option::Some(Type::UNKNOWN),
                "JOINED_SIGNAL" => ::std::option::Option::Some(Type::JOINED_SIGNAL),
                "IDENTITY_UPDATE" => ::std::option::Option::Some(Type::IDENTITY_UPDATE),
                "IDENTITY_VERIFIED" => ::std::option::Option::Some(Type::IDENTITY_VERIFIED),
                "IDENTITY_DEFAULT" => ::std::option::Option::Some(Type::IDENTITY_DEFAULT),
                "CHANGE_NUMBER" => ::std::option::Option::Some(Type::CHANGE_NUMBER),
                "RELEASE_CHANNEL_DONATION_REQUEST" => ::std::option::Option::Some(Type::RELEASE_CHANNEL_DONATION_REQUEST),
                "END_SESSION" => ::std::option::Option::Some(Type::END_SESSION),
                "CHAT_SESSION_REFRESH" => ::std::option::Option::Some(Type::CHAT_SESSION_REFRESH),
                "BAD_DECRYPT" => ::std::option::Option::Some(Type::BAD_DECRYPT),
                "PAYMENTS_ACTIVATED" => ::std::option::Option::Some(Type::PAYMENTS_ACTIVATED),
                "PAYMENT_ACTIVATION_REQUEST" => ::std::option::Option::Some(Type::PAYMENT_ACTIVATION_REQUEST),
                "UNSUPPORTED_PROTOCOL_MESSAGE" => ::std::option::Option::Some(Type::UNSUPPORTED_PROTOCOL_MESSAGE),
                "REPORTED_SPAM" => ::std::option::Option::Some(Type::REPORTED_SPAM),
                "BLOCKED" => ::std::option::Option::Some(Type::BLOCKED),
                "UNBLOCKED" => ::std::option::Option::Some(Type::UNBLOCKED),
                "MESSAGE_REQUEST_ACCEPTED" => ::std::option::Option::Some(Type::MESSAGE_REQUEST_ACCEPTED),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Type] = &[
            Type::UNKNOWN,
            Type::JOINED_SIGNAL,
            Type::IDENTITY_UPDATE,
            Type::IDENTITY_VERIFIED,
            Type::IDENTITY_DEFAULT,
            Type::CHANGE_NUMBER,
            Type::RELEASE_CHANNEL_DONATION_REQUEST,
            Type::END_SESSION,
            Type::CHAT_SESSION_REFRESH,
            Type::BAD_DECRYPT,
            Type::PAYMENTS_ACTIVATED,
            Type::PAYMENT_ACTIVATION_REQUEST,
            Type::UNSUPPORTED_PROTOCOL_MESSAGE,
            Type::REPORTED_SPAM,
            Type::BLOCKED,
            Type::UNBLOCKED,
            Type::MESSAGE_REQUEST_ACCEPTED,
        ];
    }

    impl ::std::default::Default for Type {
        fn default() -> Self {
            Type::UNKNOWN
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ExpirationTimerChatUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ExpirationTimerChatUpdate {
    // message fields
    #[field_name("expiresInMs")]
    // @@protoc_insertion_point(field:signal.backup.ExpirationTimerChatUpdate.expiresInMs)
    pub expiresInMs: u64,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ExpirationTimerChatUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.expiresInMs = is.read_uint64()?;
                },
                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.expiresInMs != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.expiresInMs);
        }
        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.expiresInMs != 0 {
            os.write_uint64(1, self.expiresInMs)?;
        }
        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() -> ExpirationTimerChatUpdate {
        ExpirationTimerChatUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ProfileChangeChatUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ProfileChangeChatUpdate {
    // message fields
    #[field_name("previousName")]
    // @@protoc_insertion_point(field:signal.backup.ProfileChangeChatUpdate.previousName)
    pub previousName: ::std::string::String,
    #[field_name("newName")]
    // @@protoc_insertion_point(field:signal.backup.ProfileChangeChatUpdate.newName)
    pub newName: ::std::string::String,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ProfileChangeChatUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.previousName = is.read_string()?;
                },
                18 => {
                    self.newName = is.read_string()?;
                },
                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.previousName.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.previousName);
        }
        if !self.newName.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.newName);
        }
        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.previousName.is_empty() {
            os.write_string(1, &self.previousName)?;
        }
        if !self.newName.is_empty() {
            os.write_string(2, &self.newName)?;
        }
        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() -> ProfileChangeChatUpdate {
        ProfileChangeChatUpdate::new()
    }

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

    fn default_instance() -> &'static ProfileChangeChatUpdate {
        static instance: ProfileChangeChatUpdate = ProfileChangeChatUpdate {
            previousName: ::std::string::String::new(),
            newName: ::std::string::String::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.LearnedProfileChatUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct LearnedProfileChatUpdate {
    // message oneof groups
    pub previousName: ::std::option::Option<learned_profile_chat_update::PreviousName>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.LearnedProfileChatUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // uint64 e164 = 1;

    pub fn e164(&self) -> u64 {
        match self.previousName {
            ::std::option::Option::Some(learned_profile_chat_update::PreviousName::E164(v)) => v,
            _ => 0,
        }
    }

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

    pub fn has_e164(&self) -> bool {
        match self.previousName {
            ::std::option::Option::Some(learned_profile_chat_update::PreviousName::E164(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_e164(&mut self, v: u64) {
        self.previousName = ::std::option::Option::Some(learned_profile_chat_update::PreviousName::E164(v))
    }

    // string username = 2;

    pub fn username(&self) -> &str {
        match self.previousName {
            ::std::option::Option::Some(learned_profile_chat_update::PreviousName::Username(ref v)) => v,
            _ => "",
        }
    }

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

    pub fn has_username(&self) -> bool {
        match self.previousName {
            ::std::option::Option::Some(learned_profile_chat_update::PreviousName::Username(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_username(&mut self, v: ::std::string::String) {
        self.previousName = ::std::option::Option::Some(learned_profile_chat_update::PreviousName::Username(v))
    }

    // Mutable pointer to the field.
    pub fn mut_username(&mut self) -> &mut ::std::string::String {
        if let ::std::option::Option::Some(learned_profile_chat_update::PreviousName::Username(_)) = self.previousName {
        } else {
            self.previousName = ::std::option::Option::Some(learned_profile_chat_update::PreviousName::Username(::std::string::String::new()));
        }
        match self.previousName {
            ::std::option::Option::Some(learned_profile_chat_update::PreviousName::Username(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_username(&mut self) -> ::std::string::String {
        if self.has_username() {
            match self.previousName.take() {
                ::std::option::Option::Some(learned_profile_chat_update::PreviousName::Username(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }
}

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

    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.previousName = ::std::option::Option::Some(learned_profile_chat_update::PreviousName::E164(is.read_uint64()?));
                },
                18 => {
                    self.previousName = ::std::option::Option::Some(learned_profile_chat_update::PreviousName::Username(is.read_string()?));
                },
                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.previousName {
            match v {
                &learned_profile_chat_update::PreviousName::E164(v) => {
                    my_size += ::protobuf::rt::uint64_size(1, v);
                },
                &learned_profile_chat_update::PreviousName::Username(ref v) => {
                    my_size += ::protobuf::rt::string_size(2, &v);
                },
            };
        }
        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.previousName {
            match v {
                &learned_profile_chat_update::PreviousName::E164(v) => {
                    os.write_uint64(1, v)?;
                },
                &learned_profile_chat_update::PreviousName::Username(ref v) => {
                    os.write_string(2, v)?;
                },
            };
        }
        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() -> LearnedProfileChatUpdate {
        LearnedProfileChatUpdate::new()
    }

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

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

/// Nested message and enums of message `LearnedProfileChatUpdate`
pub mod learned_profile_chat_update {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.LearnedProfileChatUpdate.previousName)
    pub enum PreviousName {
        // @@protoc_insertion_point(oneof_field:signal.backup.LearnedProfileChatUpdate.e164)
        E164(u64),
        // @@protoc_insertion_point(oneof_field:signal.backup.LearnedProfileChatUpdate.username)
        Username(::std::string::String),
    }

    impl ::protobuf::Oneof for PreviousName {
    }

    impl PreviousName {
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ThreadMergeChatUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ThreadMergeChatUpdate {
    // message fields
    #[field_name("previousE164")]
    // @@protoc_insertion_point(field:signal.backup.ThreadMergeChatUpdate.previousE164)
    pub previousE164: u64,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ThreadMergeChatUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.previousE164 = is.read_uint64()?;
                },
                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.previousE164 != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.previousE164);
        }
        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.previousE164 != 0 {
            os.write_uint64(1, self.previousE164)?;
        }
        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() -> ThreadMergeChatUpdate {
        ThreadMergeChatUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.SessionSwitchoverChatUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SessionSwitchoverChatUpdate {
    // message fields
    #[field_name("e164")]
    // @@protoc_insertion_point(field:signal.backup.SessionSwitchoverChatUpdate.e164)
    pub e164: u64,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.SessionSwitchoverChatUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.e164 = is.read_uint64()?;
                },
                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.e164 != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.e164);
        }
        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.e164 != 0 {
            os.write_uint64(1, self.e164)?;
        }
        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() -> SessionSwitchoverChatUpdate {
        SessionSwitchoverChatUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupChangeChatUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupChangeChatUpdate {
    // message fields
    #[field_name("updates")]
    // @@protoc_insertion_point(field:signal.backup.GroupChangeChatUpdate.updates)
    pub updates: ::std::vec::Vec<group_change_chat_update::Update>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupChangeChatUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updates.push(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;
        for value in &self.updates {
            let len = value.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<()> {
        for v in &self.updates {
            ::protobuf::rt::write_message_field_with_cached_size(1, 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() -> GroupChangeChatUpdate {
        GroupChangeChatUpdate::new()
    }

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

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

/// Nested message and enums of message `GroupChangeChatUpdate`
pub mod group_change_chat_update {
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.GroupChangeChatUpdate.Update)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Update {
        // message oneof groups
        pub update: ::std::option::Option<update::Update>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.GroupChangeChatUpdate.Update.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        // .signal.backup.GenericGroupUpdate genericGroupUpdate = 1;

        pub fn genericGroupUpdate(&self) -> &super::GenericGroupUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GenericGroupUpdate(ref v)) => v,
                _ => <super::GenericGroupUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_genericGroupUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GenericGroupUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_genericGroupUpdate(&mut self, v: super::GenericGroupUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GenericGroupUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_genericGroupUpdate(&mut self) -> &mut super::GenericGroupUpdate {
            if let ::std::option::Option::Some(update::Update::GenericGroupUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GenericGroupUpdate(super::GenericGroupUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GenericGroupUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_genericGroupUpdate(&mut self) -> super::GenericGroupUpdate {
            if self.has_genericGroupUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GenericGroupUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GenericGroupUpdate::new()
            }
        }

        // .signal.backup.GroupCreationUpdate groupCreationUpdate = 2;

        pub fn groupCreationUpdate(&self) -> &super::GroupCreationUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupCreationUpdate(ref v)) => v,
                _ => <super::GroupCreationUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupCreationUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupCreationUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupCreationUpdate(&mut self, v: super::GroupCreationUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupCreationUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupCreationUpdate(&mut self) -> &mut super::GroupCreationUpdate {
            if let ::std::option::Option::Some(update::Update::GroupCreationUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupCreationUpdate(super::GroupCreationUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupCreationUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupCreationUpdate(&mut self) -> super::GroupCreationUpdate {
            if self.has_groupCreationUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupCreationUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupCreationUpdate::new()
            }
        }

        // .signal.backup.GroupNameUpdate groupNameUpdate = 3;

        pub fn groupNameUpdate(&self) -> &super::GroupNameUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupNameUpdate(ref v)) => v,
                _ => <super::GroupNameUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupNameUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupNameUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupNameUpdate(&mut self, v: super::GroupNameUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupNameUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupNameUpdate(&mut self) -> &mut super::GroupNameUpdate {
            if let ::std::option::Option::Some(update::Update::GroupNameUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupNameUpdate(super::GroupNameUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupNameUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupNameUpdate(&mut self) -> super::GroupNameUpdate {
            if self.has_groupNameUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupNameUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupNameUpdate::new()
            }
        }

        // .signal.backup.GroupAvatarUpdate groupAvatarUpdate = 4;

        pub fn groupAvatarUpdate(&self) -> &super::GroupAvatarUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAvatarUpdate(ref v)) => v,
                _ => <super::GroupAvatarUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupAvatarUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAvatarUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupAvatarUpdate(&mut self, v: super::GroupAvatarUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupAvatarUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupAvatarUpdate(&mut self) -> &mut super::GroupAvatarUpdate {
            if let ::std::option::Option::Some(update::Update::GroupAvatarUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupAvatarUpdate(super::GroupAvatarUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAvatarUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupAvatarUpdate(&mut self) -> super::GroupAvatarUpdate {
            if self.has_groupAvatarUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupAvatarUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupAvatarUpdate::new()
            }
        }

        // .signal.backup.GroupDescriptionUpdate groupDescriptionUpdate = 5;

        pub fn groupDescriptionUpdate(&self) -> &super::GroupDescriptionUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupDescriptionUpdate(ref v)) => v,
                _ => <super::GroupDescriptionUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupDescriptionUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupDescriptionUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupDescriptionUpdate(&mut self, v: super::GroupDescriptionUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupDescriptionUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupDescriptionUpdate(&mut self) -> &mut super::GroupDescriptionUpdate {
            if let ::std::option::Option::Some(update::Update::GroupDescriptionUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupDescriptionUpdate(super::GroupDescriptionUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupDescriptionUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupDescriptionUpdate(&mut self) -> super::GroupDescriptionUpdate {
            if self.has_groupDescriptionUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupDescriptionUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupDescriptionUpdate::new()
            }
        }

        // .signal.backup.GroupMembershipAccessLevelChangeUpdate groupMembershipAccessLevelChangeUpdate = 6;

        pub fn groupMembershipAccessLevelChangeUpdate(&self) -> &super::GroupMembershipAccessLevelChangeUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMembershipAccessLevelChangeUpdate(ref v)) => v,
                _ => <super::GroupMembershipAccessLevelChangeUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupMembershipAccessLevelChangeUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMembershipAccessLevelChangeUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupMembershipAccessLevelChangeUpdate(&mut self, v: super::GroupMembershipAccessLevelChangeUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupMembershipAccessLevelChangeUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupMembershipAccessLevelChangeUpdate(&mut self) -> &mut super::GroupMembershipAccessLevelChangeUpdate {
            if let ::std::option::Option::Some(update::Update::GroupMembershipAccessLevelChangeUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupMembershipAccessLevelChangeUpdate(super::GroupMembershipAccessLevelChangeUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMembershipAccessLevelChangeUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupMembershipAccessLevelChangeUpdate(&mut self) -> super::GroupMembershipAccessLevelChangeUpdate {
            if self.has_groupMembershipAccessLevelChangeUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupMembershipAccessLevelChangeUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupMembershipAccessLevelChangeUpdate::new()
            }
        }

        // .signal.backup.GroupAttributesAccessLevelChangeUpdate groupAttributesAccessLevelChangeUpdate = 7;

        pub fn groupAttributesAccessLevelChangeUpdate(&self) -> &super::GroupAttributesAccessLevelChangeUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAttributesAccessLevelChangeUpdate(ref v)) => v,
                _ => <super::GroupAttributesAccessLevelChangeUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupAttributesAccessLevelChangeUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAttributesAccessLevelChangeUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupAttributesAccessLevelChangeUpdate(&mut self, v: super::GroupAttributesAccessLevelChangeUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupAttributesAccessLevelChangeUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupAttributesAccessLevelChangeUpdate(&mut self) -> &mut super::GroupAttributesAccessLevelChangeUpdate {
            if let ::std::option::Option::Some(update::Update::GroupAttributesAccessLevelChangeUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupAttributesAccessLevelChangeUpdate(super::GroupAttributesAccessLevelChangeUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAttributesAccessLevelChangeUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupAttributesAccessLevelChangeUpdate(&mut self) -> super::GroupAttributesAccessLevelChangeUpdate {
            if self.has_groupAttributesAccessLevelChangeUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupAttributesAccessLevelChangeUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupAttributesAccessLevelChangeUpdate::new()
            }
        }

        // .signal.backup.GroupAnnouncementOnlyChangeUpdate groupAnnouncementOnlyChangeUpdate = 8;

        pub fn groupAnnouncementOnlyChangeUpdate(&self) -> &super::GroupAnnouncementOnlyChangeUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAnnouncementOnlyChangeUpdate(ref v)) => v,
                _ => <super::GroupAnnouncementOnlyChangeUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupAnnouncementOnlyChangeUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAnnouncementOnlyChangeUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupAnnouncementOnlyChangeUpdate(&mut self, v: super::GroupAnnouncementOnlyChangeUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupAnnouncementOnlyChangeUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupAnnouncementOnlyChangeUpdate(&mut self) -> &mut super::GroupAnnouncementOnlyChangeUpdate {
            if let ::std::option::Option::Some(update::Update::GroupAnnouncementOnlyChangeUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupAnnouncementOnlyChangeUpdate(super::GroupAnnouncementOnlyChangeUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAnnouncementOnlyChangeUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupAnnouncementOnlyChangeUpdate(&mut self) -> super::GroupAnnouncementOnlyChangeUpdate {
            if self.has_groupAnnouncementOnlyChangeUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupAnnouncementOnlyChangeUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupAnnouncementOnlyChangeUpdate::new()
            }
        }

        // .signal.backup.GroupAdminStatusUpdate groupAdminStatusUpdate = 9;

        pub fn groupAdminStatusUpdate(&self) -> &super::GroupAdminStatusUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAdminStatusUpdate(ref v)) => v,
                _ => <super::GroupAdminStatusUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupAdminStatusUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAdminStatusUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupAdminStatusUpdate(&mut self, v: super::GroupAdminStatusUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupAdminStatusUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupAdminStatusUpdate(&mut self) -> &mut super::GroupAdminStatusUpdate {
            if let ::std::option::Option::Some(update::Update::GroupAdminStatusUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupAdminStatusUpdate(super::GroupAdminStatusUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupAdminStatusUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupAdminStatusUpdate(&mut self) -> super::GroupAdminStatusUpdate {
            if self.has_groupAdminStatusUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupAdminStatusUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupAdminStatusUpdate::new()
            }
        }

        // .signal.backup.GroupMemberLeftUpdate groupMemberLeftUpdate = 10;

        pub fn groupMemberLeftUpdate(&self) -> &super::GroupMemberLeftUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberLeftUpdate(ref v)) => v,
                _ => <super::GroupMemberLeftUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupMemberLeftUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberLeftUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupMemberLeftUpdate(&mut self, v: super::GroupMemberLeftUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupMemberLeftUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupMemberLeftUpdate(&mut self) -> &mut super::GroupMemberLeftUpdate {
            if let ::std::option::Option::Some(update::Update::GroupMemberLeftUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupMemberLeftUpdate(super::GroupMemberLeftUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberLeftUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupMemberLeftUpdate(&mut self) -> super::GroupMemberLeftUpdate {
            if self.has_groupMemberLeftUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupMemberLeftUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupMemberLeftUpdate::new()
            }
        }

        // .signal.backup.GroupMemberRemovedUpdate groupMemberRemovedUpdate = 11;

        pub fn groupMemberRemovedUpdate(&self) -> &super::GroupMemberRemovedUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberRemovedUpdate(ref v)) => v,
                _ => <super::GroupMemberRemovedUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupMemberRemovedUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberRemovedUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupMemberRemovedUpdate(&mut self, v: super::GroupMemberRemovedUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupMemberRemovedUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupMemberRemovedUpdate(&mut self) -> &mut super::GroupMemberRemovedUpdate {
            if let ::std::option::Option::Some(update::Update::GroupMemberRemovedUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupMemberRemovedUpdate(super::GroupMemberRemovedUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberRemovedUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupMemberRemovedUpdate(&mut self) -> super::GroupMemberRemovedUpdate {
            if self.has_groupMemberRemovedUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupMemberRemovedUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupMemberRemovedUpdate::new()
            }
        }

        // .signal.backup.SelfInvitedToGroupUpdate selfInvitedToGroupUpdate = 12;

        pub fn selfInvitedToGroupUpdate(&self) -> &super::SelfInvitedToGroupUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::SelfInvitedToGroupUpdate(ref v)) => v,
                _ => <super::SelfInvitedToGroupUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_selfInvitedToGroupUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::SelfInvitedToGroupUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_selfInvitedToGroupUpdate(&mut self, v: super::SelfInvitedToGroupUpdate) {
            self.update = ::std::option::Option::Some(update::Update::SelfInvitedToGroupUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_selfInvitedToGroupUpdate(&mut self) -> &mut super::SelfInvitedToGroupUpdate {
            if let ::std::option::Option::Some(update::Update::SelfInvitedToGroupUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::SelfInvitedToGroupUpdate(super::SelfInvitedToGroupUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::SelfInvitedToGroupUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_selfInvitedToGroupUpdate(&mut self) -> super::SelfInvitedToGroupUpdate {
            if self.has_selfInvitedToGroupUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::SelfInvitedToGroupUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::SelfInvitedToGroupUpdate::new()
            }
        }

        // .signal.backup.SelfInvitedOtherUserToGroupUpdate selfInvitedOtherUserToGroupUpdate = 13;

        pub fn selfInvitedOtherUserToGroupUpdate(&self) -> &super::SelfInvitedOtherUserToGroupUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::SelfInvitedOtherUserToGroupUpdate(ref v)) => v,
                _ => <super::SelfInvitedOtherUserToGroupUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_selfInvitedOtherUserToGroupUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::SelfInvitedOtherUserToGroupUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_selfInvitedOtherUserToGroupUpdate(&mut self, v: super::SelfInvitedOtherUserToGroupUpdate) {
            self.update = ::std::option::Option::Some(update::Update::SelfInvitedOtherUserToGroupUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_selfInvitedOtherUserToGroupUpdate(&mut self) -> &mut super::SelfInvitedOtherUserToGroupUpdate {
            if let ::std::option::Option::Some(update::Update::SelfInvitedOtherUserToGroupUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::SelfInvitedOtherUserToGroupUpdate(super::SelfInvitedOtherUserToGroupUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::SelfInvitedOtherUserToGroupUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_selfInvitedOtherUserToGroupUpdate(&mut self) -> super::SelfInvitedOtherUserToGroupUpdate {
            if self.has_selfInvitedOtherUserToGroupUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::SelfInvitedOtherUserToGroupUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::SelfInvitedOtherUserToGroupUpdate::new()
            }
        }

        // .signal.backup.GroupUnknownInviteeUpdate groupUnknownInviteeUpdate = 14;

        pub fn groupUnknownInviteeUpdate(&self) -> &super::GroupUnknownInviteeUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupUnknownInviteeUpdate(ref v)) => v,
                _ => <super::GroupUnknownInviteeUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupUnknownInviteeUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupUnknownInviteeUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupUnknownInviteeUpdate(&mut self, v: super::GroupUnknownInviteeUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupUnknownInviteeUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupUnknownInviteeUpdate(&mut self) -> &mut super::GroupUnknownInviteeUpdate {
            if let ::std::option::Option::Some(update::Update::GroupUnknownInviteeUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupUnknownInviteeUpdate(super::GroupUnknownInviteeUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupUnknownInviteeUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupUnknownInviteeUpdate(&mut self) -> super::GroupUnknownInviteeUpdate {
            if self.has_groupUnknownInviteeUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupUnknownInviteeUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupUnknownInviteeUpdate::new()
            }
        }

        // .signal.backup.GroupInvitationAcceptedUpdate groupInvitationAcceptedUpdate = 15;

        pub fn groupInvitationAcceptedUpdate(&self) -> &super::GroupInvitationAcceptedUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInvitationAcceptedUpdate(ref v)) => v,
                _ => <super::GroupInvitationAcceptedUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupInvitationAcceptedUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInvitationAcceptedUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupInvitationAcceptedUpdate(&mut self, v: super::GroupInvitationAcceptedUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupInvitationAcceptedUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupInvitationAcceptedUpdate(&mut self) -> &mut super::GroupInvitationAcceptedUpdate {
            if let ::std::option::Option::Some(update::Update::GroupInvitationAcceptedUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupInvitationAcceptedUpdate(super::GroupInvitationAcceptedUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInvitationAcceptedUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupInvitationAcceptedUpdate(&mut self) -> super::GroupInvitationAcceptedUpdate {
            if self.has_groupInvitationAcceptedUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupInvitationAcceptedUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupInvitationAcceptedUpdate::new()
            }
        }

        // .signal.backup.GroupInvitationDeclinedUpdate groupInvitationDeclinedUpdate = 16;

        pub fn groupInvitationDeclinedUpdate(&self) -> &super::GroupInvitationDeclinedUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInvitationDeclinedUpdate(ref v)) => v,
                _ => <super::GroupInvitationDeclinedUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupInvitationDeclinedUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInvitationDeclinedUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupInvitationDeclinedUpdate(&mut self, v: super::GroupInvitationDeclinedUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupInvitationDeclinedUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupInvitationDeclinedUpdate(&mut self) -> &mut super::GroupInvitationDeclinedUpdate {
            if let ::std::option::Option::Some(update::Update::GroupInvitationDeclinedUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupInvitationDeclinedUpdate(super::GroupInvitationDeclinedUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInvitationDeclinedUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupInvitationDeclinedUpdate(&mut self) -> super::GroupInvitationDeclinedUpdate {
            if self.has_groupInvitationDeclinedUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupInvitationDeclinedUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupInvitationDeclinedUpdate::new()
            }
        }

        // .signal.backup.GroupMemberJoinedUpdate groupMemberJoinedUpdate = 17;

        pub fn groupMemberJoinedUpdate(&self) -> &super::GroupMemberJoinedUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberJoinedUpdate(ref v)) => v,
                _ => <super::GroupMemberJoinedUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupMemberJoinedUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberJoinedUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupMemberJoinedUpdate(&mut self, v: super::GroupMemberJoinedUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupMemberJoinedUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupMemberJoinedUpdate(&mut self) -> &mut super::GroupMemberJoinedUpdate {
            if let ::std::option::Option::Some(update::Update::GroupMemberJoinedUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupMemberJoinedUpdate(super::GroupMemberJoinedUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberJoinedUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupMemberJoinedUpdate(&mut self) -> super::GroupMemberJoinedUpdate {
            if self.has_groupMemberJoinedUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupMemberJoinedUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupMemberJoinedUpdate::new()
            }
        }

        // .signal.backup.GroupMemberAddedUpdate groupMemberAddedUpdate = 18;

        pub fn groupMemberAddedUpdate(&self) -> &super::GroupMemberAddedUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberAddedUpdate(ref v)) => v,
                _ => <super::GroupMemberAddedUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupMemberAddedUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberAddedUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupMemberAddedUpdate(&mut self, v: super::GroupMemberAddedUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupMemberAddedUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupMemberAddedUpdate(&mut self) -> &mut super::GroupMemberAddedUpdate {
            if let ::std::option::Option::Some(update::Update::GroupMemberAddedUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupMemberAddedUpdate(super::GroupMemberAddedUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberAddedUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupMemberAddedUpdate(&mut self) -> super::GroupMemberAddedUpdate {
            if self.has_groupMemberAddedUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupMemberAddedUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupMemberAddedUpdate::new()
            }
        }

        // .signal.backup.GroupSelfInvitationRevokedUpdate groupSelfInvitationRevokedUpdate = 19;

        pub fn groupSelfInvitationRevokedUpdate(&self) -> &super::GroupSelfInvitationRevokedUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupSelfInvitationRevokedUpdate(ref v)) => v,
                _ => <super::GroupSelfInvitationRevokedUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupSelfInvitationRevokedUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupSelfInvitationRevokedUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupSelfInvitationRevokedUpdate(&mut self, v: super::GroupSelfInvitationRevokedUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupSelfInvitationRevokedUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupSelfInvitationRevokedUpdate(&mut self) -> &mut super::GroupSelfInvitationRevokedUpdate {
            if let ::std::option::Option::Some(update::Update::GroupSelfInvitationRevokedUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupSelfInvitationRevokedUpdate(super::GroupSelfInvitationRevokedUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupSelfInvitationRevokedUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupSelfInvitationRevokedUpdate(&mut self) -> super::GroupSelfInvitationRevokedUpdate {
            if self.has_groupSelfInvitationRevokedUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupSelfInvitationRevokedUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupSelfInvitationRevokedUpdate::new()
            }
        }

        // .signal.backup.GroupInvitationRevokedUpdate groupInvitationRevokedUpdate = 20;

        pub fn groupInvitationRevokedUpdate(&self) -> &super::GroupInvitationRevokedUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInvitationRevokedUpdate(ref v)) => v,
                _ => <super::GroupInvitationRevokedUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupInvitationRevokedUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInvitationRevokedUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupInvitationRevokedUpdate(&mut self, v: super::GroupInvitationRevokedUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupInvitationRevokedUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupInvitationRevokedUpdate(&mut self) -> &mut super::GroupInvitationRevokedUpdate {
            if let ::std::option::Option::Some(update::Update::GroupInvitationRevokedUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupInvitationRevokedUpdate(super::GroupInvitationRevokedUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInvitationRevokedUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupInvitationRevokedUpdate(&mut self) -> super::GroupInvitationRevokedUpdate {
            if self.has_groupInvitationRevokedUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupInvitationRevokedUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupInvitationRevokedUpdate::new()
            }
        }

        // .signal.backup.GroupJoinRequestUpdate groupJoinRequestUpdate = 21;

        pub fn groupJoinRequestUpdate(&self) -> &super::GroupJoinRequestUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupJoinRequestUpdate(ref v)) => v,
                _ => <super::GroupJoinRequestUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupJoinRequestUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupJoinRequestUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupJoinRequestUpdate(&mut self, v: super::GroupJoinRequestUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupJoinRequestUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupJoinRequestUpdate(&mut self) -> &mut super::GroupJoinRequestUpdate {
            if let ::std::option::Option::Some(update::Update::GroupJoinRequestUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupJoinRequestUpdate(super::GroupJoinRequestUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupJoinRequestUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupJoinRequestUpdate(&mut self) -> super::GroupJoinRequestUpdate {
            if self.has_groupJoinRequestUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupJoinRequestUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupJoinRequestUpdate::new()
            }
        }

        // .signal.backup.GroupJoinRequestApprovalUpdate groupJoinRequestApprovalUpdate = 22;

        pub fn groupJoinRequestApprovalUpdate(&self) -> &super::GroupJoinRequestApprovalUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupJoinRequestApprovalUpdate(ref v)) => v,
                _ => <super::GroupJoinRequestApprovalUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupJoinRequestApprovalUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupJoinRequestApprovalUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupJoinRequestApprovalUpdate(&mut self, v: super::GroupJoinRequestApprovalUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupJoinRequestApprovalUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupJoinRequestApprovalUpdate(&mut self) -> &mut super::GroupJoinRequestApprovalUpdate {
            if let ::std::option::Option::Some(update::Update::GroupJoinRequestApprovalUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupJoinRequestApprovalUpdate(super::GroupJoinRequestApprovalUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupJoinRequestApprovalUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupJoinRequestApprovalUpdate(&mut self) -> super::GroupJoinRequestApprovalUpdate {
            if self.has_groupJoinRequestApprovalUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupJoinRequestApprovalUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupJoinRequestApprovalUpdate::new()
            }
        }

        // .signal.backup.GroupJoinRequestCanceledUpdate groupJoinRequestCanceledUpdate = 23;

        pub fn groupJoinRequestCanceledUpdate(&self) -> &super::GroupJoinRequestCanceledUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupJoinRequestCanceledUpdate(ref v)) => v,
                _ => <super::GroupJoinRequestCanceledUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupJoinRequestCanceledUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupJoinRequestCanceledUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupJoinRequestCanceledUpdate(&mut self, v: super::GroupJoinRequestCanceledUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupJoinRequestCanceledUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupJoinRequestCanceledUpdate(&mut self) -> &mut super::GroupJoinRequestCanceledUpdate {
            if let ::std::option::Option::Some(update::Update::GroupJoinRequestCanceledUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupJoinRequestCanceledUpdate(super::GroupJoinRequestCanceledUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupJoinRequestCanceledUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupJoinRequestCanceledUpdate(&mut self) -> super::GroupJoinRequestCanceledUpdate {
            if self.has_groupJoinRequestCanceledUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupJoinRequestCanceledUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupJoinRequestCanceledUpdate::new()
            }
        }

        // .signal.backup.GroupInviteLinkResetUpdate groupInviteLinkResetUpdate = 24;

        pub fn groupInviteLinkResetUpdate(&self) -> &super::GroupInviteLinkResetUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkResetUpdate(ref v)) => v,
                _ => <super::GroupInviteLinkResetUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupInviteLinkResetUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkResetUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupInviteLinkResetUpdate(&mut self, v: super::GroupInviteLinkResetUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkResetUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupInviteLinkResetUpdate(&mut self) -> &mut super::GroupInviteLinkResetUpdate {
            if let ::std::option::Option::Some(update::Update::GroupInviteLinkResetUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkResetUpdate(super::GroupInviteLinkResetUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkResetUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupInviteLinkResetUpdate(&mut self) -> super::GroupInviteLinkResetUpdate {
            if self.has_groupInviteLinkResetUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupInviteLinkResetUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupInviteLinkResetUpdate::new()
            }
        }

        // .signal.backup.GroupInviteLinkEnabledUpdate groupInviteLinkEnabledUpdate = 25;

        pub fn groupInviteLinkEnabledUpdate(&self) -> &super::GroupInviteLinkEnabledUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkEnabledUpdate(ref v)) => v,
                _ => <super::GroupInviteLinkEnabledUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupInviteLinkEnabledUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkEnabledUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupInviteLinkEnabledUpdate(&mut self, v: super::GroupInviteLinkEnabledUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkEnabledUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupInviteLinkEnabledUpdate(&mut self) -> &mut super::GroupInviteLinkEnabledUpdate {
            if let ::std::option::Option::Some(update::Update::GroupInviteLinkEnabledUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkEnabledUpdate(super::GroupInviteLinkEnabledUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkEnabledUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupInviteLinkEnabledUpdate(&mut self) -> super::GroupInviteLinkEnabledUpdate {
            if self.has_groupInviteLinkEnabledUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupInviteLinkEnabledUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupInviteLinkEnabledUpdate::new()
            }
        }

        // .signal.backup.GroupInviteLinkAdminApprovalUpdate groupInviteLinkAdminApprovalUpdate = 26;

        pub fn groupInviteLinkAdminApprovalUpdate(&self) -> &super::GroupInviteLinkAdminApprovalUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkAdminApprovalUpdate(ref v)) => v,
                _ => <super::GroupInviteLinkAdminApprovalUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupInviteLinkAdminApprovalUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkAdminApprovalUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupInviteLinkAdminApprovalUpdate(&mut self, v: super::GroupInviteLinkAdminApprovalUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkAdminApprovalUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupInviteLinkAdminApprovalUpdate(&mut self) -> &mut super::GroupInviteLinkAdminApprovalUpdate {
            if let ::std::option::Option::Some(update::Update::GroupInviteLinkAdminApprovalUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkAdminApprovalUpdate(super::GroupInviteLinkAdminApprovalUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkAdminApprovalUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupInviteLinkAdminApprovalUpdate(&mut self) -> super::GroupInviteLinkAdminApprovalUpdate {
            if self.has_groupInviteLinkAdminApprovalUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupInviteLinkAdminApprovalUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupInviteLinkAdminApprovalUpdate::new()
            }
        }

        // .signal.backup.GroupInviteLinkDisabledUpdate groupInviteLinkDisabledUpdate = 27;

        pub fn groupInviteLinkDisabledUpdate(&self) -> &super::GroupInviteLinkDisabledUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkDisabledUpdate(ref v)) => v,
                _ => <super::GroupInviteLinkDisabledUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupInviteLinkDisabledUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkDisabledUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupInviteLinkDisabledUpdate(&mut self, v: super::GroupInviteLinkDisabledUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkDisabledUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupInviteLinkDisabledUpdate(&mut self) -> &mut super::GroupInviteLinkDisabledUpdate {
            if let ::std::option::Option::Some(update::Update::GroupInviteLinkDisabledUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkDisabledUpdate(super::GroupInviteLinkDisabledUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupInviteLinkDisabledUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupInviteLinkDisabledUpdate(&mut self) -> super::GroupInviteLinkDisabledUpdate {
            if self.has_groupInviteLinkDisabledUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupInviteLinkDisabledUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupInviteLinkDisabledUpdate::new()
            }
        }

        // .signal.backup.GroupMemberJoinedByLinkUpdate groupMemberJoinedByLinkUpdate = 28;

        pub fn groupMemberJoinedByLinkUpdate(&self) -> &super::GroupMemberJoinedByLinkUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberJoinedByLinkUpdate(ref v)) => v,
                _ => <super::GroupMemberJoinedByLinkUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupMemberJoinedByLinkUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberJoinedByLinkUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupMemberJoinedByLinkUpdate(&mut self, v: super::GroupMemberJoinedByLinkUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupMemberJoinedByLinkUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupMemberJoinedByLinkUpdate(&mut self) -> &mut super::GroupMemberJoinedByLinkUpdate {
            if let ::std::option::Option::Some(update::Update::GroupMemberJoinedByLinkUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupMemberJoinedByLinkUpdate(super::GroupMemberJoinedByLinkUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberJoinedByLinkUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupMemberJoinedByLinkUpdate(&mut self) -> super::GroupMemberJoinedByLinkUpdate {
            if self.has_groupMemberJoinedByLinkUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupMemberJoinedByLinkUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupMemberJoinedByLinkUpdate::new()
            }
        }

        // .signal.backup.GroupV2MigrationUpdate groupV2MigrationUpdate = 29;

        pub fn groupV2MigrationUpdate(&self) -> &super::GroupV2MigrationUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationUpdate(ref v)) => v,
                _ => <super::GroupV2MigrationUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupV2MigrationUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupV2MigrationUpdate(&mut self, v: super::GroupV2MigrationUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupV2MigrationUpdate(&mut self) -> &mut super::GroupV2MigrationUpdate {
            if let ::std::option::Option::Some(update::Update::GroupV2MigrationUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationUpdate(super::GroupV2MigrationUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupV2MigrationUpdate(&mut self) -> super::GroupV2MigrationUpdate {
            if self.has_groupV2MigrationUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupV2MigrationUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupV2MigrationUpdate::new()
            }
        }

        // .signal.backup.GroupV2MigrationSelfInvitedUpdate groupV2MigrationSelfInvitedUpdate = 30;

        pub fn groupV2MigrationSelfInvitedUpdate(&self) -> &super::GroupV2MigrationSelfInvitedUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationSelfInvitedUpdate(ref v)) => v,
                _ => <super::GroupV2MigrationSelfInvitedUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupV2MigrationSelfInvitedUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationSelfInvitedUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupV2MigrationSelfInvitedUpdate(&mut self, v: super::GroupV2MigrationSelfInvitedUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationSelfInvitedUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupV2MigrationSelfInvitedUpdate(&mut self) -> &mut super::GroupV2MigrationSelfInvitedUpdate {
            if let ::std::option::Option::Some(update::Update::GroupV2MigrationSelfInvitedUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationSelfInvitedUpdate(super::GroupV2MigrationSelfInvitedUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationSelfInvitedUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupV2MigrationSelfInvitedUpdate(&mut self) -> super::GroupV2MigrationSelfInvitedUpdate {
            if self.has_groupV2MigrationSelfInvitedUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupV2MigrationSelfInvitedUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupV2MigrationSelfInvitedUpdate::new()
            }
        }

        // .signal.backup.GroupV2MigrationInvitedMembersUpdate groupV2MigrationInvitedMembersUpdate = 31;

        pub fn groupV2MigrationInvitedMembersUpdate(&self) -> &super::GroupV2MigrationInvitedMembersUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationInvitedMembersUpdate(ref v)) => v,
                _ => <super::GroupV2MigrationInvitedMembersUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupV2MigrationInvitedMembersUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationInvitedMembersUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupV2MigrationInvitedMembersUpdate(&mut self, v: super::GroupV2MigrationInvitedMembersUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationInvitedMembersUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupV2MigrationInvitedMembersUpdate(&mut self) -> &mut super::GroupV2MigrationInvitedMembersUpdate {
            if let ::std::option::Option::Some(update::Update::GroupV2MigrationInvitedMembersUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationInvitedMembersUpdate(super::GroupV2MigrationInvitedMembersUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationInvitedMembersUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupV2MigrationInvitedMembersUpdate(&mut self) -> super::GroupV2MigrationInvitedMembersUpdate {
            if self.has_groupV2MigrationInvitedMembersUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupV2MigrationInvitedMembersUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupV2MigrationInvitedMembersUpdate::new()
            }
        }

        // .signal.backup.GroupV2MigrationDroppedMembersUpdate groupV2MigrationDroppedMembersUpdate = 32;

        pub fn groupV2MigrationDroppedMembersUpdate(&self) -> &super::GroupV2MigrationDroppedMembersUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationDroppedMembersUpdate(ref v)) => v,
                _ => <super::GroupV2MigrationDroppedMembersUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupV2MigrationDroppedMembersUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationDroppedMembersUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupV2MigrationDroppedMembersUpdate(&mut self, v: super::GroupV2MigrationDroppedMembersUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationDroppedMembersUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupV2MigrationDroppedMembersUpdate(&mut self) -> &mut super::GroupV2MigrationDroppedMembersUpdate {
            if let ::std::option::Option::Some(update::Update::GroupV2MigrationDroppedMembersUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationDroppedMembersUpdate(super::GroupV2MigrationDroppedMembersUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupV2MigrationDroppedMembersUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupV2MigrationDroppedMembersUpdate(&mut self) -> super::GroupV2MigrationDroppedMembersUpdate {
            if self.has_groupV2MigrationDroppedMembersUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupV2MigrationDroppedMembersUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupV2MigrationDroppedMembersUpdate::new()
            }
        }

        // .signal.backup.GroupSequenceOfRequestsAndCancelsUpdate groupSequenceOfRequestsAndCancelsUpdate = 33;

        pub fn groupSequenceOfRequestsAndCancelsUpdate(&self) -> &super::GroupSequenceOfRequestsAndCancelsUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupSequenceOfRequestsAndCancelsUpdate(ref v)) => v,
                _ => <super::GroupSequenceOfRequestsAndCancelsUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupSequenceOfRequestsAndCancelsUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupSequenceOfRequestsAndCancelsUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupSequenceOfRequestsAndCancelsUpdate(&mut self, v: super::GroupSequenceOfRequestsAndCancelsUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupSequenceOfRequestsAndCancelsUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupSequenceOfRequestsAndCancelsUpdate(&mut self) -> &mut super::GroupSequenceOfRequestsAndCancelsUpdate {
            if let ::std::option::Option::Some(update::Update::GroupSequenceOfRequestsAndCancelsUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupSequenceOfRequestsAndCancelsUpdate(super::GroupSequenceOfRequestsAndCancelsUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupSequenceOfRequestsAndCancelsUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupSequenceOfRequestsAndCancelsUpdate(&mut self) -> super::GroupSequenceOfRequestsAndCancelsUpdate {
            if self.has_groupSequenceOfRequestsAndCancelsUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupSequenceOfRequestsAndCancelsUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupSequenceOfRequestsAndCancelsUpdate::new()
            }
        }

        // .signal.backup.GroupExpirationTimerUpdate groupExpirationTimerUpdate = 34;

        pub fn groupExpirationTimerUpdate(&self) -> &super::GroupExpirationTimerUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupExpirationTimerUpdate(ref v)) => v,
                _ => <super::GroupExpirationTimerUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupExpirationTimerUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupExpirationTimerUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupExpirationTimerUpdate(&mut self, v: super::GroupExpirationTimerUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupExpirationTimerUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupExpirationTimerUpdate(&mut self) -> &mut super::GroupExpirationTimerUpdate {
            if let ::std::option::Option::Some(update::Update::GroupExpirationTimerUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupExpirationTimerUpdate(super::GroupExpirationTimerUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupExpirationTimerUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupExpirationTimerUpdate(&mut self) -> super::GroupExpirationTimerUpdate {
            if self.has_groupExpirationTimerUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupExpirationTimerUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupExpirationTimerUpdate::new()
            }
        }

        // .signal.backup.GroupMemberLabelAccessLevelChangeUpdate groupMemberLabelAccessLevelChangeUpdate = 35;

        pub fn groupMemberLabelAccessLevelChangeUpdate(&self) -> &super::GroupMemberLabelAccessLevelChangeUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberLabelAccessLevelChangeUpdate(ref v)) => v,
                _ => <super::GroupMemberLabelAccessLevelChangeUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupMemberLabelAccessLevelChangeUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberLabelAccessLevelChangeUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupMemberLabelAccessLevelChangeUpdate(&mut self, v: super::GroupMemberLabelAccessLevelChangeUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupMemberLabelAccessLevelChangeUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupMemberLabelAccessLevelChangeUpdate(&mut self) -> &mut super::GroupMemberLabelAccessLevelChangeUpdate {
            if let ::std::option::Option::Some(update::Update::GroupMemberLabelAccessLevelChangeUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupMemberLabelAccessLevelChangeUpdate(super::GroupMemberLabelAccessLevelChangeUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupMemberLabelAccessLevelChangeUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupMemberLabelAccessLevelChangeUpdate(&mut self) -> super::GroupMemberLabelAccessLevelChangeUpdate {
            if self.has_groupMemberLabelAccessLevelChangeUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupMemberLabelAccessLevelChangeUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupMemberLabelAccessLevelChangeUpdate::new()
            }
        }

        // .signal.backup.GroupTerminateChangeUpdate groupTerminateChangeUpdate = 36;

        pub fn groupTerminateChangeUpdate(&self) -> &super::GroupTerminateChangeUpdate {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupTerminateChangeUpdate(ref v)) => v,
                _ => <super::GroupTerminateChangeUpdate as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_groupTerminateChangeUpdate(&self) -> bool {
            match self.update {
                ::std::option::Option::Some(update::Update::GroupTerminateChangeUpdate(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_groupTerminateChangeUpdate(&mut self, v: super::GroupTerminateChangeUpdate) {
            self.update = ::std::option::Option::Some(update::Update::GroupTerminateChangeUpdate(v))
        }

        // Mutable pointer to the field.
        pub fn mut_groupTerminateChangeUpdate(&mut self) -> &mut super::GroupTerminateChangeUpdate {
            if let ::std::option::Option::Some(update::Update::GroupTerminateChangeUpdate(_)) = self.update {
            } else {
                self.update = ::std::option::Option::Some(update::Update::GroupTerminateChangeUpdate(super::GroupTerminateChangeUpdate::new()));
            }
            match self.update {
                ::std::option::Option::Some(update::Update::GroupTerminateChangeUpdate(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_groupTerminateChangeUpdate(&mut self) -> super::GroupTerminateChangeUpdate {
            if self.has_groupTerminateChangeUpdate() {
                match self.update.take() {
                    ::std::option::Option::Some(update::Update::GroupTerminateChangeUpdate(v)) => v,
                    _ => panic!(),
                }
            } else {
                super::GroupTerminateChangeUpdate::new()
            }
        }
    }

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

        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.update = ::std::option::Option::Some(update::Update::GenericGroupUpdate(is.read_message()?));
                    },
                    18 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupCreationUpdate(is.read_message()?));
                    },
                    26 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupNameUpdate(is.read_message()?));
                    },
                    34 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupAvatarUpdate(is.read_message()?));
                    },
                    42 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupDescriptionUpdate(is.read_message()?));
                    },
                    50 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupMembershipAccessLevelChangeUpdate(is.read_message()?));
                    },
                    58 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupAttributesAccessLevelChangeUpdate(is.read_message()?));
                    },
                    66 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupAnnouncementOnlyChangeUpdate(is.read_message()?));
                    },
                    74 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupAdminStatusUpdate(is.read_message()?));
                    },
                    82 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupMemberLeftUpdate(is.read_message()?));
                    },
                    90 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupMemberRemovedUpdate(is.read_message()?));
                    },
                    98 => {
                        self.update = ::std::option::Option::Some(update::Update::SelfInvitedToGroupUpdate(is.read_message()?));
                    },
                    106 => {
                        self.update = ::std::option::Option::Some(update::Update::SelfInvitedOtherUserToGroupUpdate(is.read_message()?));
                    },
                    114 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupUnknownInviteeUpdate(is.read_message()?));
                    },
                    122 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupInvitationAcceptedUpdate(is.read_message()?));
                    },
                    130 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupInvitationDeclinedUpdate(is.read_message()?));
                    },
                    138 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupMemberJoinedUpdate(is.read_message()?));
                    },
                    146 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupMemberAddedUpdate(is.read_message()?));
                    },
                    154 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupSelfInvitationRevokedUpdate(is.read_message()?));
                    },
                    162 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupInvitationRevokedUpdate(is.read_message()?));
                    },
                    170 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupJoinRequestUpdate(is.read_message()?));
                    },
                    178 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupJoinRequestApprovalUpdate(is.read_message()?));
                    },
                    186 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupJoinRequestCanceledUpdate(is.read_message()?));
                    },
                    194 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkResetUpdate(is.read_message()?));
                    },
                    202 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkEnabledUpdate(is.read_message()?));
                    },
                    210 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkAdminApprovalUpdate(is.read_message()?));
                    },
                    218 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupInviteLinkDisabledUpdate(is.read_message()?));
                    },
                    226 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupMemberJoinedByLinkUpdate(is.read_message()?));
                    },
                    234 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationUpdate(is.read_message()?));
                    },
                    242 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationSelfInvitedUpdate(is.read_message()?));
                    },
                    250 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationInvitedMembersUpdate(is.read_message()?));
                    },
                    258 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupV2MigrationDroppedMembersUpdate(is.read_message()?));
                    },
                    266 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupSequenceOfRequestsAndCancelsUpdate(is.read_message()?));
                    },
                    274 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupExpirationTimerUpdate(is.read_message()?));
                    },
                    282 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupMemberLabelAccessLevelChangeUpdate(is.read_message()?));
                    },
                    290 => {
                        self.update = ::std::option::Option::Some(update::Update::GroupTerminateChangeUpdate(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.update {
                match v {
                    &update::Update::GenericGroupUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupCreationUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupNameUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupAvatarUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupDescriptionUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupMembershipAccessLevelChangeUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupAttributesAccessLevelChangeUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupAnnouncementOnlyChangeUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupAdminStatusUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupMemberLeftUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupMemberRemovedUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::SelfInvitedToGroupUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::SelfInvitedOtherUserToGroupUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupUnknownInviteeUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupInvitationAcceptedUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupInvitationDeclinedUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupMemberJoinedUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupMemberAddedUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupSelfInvitationRevokedUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupInvitationRevokedUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupJoinRequestUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupJoinRequestApprovalUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupJoinRequestCanceledUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupInviteLinkResetUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupInviteLinkEnabledUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupInviteLinkAdminApprovalUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupInviteLinkDisabledUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupMemberJoinedByLinkUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupV2MigrationUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupV2MigrationSelfInvitedUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupV2MigrationInvitedMembersUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupV2MigrationDroppedMembersUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupSequenceOfRequestsAndCancelsUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupExpirationTimerUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupMemberLabelAccessLevelChangeUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &update::Update::GroupTerminateChangeUpdate(ref v) => {
                        let len = v.compute_size();
                        my_size += 2 + ::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.update {
                match v {
                    &update::Update::GenericGroupUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                    },
                    &update::Update::GroupCreationUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                    },
                    &update::Update::GroupNameUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                    },
                    &update::Update::GroupAvatarUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                    },
                    &update::Update::GroupDescriptionUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                    },
                    &update::Update::GroupMembershipAccessLevelChangeUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                    },
                    &update::Update::GroupAttributesAccessLevelChangeUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                    },
                    &update::Update::GroupAnnouncementOnlyChangeUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
                    },
                    &update::Update::GroupAdminStatusUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
                    },
                    &update::Update::GroupMemberLeftUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
                    },
                    &update::Update::GroupMemberRemovedUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
                    },
                    &update::Update::SelfInvitedToGroupUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
                    },
                    &update::Update::SelfInvitedOtherUserToGroupUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
                    },
                    &update::Update::GroupUnknownInviteeUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
                    },
                    &update::Update::GroupInvitationAcceptedUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(15, v, os)?;
                    },
                    &update::Update::GroupInvitationDeclinedUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(16, v, os)?;
                    },
                    &update::Update::GroupMemberJoinedUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(17, v, os)?;
                    },
                    &update::Update::GroupMemberAddedUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(18, v, os)?;
                    },
                    &update::Update::GroupSelfInvitationRevokedUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(19, v, os)?;
                    },
                    &update::Update::GroupInvitationRevokedUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(20, v, os)?;
                    },
                    &update::Update::GroupJoinRequestUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(21, v, os)?;
                    },
                    &update::Update::GroupJoinRequestApprovalUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(22, v, os)?;
                    },
                    &update::Update::GroupJoinRequestCanceledUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(23, v, os)?;
                    },
                    &update::Update::GroupInviteLinkResetUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(24, v, os)?;
                    },
                    &update::Update::GroupInviteLinkEnabledUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(25, v, os)?;
                    },
                    &update::Update::GroupInviteLinkAdminApprovalUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(26, v, os)?;
                    },
                    &update::Update::GroupInviteLinkDisabledUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(27, v, os)?;
                    },
                    &update::Update::GroupMemberJoinedByLinkUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(28, v, os)?;
                    },
                    &update::Update::GroupV2MigrationUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(29, v, os)?;
                    },
                    &update::Update::GroupV2MigrationSelfInvitedUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(30, v, os)?;
                    },
                    &update::Update::GroupV2MigrationInvitedMembersUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(31, v, os)?;
                    },
                    &update::Update::GroupV2MigrationDroppedMembersUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(32, v, os)?;
                    },
                    &update::Update::GroupSequenceOfRequestsAndCancelsUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(33, v, os)?;
                    },
                    &update::Update::GroupExpirationTimerUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(34, v, os)?;
                    },
                    &update::Update::GroupMemberLabelAccessLevelChangeUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(35, v, os)?;
                    },
                    &update::Update::GroupTerminateChangeUpdate(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(36, 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() -> Update {
            Update::new()
        }

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

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

    /// Nested message and enums of message `Update`
    pub mod update {

        #[derive(Clone,PartialEq,Debug)]
        #[non_exhaustive]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(oneof:signal.backup.GroupChangeChatUpdate.Update.update)
        pub enum Update {
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.genericGroupUpdate)
            GenericGroupUpdate(super::super::GenericGroupUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupCreationUpdate)
            GroupCreationUpdate(super::super::GroupCreationUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupNameUpdate)
            GroupNameUpdate(super::super::GroupNameUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupAvatarUpdate)
            GroupAvatarUpdate(super::super::GroupAvatarUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupDescriptionUpdate)
            GroupDescriptionUpdate(super::super::GroupDescriptionUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupMembershipAccessLevelChangeUpdate)
            GroupMembershipAccessLevelChangeUpdate(super::super::GroupMembershipAccessLevelChangeUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupAttributesAccessLevelChangeUpdate)
            GroupAttributesAccessLevelChangeUpdate(super::super::GroupAttributesAccessLevelChangeUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupAnnouncementOnlyChangeUpdate)
            GroupAnnouncementOnlyChangeUpdate(super::super::GroupAnnouncementOnlyChangeUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupAdminStatusUpdate)
            GroupAdminStatusUpdate(super::super::GroupAdminStatusUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupMemberLeftUpdate)
            GroupMemberLeftUpdate(super::super::GroupMemberLeftUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupMemberRemovedUpdate)
            GroupMemberRemovedUpdate(super::super::GroupMemberRemovedUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.selfInvitedToGroupUpdate)
            SelfInvitedToGroupUpdate(super::super::SelfInvitedToGroupUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.selfInvitedOtherUserToGroupUpdate)
            SelfInvitedOtherUserToGroupUpdate(super::super::SelfInvitedOtherUserToGroupUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupUnknownInviteeUpdate)
            GroupUnknownInviteeUpdate(super::super::GroupUnknownInviteeUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupInvitationAcceptedUpdate)
            GroupInvitationAcceptedUpdate(super::super::GroupInvitationAcceptedUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupInvitationDeclinedUpdate)
            GroupInvitationDeclinedUpdate(super::super::GroupInvitationDeclinedUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupMemberJoinedUpdate)
            GroupMemberJoinedUpdate(super::super::GroupMemberJoinedUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupMemberAddedUpdate)
            GroupMemberAddedUpdate(super::super::GroupMemberAddedUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupSelfInvitationRevokedUpdate)
            GroupSelfInvitationRevokedUpdate(super::super::GroupSelfInvitationRevokedUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupInvitationRevokedUpdate)
            GroupInvitationRevokedUpdate(super::super::GroupInvitationRevokedUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupJoinRequestUpdate)
            GroupJoinRequestUpdate(super::super::GroupJoinRequestUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupJoinRequestApprovalUpdate)
            GroupJoinRequestApprovalUpdate(super::super::GroupJoinRequestApprovalUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupJoinRequestCanceledUpdate)
            GroupJoinRequestCanceledUpdate(super::super::GroupJoinRequestCanceledUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupInviteLinkResetUpdate)
            GroupInviteLinkResetUpdate(super::super::GroupInviteLinkResetUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupInviteLinkEnabledUpdate)
            GroupInviteLinkEnabledUpdate(super::super::GroupInviteLinkEnabledUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupInviteLinkAdminApprovalUpdate)
            GroupInviteLinkAdminApprovalUpdate(super::super::GroupInviteLinkAdminApprovalUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupInviteLinkDisabledUpdate)
            GroupInviteLinkDisabledUpdate(super::super::GroupInviteLinkDisabledUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupMemberJoinedByLinkUpdate)
            GroupMemberJoinedByLinkUpdate(super::super::GroupMemberJoinedByLinkUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupV2MigrationUpdate)
            GroupV2MigrationUpdate(super::super::GroupV2MigrationUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupV2MigrationSelfInvitedUpdate)
            GroupV2MigrationSelfInvitedUpdate(super::super::GroupV2MigrationSelfInvitedUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupV2MigrationInvitedMembersUpdate)
            GroupV2MigrationInvitedMembersUpdate(super::super::GroupV2MigrationInvitedMembersUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupV2MigrationDroppedMembersUpdate)
            GroupV2MigrationDroppedMembersUpdate(super::super::GroupV2MigrationDroppedMembersUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupSequenceOfRequestsAndCancelsUpdate)
            GroupSequenceOfRequestsAndCancelsUpdate(super::super::GroupSequenceOfRequestsAndCancelsUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupExpirationTimerUpdate)
            GroupExpirationTimerUpdate(super::super::GroupExpirationTimerUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupMemberLabelAccessLevelChangeUpdate)
            GroupMemberLabelAccessLevelChangeUpdate(super::super::GroupMemberLabelAccessLevelChangeUpdate),
            // @@protoc_insertion_point(oneof_field:signal.backup.GroupChangeChatUpdate.Update.groupTerminateChangeUpdate)
            GroupTerminateChangeUpdate(super::super::GroupTerminateChangeUpdate),
        }

        impl ::protobuf::Oneof for Update {
        }

        impl Update {
        }
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GenericGroupUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GenericGroupUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GenericGroupUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GenericGroupUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(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 let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        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() -> GenericGroupUpdate {
        GenericGroupUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupCreationUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupCreationUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupCreationUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupCreationUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(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 let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        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() -> GroupCreationUpdate {
        GroupCreationUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupNameUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupNameUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupNameUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("newGroupName")]
    // @@protoc_insertion_point(field:signal.backup.GroupNameUpdate.newGroupName)
    pub newGroupName: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupNameUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.newGroupName = ::std::option::Option::Some(is.read_string()?);
                },
                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 Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.newGroupName.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if let Some(v) = self.newGroupName.as_ref() {
            os.write_string(2, v)?;
        }
        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() -> GroupNameUpdate {
        GroupNameUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupAvatarUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupAvatarUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupAvatarUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("wasRemoved")]
    // @@protoc_insertion_point(field:signal.backup.GroupAvatarUpdate.wasRemoved)
    pub wasRemoved: bool,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupAvatarUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                16 => {
                    self.wasRemoved = is.read_bool()?;
                },
                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 Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if self.wasRemoved != false {
            my_size += 1 + 1;
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if self.wasRemoved != false {
            os.write_bool(2, self.wasRemoved)?;
        }
        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() -> GroupAvatarUpdate {
        GroupAvatarUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupDescriptionUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupDescriptionUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupDescriptionUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("newDescription")]
    // @@protoc_insertion_point(field:signal.backup.GroupDescriptionUpdate.newDescription)
    pub newDescription: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupDescriptionUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.newDescription = ::std::option::Option::Some(is.read_string()?);
                },
                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 Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.newDescription.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if let Some(v) = self.newDescription.as_ref() {
            os.write_string(2, v)?;
        }
        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() -> GroupDescriptionUpdate {
        GroupDescriptionUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupMembershipAccessLevelChangeUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupMembershipAccessLevelChangeUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupMembershipAccessLevelChangeUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("accessLevel")]
    // @@protoc_insertion_point(field:signal.backup.GroupMembershipAccessLevelChangeUpdate.accessLevel)
    pub accessLevel: ::protobuf::EnumOrUnknown<GroupV2AccessLevel>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupMembershipAccessLevelChangeUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                16 => {
                    self.accessLevel = 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 let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if self.accessLevel != ::protobuf::EnumOrUnknown::new(GroupV2AccessLevel::UNKNOWN) {
            my_size += ::protobuf::rt::int32_size(2, self.accessLevel.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 let Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if self.accessLevel != ::protobuf::EnumOrUnknown::new(GroupV2AccessLevel::UNKNOWN) {
            os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.accessLevel))?;
        }
        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() -> GroupMembershipAccessLevelChangeUpdate {
        GroupMembershipAccessLevelChangeUpdate::new()
    }

    fn clear(&mut self) {
        self.updaterAci = ::std::option::Option::None;
        self.accessLevel = ::protobuf::EnumOrUnknown::new(GroupV2AccessLevel::UNKNOWN);
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GroupMembershipAccessLevelChangeUpdate {
        static instance: GroupMembershipAccessLevelChangeUpdate = GroupMembershipAccessLevelChangeUpdate {
            updaterAci: ::std::option::Option::None,
            accessLevel: ::protobuf::EnumOrUnknown::from_i32(0),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupMemberLabelAccessLevelChangeUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupMemberLabelAccessLevelChangeUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberLabelAccessLevelChangeUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("accessLevel")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberLabelAccessLevelChangeUpdate.accessLevel)
    pub accessLevel: ::protobuf::EnumOrUnknown<GroupV2AccessLevel>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupMemberLabelAccessLevelChangeUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                16 => {
                    self.accessLevel = 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 let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if self.accessLevel != ::protobuf::EnumOrUnknown::new(GroupV2AccessLevel::UNKNOWN) {
            my_size += ::protobuf::rt::int32_size(2, self.accessLevel.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 let Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if self.accessLevel != ::protobuf::EnumOrUnknown::new(GroupV2AccessLevel::UNKNOWN) {
            os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.accessLevel))?;
        }
        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() -> GroupMemberLabelAccessLevelChangeUpdate {
        GroupMemberLabelAccessLevelChangeUpdate::new()
    }

    fn clear(&mut self) {
        self.updaterAci = ::std::option::Option::None;
        self.accessLevel = ::protobuf::EnumOrUnknown::new(GroupV2AccessLevel::UNKNOWN);
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GroupMemberLabelAccessLevelChangeUpdate {
        static instance: GroupMemberLabelAccessLevelChangeUpdate = GroupMemberLabelAccessLevelChangeUpdate {
            updaterAci: ::std::option::Option::None,
            accessLevel: ::protobuf::EnumOrUnknown::from_i32(0),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupAttributesAccessLevelChangeUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupAttributesAccessLevelChangeUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupAttributesAccessLevelChangeUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("accessLevel")]
    // @@protoc_insertion_point(field:signal.backup.GroupAttributesAccessLevelChangeUpdate.accessLevel)
    pub accessLevel: ::protobuf::EnumOrUnknown<GroupV2AccessLevel>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupAttributesAccessLevelChangeUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                16 => {
                    self.accessLevel = 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 let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if self.accessLevel != ::protobuf::EnumOrUnknown::new(GroupV2AccessLevel::UNKNOWN) {
            my_size += ::protobuf::rt::int32_size(2, self.accessLevel.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 let Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if self.accessLevel != ::protobuf::EnumOrUnknown::new(GroupV2AccessLevel::UNKNOWN) {
            os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.accessLevel))?;
        }
        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() -> GroupAttributesAccessLevelChangeUpdate {
        GroupAttributesAccessLevelChangeUpdate::new()
    }

    fn clear(&mut self) {
        self.updaterAci = ::std::option::Option::None;
        self.accessLevel = ::protobuf::EnumOrUnknown::new(GroupV2AccessLevel::UNKNOWN);
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GroupAttributesAccessLevelChangeUpdate {
        static instance: GroupAttributesAccessLevelChangeUpdate = GroupAttributesAccessLevelChangeUpdate {
            updaterAci: ::std::option::Option::None,
            accessLevel: ::protobuf::EnumOrUnknown::from_i32(0),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupAnnouncementOnlyChangeUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupAnnouncementOnlyChangeUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupAnnouncementOnlyChangeUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("isAnnouncementOnly")]
    // @@protoc_insertion_point(field:signal.backup.GroupAnnouncementOnlyChangeUpdate.isAnnouncementOnly)
    pub isAnnouncementOnly: bool,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupAnnouncementOnlyChangeUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                16 => {
                    self.isAnnouncementOnly = is.read_bool()?;
                },
                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 Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if self.isAnnouncementOnly != false {
            my_size += 1 + 1;
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if self.isAnnouncementOnly != false {
            os.write_bool(2, self.isAnnouncementOnly)?;
        }
        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() -> GroupAnnouncementOnlyChangeUpdate {
        GroupAnnouncementOnlyChangeUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupAdminStatusUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupAdminStatusUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupAdminStatusUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("memberAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupAdminStatusUpdate.memberAci)
    pub memberAci: ::std::vec::Vec<u8>,
    #[field_name("wasAdminStatusGranted")]
    // @@protoc_insertion_point(field:signal.backup.GroupAdminStatusUpdate.wasAdminStatusGranted)
    pub wasAdminStatusGranted: bool,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupAdminStatusUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.memberAci = is.read_bytes()?;
                },
                24 => {
                    self.wasAdminStatusGranted = is.read_bool()?;
                },
                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 Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if !self.memberAci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.memberAci);
        }
        if self.wasAdminStatusGranted != false {
            my_size += 1 + 1;
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if !self.memberAci.is_empty() {
            os.write_bytes(2, &self.memberAci)?;
        }
        if self.wasAdminStatusGranted != false {
            os.write_bool(3, self.wasAdminStatusGranted)?;
        }
        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() -> GroupAdminStatusUpdate {
        GroupAdminStatusUpdate::new()
    }

    fn clear(&mut self) {
        self.updaterAci = ::std::option::Option::None;
        self.memberAci.clear();
        self.wasAdminStatusGranted = false;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GroupAdminStatusUpdate {
        static instance: GroupAdminStatusUpdate = GroupAdminStatusUpdate {
            updaterAci: ::std::option::Option::None,
            memberAci: ::std::vec::Vec::new(),
            wasAdminStatusGranted: false,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupMemberLeftUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupMemberLeftUpdate {
    // message fields
    #[field_name("aci")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberLeftUpdate.aci)
    pub aci: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupMemberLeftUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.aci = 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.aci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.aci);
        }
        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.aci.is_empty() {
            os.write_bytes(1, &self.aci)?;
        }
        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() -> GroupMemberLeftUpdate {
        GroupMemberLeftUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupMemberRemovedUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupMemberRemovedUpdate {
    // message fields
    #[field_name("removerAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberRemovedUpdate.removerAci)
    pub removerAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("removedAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberRemovedUpdate.removedAci)
    pub removedAci: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupMemberRemovedUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.removerAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.removedAci = 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 let Some(v) = self.removerAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if !self.removedAci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.removedAci);
        }
        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 Some(v) = self.removerAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if !self.removedAci.is_empty() {
            os.write_bytes(2, &self.removedAci)?;
        }
        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() -> GroupMemberRemovedUpdate {
        GroupMemberRemovedUpdate::new()
    }

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

    fn default_instance() -> &'static GroupMemberRemovedUpdate {
        static instance: GroupMemberRemovedUpdate = GroupMemberRemovedUpdate {
            removerAci: ::std::option::Option::None,
            removedAci: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.SelfInvitedToGroupUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SelfInvitedToGroupUpdate {
    // message fields
    #[field_name("inviterAci")]
    // @@protoc_insertion_point(field:signal.backup.SelfInvitedToGroupUpdate.inviterAci)
    pub inviterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.SelfInvitedToGroupUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.inviterAci = ::std::option::Option::Some(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 let Some(v) = self.inviterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        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 Some(v) = self.inviterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        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() -> SelfInvitedToGroupUpdate {
        SelfInvitedToGroupUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.SelfInvitedOtherUserToGroupUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SelfInvitedOtherUserToGroupUpdate {
    // message fields
    #[field_name("inviteeServiceId")]
    // @@protoc_insertion_point(field:signal.backup.SelfInvitedOtherUserToGroupUpdate.inviteeServiceId)
    pub inviteeServiceId: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.SelfInvitedOtherUserToGroupUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.inviteeServiceId = 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.inviteeServiceId.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.inviteeServiceId);
        }
        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.inviteeServiceId.is_empty() {
            os.write_bytes(1, &self.inviteeServiceId)?;
        }
        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() -> SelfInvitedOtherUserToGroupUpdate {
        SelfInvitedOtherUserToGroupUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupUnknownInviteeUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupUnknownInviteeUpdate {
    // message fields
    #[field_name("inviterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupUnknownInviteeUpdate.inviterAci)
    pub inviterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("inviteeCount")]
    // @@protoc_insertion_point(field:signal.backup.GroupUnknownInviteeUpdate.inviteeCount)
    pub inviteeCount: u32,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupUnknownInviteeUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.inviterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                16 => {
                    self.inviteeCount = 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 let Some(v) = self.inviterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if self.inviteeCount != 0 {
            my_size += ::protobuf::rt::uint32_size(2, self.inviteeCount);
        }
        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 Some(v) = self.inviterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if self.inviteeCount != 0 {
            os.write_uint32(2, self.inviteeCount)?;
        }
        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() -> GroupUnknownInviteeUpdate {
        GroupUnknownInviteeUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupInvitationAcceptedUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupInvitationAcceptedUpdate {
    // message fields
    #[field_name("inviterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupInvitationAcceptedUpdate.inviterAci)
    pub inviterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("newMemberAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupInvitationAcceptedUpdate.newMemberAci)
    pub newMemberAci: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupInvitationAcceptedUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.inviterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.newMemberAci = 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 let Some(v) = self.inviterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if !self.newMemberAci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.newMemberAci);
        }
        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 Some(v) = self.inviterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if !self.newMemberAci.is_empty() {
            os.write_bytes(2, &self.newMemberAci)?;
        }
        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() -> GroupInvitationAcceptedUpdate {
        GroupInvitationAcceptedUpdate::new()
    }

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

    fn default_instance() -> &'static GroupInvitationAcceptedUpdate {
        static instance: GroupInvitationAcceptedUpdate = GroupInvitationAcceptedUpdate {
            inviterAci: ::std::option::Option::None,
            newMemberAci: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupInvitationDeclinedUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupInvitationDeclinedUpdate {
    // message fields
    #[field_name("inviterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupInvitationDeclinedUpdate.inviterAci)
    pub inviterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("inviteeAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupInvitationDeclinedUpdate.inviteeAci)
    pub inviteeAci: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupInvitationDeclinedUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.inviterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.inviteeAci = ::std::option::Option::Some(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 let Some(v) = self.inviterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.inviteeAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        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 Some(v) = self.inviterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if let Some(v) = self.inviteeAci.as_ref() {
            os.write_bytes(2, v)?;
        }
        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() -> GroupInvitationDeclinedUpdate {
        GroupInvitationDeclinedUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupMemberJoinedUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupMemberJoinedUpdate {
    // message fields
    #[field_name("newMemberAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberJoinedUpdate.newMemberAci)
    pub newMemberAci: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupMemberJoinedUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.newMemberAci = 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.newMemberAci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.newMemberAci);
        }
        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.newMemberAci.is_empty() {
            os.write_bytes(1, &self.newMemberAci)?;
        }
        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() -> GroupMemberJoinedUpdate {
        GroupMemberJoinedUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupMemberAddedUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupMemberAddedUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberAddedUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("newMemberAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberAddedUpdate.newMemberAci)
    pub newMemberAci: ::std::vec::Vec<u8>,
    #[field_name("hadOpenInvitation")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberAddedUpdate.hadOpenInvitation)
    pub hadOpenInvitation: bool,
    #[field_name("inviterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberAddedUpdate.inviterAci)
    pub inviterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupMemberAddedUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.newMemberAci = is.read_bytes()?;
                },
                24 => {
                    self.hadOpenInvitation = is.read_bool()?;
                },
                34 => {
                    self.inviterAci = ::std::option::Option::Some(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 let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if !self.newMemberAci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.newMemberAci);
        }
        if self.hadOpenInvitation != false {
            my_size += 1 + 1;
        }
        if let Some(v) = self.inviterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(4, &v);
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if !self.newMemberAci.is_empty() {
            os.write_bytes(2, &self.newMemberAci)?;
        }
        if self.hadOpenInvitation != false {
            os.write_bool(3, self.hadOpenInvitation)?;
        }
        if let Some(v) = self.inviterAci.as_ref() {
            os.write_bytes(4, v)?;
        }
        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() -> GroupMemberAddedUpdate {
        GroupMemberAddedUpdate::new()
    }

    fn clear(&mut self) {
        self.updaterAci = ::std::option::Option::None;
        self.newMemberAci.clear();
        self.hadOpenInvitation = false;
        self.inviterAci = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GroupMemberAddedUpdate {
        static instance: GroupMemberAddedUpdate = GroupMemberAddedUpdate {
            updaterAci: ::std::option::Option::None,
            newMemberAci: ::std::vec::Vec::new(),
            hadOpenInvitation: false,
            inviterAci: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupSelfInvitationRevokedUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupSelfInvitationRevokedUpdate {
    // message fields
    #[field_name("revokerAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupSelfInvitationRevokedUpdate.revokerAci)
    pub revokerAci: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupSelfInvitationRevokedUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.revokerAci = ::std::option::Option::Some(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 let Some(v) = self.revokerAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        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 Some(v) = self.revokerAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        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() -> GroupSelfInvitationRevokedUpdate {
        GroupSelfInvitationRevokedUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupInvitationRevokedUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupInvitationRevokedUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupInvitationRevokedUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("invitees")]
    // @@protoc_insertion_point(field:signal.backup.GroupInvitationRevokedUpdate.invitees)
    pub invitees: ::std::vec::Vec<group_invitation_revoked_update::Invitee>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupInvitationRevokedUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                18 => {
                    self.invitees.push(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 Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        for value in &self.invitees {
            let len = value.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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        for v in &self.invitees {
            ::protobuf::rt::write_message_field_with_cached_size(2, 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() -> GroupInvitationRevokedUpdate {
        GroupInvitationRevokedUpdate::new()
    }

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

    fn default_instance() -> &'static GroupInvitationRevokedUpdate {
        static instance: GroupInvitationRevokedUpdate = GroupInvitationRevokedUpdate {
            updaterAci: ::std::option::Option::None,
            invitees: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `GroupInvitationRevokedUpdate`
pub mod group_invitation_revoked_update {
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.GroupInvitationRevokedUpdate.Invitee)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Invitee {
        // message fields
        #[field_name("inviterAci")]
        // @@protoc_insertion_point(field:signal.backup.GroupInvitationRevokedUpdate.Invitee.inviterAci)
        pub inviterAci: ::std::option::Option<::std::vec::Vec<u8>>,
        #[field_name("inviteeAci")]
        // @@protoc_insertion_point(field:signal.backup.GroupInvitationRevokedUpdate.Invitee.inviteeAci)
        pub inviteeAci: ::std::option::Option<::std::vec::Vec<u8>>,
        #[field_name("inviteePni")]
        // @@protoc_insertion_point(field:signal.backup.GroupInvitationRevokedUpdate.Invitee.inviteePni)
        pub inviteePni: ::std::option::Option<::std::vec::Vec<u8>>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.GroupInvitationRevokedUpdate.Invitee.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.inviterAci = ::std::option::Option::Some(is.read_bytes()?);
                    },
                    18 => {
                        self.inviteeAci = ::std::option::Option::Some(is.read_bytes()?);
                    },
                    26 => {
                        self.inviteePni = ::std::option::Option::Some(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 let Some(v) = self.inviterAci.as_ref() {
                my_size += ::protobuf::rt::bytes_size(1, &v);
            }
            if let Some(v) = self.inviteeAci.as_ref() {
                my_size += ::protobuf::rt::bytes_size(2, &v);
            }
            if let Some(v) = self.inviteePni.as_ref() {
                my_size += ::protobuf::rt::bytes_size(3, &v);
            }
            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 Some(v) = self.inviterAci.as_ref() {
                os.write_bytes(1, v)?;
            }
            if let Some(v) = self.inviteeAci.as_ref() {
                os.write_bytes(2, v)?;
            }
            if let Some(v) = self.inviteePni.as_ref() {
                os.write_bytes(3, v)?;
            }
            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() -> Invitee {
            Invitee::new()
        }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupJoinRequestUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupJoinRequestUpdate {
    // message fields
    #[field_name("requestorAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupJoinRequestUpdate.requestorAci)
    pub requestorAci: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupJoinRequestUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.requestorAci = 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.requestorAci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.requestorAci);
        }
        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.requestorAci.is_empty() {
            os.write_bytes(1, &self.requestorAci)?;
        }
        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() -> GroupJoinRequestUpdate {
        GroupJoinRequestUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupJoinRequestApprovalUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupJoinRequestApprovalUpdate {
    // message fields
    #[field_name("requestorAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupJoinRequestApprovalUpdate.requestorAci)
    pub requestorAci: ::std::vec::Vec<u8>,
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupJoinRequestApprovalUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("wasApproved")]
    // @@protoc_insertion_point(field:signal.backup.GroupJoinRequestApprovalUpdate.wasApproved)
    pub wasApproved: bool,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupJoinRequestApprovalUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.requestorAci = is.read_bytes()?;
                },
                18 => {
                    self.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                24 => {
                    self.wasApproved = is.read_bool()?;
                },
                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.requestorAci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.requestorAci);
        }
        if let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if self.wasApproved != false {
            my_size += 1 + 1;
        }
        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.requestorAci.is_empty() {
            os.write_bytes(1, &self.requestorAci)?;
        }
        if let Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(2, v)?;
        }
        if self.wasApproved != false {
            os.write_bool(3, self.wasApproved)?;
        }
        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() -> GroupJoinRequestApprovalUpdate {
        GroupJoinRequestApprovalUpdate::new()
    }

    fn clear(&mut self) {
        self.requestorAci.clear();
        self.updaterAci = ::std::option::Option::None;
        self.wasApproved = false;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GroupJoinRequestApprovalUpdate {
        static instance: GroupJoinRequestApprovalUpdate = GroupJoinRequestApprovalUpdate {
            requestorAci: ::std::vec::Vec::new(),
            updaterAci: ::std::option::Option::None,
            wasApproved: false,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupJoinRequestCanceledUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupJoinRequestCanceledUpdate {
    // message fields
    #[field_name("requestorAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupJoinRequestCanceledUpdate.requestorAci)
    pub requestorAci: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupJoinRequestCanceledUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.requestorAci = 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.requestorAci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.requestorAci);
        }
        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.requestorAci.is_empty() {
            os.write_bytes(1, &self.requestorAci)?;
        }
        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() -> GroupJoinRequestCanceledUpdate {
        GroupJoinRequestCanceledUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupSequenceOfRequestsAndCancelsUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupSequenceOfRequestsAndCancelsUpdate {
    // message fields
    #[field_name("requestorAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupSequenceOfRequestsAndCancelsUpdate.requestorAci)
    pub requestorAci: ::std::vec::Vec<u8>,
    #[field_name("count")]
    // @@protoc_insertion_point(field:signal.backup.GroupSequenceOfRequestsAndCancelsUpdate.count)
    pub count: u32,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupSequenceOfRequestsAndCancelsUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.requestorAci = is.read_bytes()?;
                },
                16 => {
                    self.count = 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.requestorAci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.requestorAci);
        }
        if self.count != 0 {
            my_size += ::protobuf::rt::uint32_size(2, self.count);
        }
        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.requestorAci.is_empty() {
            os.write_bytes(1, &self.requestorAci)?;
        }
        if self.count != 0 {
            os.write_uint32(2, self.count)?;
        }
        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() -> GroupSequenceOfRequestsAndCancelsUpdate {
        GroupSequenceOfRequestsAndCancelsUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupInviteLinkResetUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupInviteLinkResetUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupInviteLinkResetUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupInviteLinkResetUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(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 let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        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() -> GroupInviteLinkResetUpdate {
        GroupInviteLinkResetUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupInviteLinkEnabledUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupInviteLinkEnabledUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupInviteLinkEnabledUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("linkRequiresAdminApproval")]
    // @@protoc_insertion_point(field:signal.backup.GroupInviteLinkEnabledUpdate.linkRequiresAdminApproval)
    pub linkRequiresAdminApproval: bool,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupInviteLinkEnabledUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                16 => {
                    self.linkRequiresAdminApproval = is.read_bool()?;
                },
                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 Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if self.linkRequiresAdminApproval != false {
            my_size += 1 + 1;
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if self.linkRequiresAdminApproval != false {
            os.write_bool(2, self.linkRequiresAdminApproval)?;
        }
        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() -> GroupInviteLinkEnabledUpdate {
        GroupInviteLinkEnabledUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupInviteLinkAdminApprovalUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupInviteLinkAdminApprovalUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupInviteLinkAdminApprovalUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    #[field_name("linkRequiresAdminApproval")]
    // @@protoc_insertion_point(field:signal.backup.GroupInviteLinkAdminApprovalUpdate.linkRequiresAdminApproval)
    pub linkRequiresAdminApproval: bool,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupInviteLinkAdminApprovalUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(is.read_bytes()?);
                },
                16 => {
                    self.linkRequiresAdminApproval = is.read_bool()?;
                },
                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 Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if self.linkRequiresAdminApproval != false {
            my_size += 1 + 1;
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        if self.linkRequiresAdminApproval != false {
            os.write_bool(2, self.linkRequiresAdminApproval)?;
        }
        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() -> GroupInviteLinkAdminApprovalUpdate {
        GroupInviteLinkAdminApprovalUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupInviteLinkDisabledUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupInviteLinkDisabledUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupInviteLinkDisabledUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupInviteLinkDisabledUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(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 let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        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() -> GroupInviteLinkDisabledUpdate {
        GroupInviteLinkDisabledUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupMemberJoinedByLinkUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupMemberJoinedByLinkUpdate {
    // message fields
    #[field_name("newMemberAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupMemberJoinedByLinkUpdate.newMemberAci)
    pub newMemberAci: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupMemberJoinedByLinkUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.newMemberAci = 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.newMemberAci.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.newMemberAci);
        }
        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.newMemberAci.is_empty() {
            os.write_bytes(1, &self.newMemberAci)?;
        }
        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() -> GroupMemberJoinedByLinkUpdate {
        GroupMemberJoinedByLinkUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupV2MigrationUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupV2MigrationUpdate {
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupV2MigrationUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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() -> GroupV2MigrationUpdate {
        GroupV2MigrationUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupV2MigrationSelfInvitedUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupV2MigrationSelfInvitedUpdate {
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupV2MigrationSelfInvitedUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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() -> GroupV2MigrationSelfInvitedUpdate {
        GroupV2MigrationSelfInvitedUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupV2MigrationInvitedMembersUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupV2MigrationInvitedMembersUpdate {
    // message fields
    #[field_name("invitedMembersCount")]
    // @@protoc_insertion_point(field:signal.backup.GroupV2MigrationInvitedMembersUpdate.invitedMembersCount)
    pub invitedMembersCount: u32,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupV2MigrationInvitedMembersUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.invitedMembersCount = 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.invitedMembersCount != 0 {
            my_size += ::protobuf::rt::uint32_size(1, self.invitedMembersCount);
        }
        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.invitedMembersCount != 0 {
            os.write_uint32(1, self.invitedMembersCount)?;
        }
        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() -> GroupV2MigrationInvitedMembersUpdate {
        GroupV2MigrationInvitedMembersUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupV2MigrationDroppedMembersUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupV2MigrationDroppedMembersUpdate {
    // message fields
    #[field_name("droppedMembersCount")]
    // @@protoc_insertion_point(field:signal.backup.GroupV2MigrationDroppedMembersUpdate.droppedMembersCount)
    pub droppedMembersCount: u32,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupV2MigrationDroppedMembersUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.droppedMembersCount = 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.droppedMembersCount != 0 {
            my_size += ::protobuf::rt::uint32_size(1, self.droppedMembersCount);
        }
        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.droppedMembersCount != 0 {
            os.write_uint32(1, self.droppedMembersCount)?;
        }
        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() -> GroupV2MigrationDroppedMembersUpdate {
        GroupV2MigrationDroppedMembersUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupExpirationTimerUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupExpirationTimerUpdate {
    // message fields
    #[field_name("expiresInMs")]
    // @@protoc_insertion_point(field:signal.backup.GroupExpirationTimerUpdate.expiresInMs)
    pub expiresInMs: u64,
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupExpirationTimerUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupExpirationTimerUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.expiresInMs = is.read_uint64()?;
                },
                18 => {
                    self.updaterAci = ::std::option::Option::Some(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.expiresInMs != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.expiresInMs);
        }
        if let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        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.expiresInMs != 0 {
            os.write_uint64(1, self.expiresInMs)?;
        }
        if let Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(2, v)?;
        }
        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() -> GroupExpirationTimerUpdate {
        GroupExpirationTimerUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.GroupTerminateChangeUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GroupTerminateChangeUpdate {
    // message fields
    #[field_name("updaterAci")]
    // @@protoc_insertion_point(field:signal.backup.GroupTerminateChangeUpdate.updaterAci)
    pub updaterAci: ::std::option::Option<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.GroupTerminateChangeUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.updaterAci = ::std::option::Option::Some(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 let Some(v) = self.updaterAci.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        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 Some(v) = self.updaterAci.as_ref() {
            os.write_bytes(1, v)?;
        }
        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() -> GroupTerminateChangeUpdate {
        GroupTerminateChangeUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.PollTerminateUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PollTerminateUpdate {
    // message fields
    #[field_name("targetSentTimestamp")]
    // @@protoc_insertion_point(field:signal.backup.PollTerminateUpdate.targetSentTimestamp)
    pub targetSentTimestamp: u64,
    #[field_name("question")]
    // @@protoc_insertion_point(field:signal.backup.PollTerminateUpdate.question)
    pub question: ::std::string::String,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.PollTerminateUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.targetSentTimestamp = is.read_uint64()?;
                },
                18 => {
                    self.question = is.read_string()?;
                },
                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.targetSentTimestamp != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.targetSentTimestamp);
        }
        if !self.question.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.question);
        }
        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.targetSentTimestamp != 0 {
            os.write_uint64(1, self.targetSentTimestamp)?;
        }
        if !self.question.is_empty() {
            os.write_string(2, &self.question)?;
        }
        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() -> PollTerminateUpdate {
        PollTerminateUpdate::new()
    }

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

    fn default_instance() -> &'static PollTerminateUpdate {
        static instance: PollTerminateUpdate = PollTerminateUpdate {
            targetSentTimestamp: 0,
            question: ::std::string::String::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.PinMessageUpdate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PinMessageUpdate {
    // message fields
    #[field_name("targetSentTimestamp")]
    // @@protoc_insertion_point(field:signal.backup.PinMessageUpdate.targetSentTimestamp)
    pub targetSentTimestamp: u64,
    #[field_name("authorId")]
    // @@protoc_insertion_point(field:signal.backup.PinMessageUpdate.authorId)
    pub authorId: u64,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.PinMessageUpdate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.targetSentTimestamp = is.read_uint64()?;
                },
                16 => {
                    self.authorId = is.read_uint64()?;
                },
                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.targetSentTimestamp != 0 {
            my_size += ::protobuf::rt::uint64_size(1, self.targetSentTimestamp);
        }
        if self.authorId != 0 {
            my_size += ::protobuf::rt::uint64_size(2, self.authorId);
        }
        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.targetSentTimestamp != 0 {
            os.write_uint64(1, self.targetSentTimestamp)?;
        }
        if self.authorId != 0 {
            os.write_uint64(2, self.authorId)?;
        }
        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() -> PinMessageUpdate {
        PinMessageUpdate::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.StickerPack)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct StickerPack {
    // message fields
    #[field_name("packId")]
    // @@protoc_insertion_point(field:signal.backup.StickerPack.packId)
    pub packId: ::std::vec::Vec<u8>,
    #[field_name("packKey")]
    // @@protoc_insertion_point(field:signal.backup.StickerPack.packKey)
    pub packKey: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.StickerPack.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.packId = is.read_bytes()?;
                },
                18 => {
                    self.packKey = 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.packId.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.packId);
        }
        if !self.packKey.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.packKey);
        }
        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.packId.is_empty() {
            os.write_bytes(1, &self.packId)?;
        }
        if !self.packKey.is_empty() {
            os.write_bytes(2, &self.packKey)?;
        }
        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() -> StickerPack {
        StickerPack::new()
    }

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

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

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ChatStyle)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ChatStyle {
    // message fields
    #[field_name("dimWallpaperInDarkMode")]
    // @@protoc_insertion_point(field:signal.backup.ChatStyle.dimWallpaperInDarkMode)
    pub dimWallpaperInDarkMode: bool,
    // message oneof groups
    pub wallpaper: ::std::option::Option<chat_style::Wallpaper>,
    pub bubbleColor: ::std::option::Option<chat_style::BubbleColor>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ChatStyle.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .signal.backup.ChatStyle.WallpaperPreset wallpaperPreset = 1;

    pub fn wallpaperPreset(&self) -> chat_style::WallpaperPreset {
        match self.wallpaper {
            ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPreset(v)) => ::protobuf::EnumOrUnknown::enum_value_or_default(&v),
            _ => chat_style::WallpaperPreset::UNKNOWN_WALLPAPER_PRESET,
        }
    }

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

    pub fn has_wallpaperPreset(&self) -> bool {
        match self.wallpaper {
            ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPreset(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_wallpaperPreset(&mut self, v: chat_style::WallpaperPreset) {
        self.wallpaper = ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPreset(::protobuf::EnumOrUnknown::new(v)))
    }

    // .signal.backup.FilePointer wallpaperPhoto = 2;

    pub fn wallpaperPhoto(&self) -> &FilePointer {
        match self.wallpaper {
            ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPhoto(ref v)) => v,
            _ => <FilePointer as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_wallpaperPhoto(&self) -> bool {
        match self.wallpaper {
            ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPhoto(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_wallpaperPhoto(&mut self, v: FilePointer) {
        self.wallpaper = ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPhoto(v))
    }

    // Mutable pointer to the field.
    pub fn mut_wallpaperPhoto(&mut self) -> &mut FilePointer {
        if let ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPhoto(_)) = self.wallpaper {
        } else {
            self.wallpaper = ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPhoto(FilePointer::new()));
        }
        match self.wallpaper {
            ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPhoto(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_wallpaperPhoto(&mut self) -> FilePointer {
        if self.has_wallpaperPhoto() {
            match self.wallpaper.take() {
                ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPhoto(v)) => v,
                _ => panic!(),
            }
        } else {
            FilePointer::new()
        }
    }

    // .signal.backup.ChatStyle.AutomaticBubbleColor autoBubbleColor = 3;

    pub fn autoBubbleColor(&self) -> &chat_style::AutomaticBubbleColor {
        match self.bubbleColor {
            ::std::option::Option::Some(chat_style::BubbleColor::AutoBubbleColor(ref v)) => v,
            _ => <chat_style::AutomaticBubbleColor as ::protobuf::Message>::default_instance(),
        }
    }

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

    pub fn has_autoBubbleColor(&self) -> bool {
        match self.bubbleColor {
            ::std::option::Option::Some(chat_style::BubbleColor::AutoBubbleColor(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_autoBubbleColor(&mut self, v: chat_style::AutomaticBubbleColor) {
        self.bubbleColor = ::std::option::Option::Some(chat_style::BubbleColor::AutoBubbleColor(v))
    }

    // Mutable pointer to the field.
    pub fn mut_autoBubbleColor(&mut self) -> &mut chat_style::AutomaticBubbleColor {
        if let ::std::option::Option::Some(chat_style::BubbleColor::AutoBubbleColor(_)) = self.bubbleColor {
        } else {
            self.bubbleColor = ::std::option::Option::Some(chat_style::BubbleColor::AutoBubbleColor(chat_style::AutomaticBubbleColor::new()));
        }
        match self.bubbleColor {
            ::std::option::Option::Some(chat_style::BubbleColor::AutoBubbleColor(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_autoBubbleColor(&mut self) -> chat_style::AutomaticBubbleColor {
        if self.has_autoBubbleColor() {
            match self.bubbleColor.take() {
                ::std::option::Option::Some(chat_style::BubbleColor::AutoBubbleColor(v)) => v,
                _ => panic!(),
            }
        } else {
            chat_style::AutomaticBubbleColor::new()
        }
    }

    // .signal.backup.ChatStyle.BubbleColorPreset bubbleColorPreset = 4;

    pub fn bubbleColorPreset(&self) -> chat_style::BubbleColorPreset {
        match self.bubbleColor {
            ::std::option::Option::Some(chat_style::BubbleColor::BubbleColorPreset(v)) => ::protobuf::EnumOrUnknown::enum_value_or_default(&v),
            _ => chat_style::BubbleColorPreset::UNKNOWN_BUBBLE_COLOR_PRESET,
        }
    }

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

    pub fn has_bubbleColorPreset(&self) -> bool {
        match self.bubbleColor {
            ::std::option::Option::Some(chat_style::BubbleColor::BubbleColorPreset(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bubbleColorPreset(&mut self, v: chat_style::BubbleColorPreset) {
        self.bubbleColor = ::std::option::Option::Some(chat_style::BubbleColor::BubbleColorPreset(::protobuf::EnumOrUnknown::new(v)))
    }

    // uint64 customColorId = 5;

    pub fn customColorId(&self) -> u64 {
        match self.bubbleColor {
            ::std::option::Option::Some(chat_style::BubbleColor::CustomColorId(v)) => v,
            _ => 0,
        }
    }

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

    pub fn has_customColorId(&self) -> bool {
        match self.bubbleColor {
            ::std::option::Option::Some(chat_style::BubbleColor::CustomColorId(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_customColorId(&mut self, v: u64) {
        self.bubbleColor = ::std::option::Option::Some(chat_style::BubbleColor::CustomColorId(v))
    }
}

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

    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.wallpaper = ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPreset(is.read_enum_or_unknown()?));
                },
                18 => {
                    self.wallpaper = ::std::option::Option::Some(chat_style::Wallpaper::WallpaperPhoto(is.read_message()?));
                },
                26 => {
                    self.bubbleColor = ::std::option::Option::Some(chat_style::BubbleColor::AutoBubbleColor(is.read_message()?));
                },
                32 => {
                    self.bubbleColor = ::std::option::Option::Some(chat_style::BubbleColor::BubbleColorPreset(is.read_enum_or_unknown()?));
                },
                40 => {
                    self.bubbleColor = ::std::option::Option::Some(chat_style::BubbleColor::CustomColorId(is.read_uint64()?));
                },
                56 => {
                    self.dimWallpaperInDarkMode = is.read_bool()?;
                },
                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.dimWallpaperInDarkMode != false {
            my_size += 1 + 1;
        }
        if let ::std::option::Option::Some(ref v) = self.wallpaper {
            match v {
                &chat_style::Wallpaper::WallpaperPreset(v) => {
                    my_size += ::protobuf::rt::int32_size(1, v.value());
                },
                &chat_style::Wallpaper::WallpaperPhoto(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
            };
        }
        if let ::std::option::Option::Some(ref v) = self.bubbleColor {
            match v {
                &chat_style::BubbleColor::AutoBubbleColor(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &chat_style::BubbleColor::BubbleColorPreset(v) => {
                    my_size += ::protobuf::rt::int32_size(4, v.value());
                },
                &chat_style::BubbleColor::CustomColorId(v) => {
                    my_size += ::protobuf::rt::uint64_size(5, v);
                },
            };
        }
        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.dimWallpaperInDarkMode != false {
            os.write_bool(7, self.dimWallpaperInDarkMode)?;
        }
        if let ::std::option::Option::Some(ref v) = self.wallpaper {
            match v {
                &chat_style::Wallpaper::WallpaperPreset(v) => {
                    os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
                },
                &chat_style::Wallpaper::WallpaperPhoto(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
            };
        }
        if let ::std::option::Option::Some(ref v) = self.bubbleColor {
            match v {
                &chat_style::BubbleColor::AutoBubbleColor(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &chat_style::BubbleColor::BubbleColorPreset(v) => {
                    os.write_enum(4, ::protobuf::EnumOrUnknown::value(&v))?;
                },
                &chat_style::BubbleColor::CustomColorId(v) => {
                    os.write_uint64(5, v)?;
                },
            };
        }
        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() -> ChatStyle {
        ChatStyle::new()
    }

    fn clear(&mut self) {
        self.wallpaper = ::std::option::Option::None;
        self.wallpaper = ::std::option::Option::None;
        self.bubbleColor = ::std::option::Option::None;
        self.bubbleColor = ::std::option::Option::None;
        self.bubbleColor = ::std::option::Option::None;
        self.dimWallpaperInDarkMode = false;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ChatStyle {
        static instance: ChatStyle = ChatStyle {
            dimWallpaperInDarkMode: false,
            wallpaper: ::std::option::Option::None,
            bubbleColor: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `ChatStyle`
pub mod chat_style {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.ChatStyle.wallpaper)
    pub enum Wallpaper {
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatStyle.wallpaperPreset)
        WallpaperPreset(::protobuf::EnumOrUnknown<WallpaperPreset>),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatStyle.wallpaperPhoto)
        WallpaperPhoto(super::FilePointer),
    }

    impl ::protobuf::Oneof for Wallpaper {
    }

    impl Wallpaper {
    }

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(oneof:signal.backup.ChatStyle.bubbleColor)
    pub enum BubbleColor {
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatStyle.autoBubbleColor)
        AutoBubbleColor(AutomaticBubbleColor),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatStyle.bubbleColorPreset)
        BubbleColorPreset(::protobuf::EnumOrUnknown<BubbleColorPreset>),
        // @@protoc_insertion_point(oneof_field:signal.backup.ChatStyle.customColorId)
        CustomColorId(u64),
    }

    impl ::protobuf::Oneof for BubbleColor {
    }

    impl BubbleColor {
    }
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ChatStyle.Gradient)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Gradient {
        // message fields
        #[field_name("angle")]
        // @@protoc_insertion_point(field:signal.backup.ChatStyle.Gradient.angle)
        pub angle: u32,
        #[field_name("colors")]
        // @@protoc_insertion_point(field:signal.backup.ChatStyle.Gradient.colors)
        pub colors: ::std::vec::Vec<u32>,
        #[field_name("positions")]
        // @@protoc_insertion_point(field:signal.backup.ChatStyle.Gradient.positions)
        pub positions: ::std::vec::Vec<f32>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ChatStyle.Gradient.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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.angle = is.read_uint32()?;
                    },
                    18 => {
                        is.read_repeated_packed_fixed32_into(&mut self.colors)?;
                    },
                    21 => {
                        self.colors.push(is.read_fixed32()?);
                    },
                    26 => {
                        is.read_repeated_packed_float_into(&mut self.positions)?;
                    },
                    29 => {
                        self.positions.push(is.read_float()?);
                    },
                    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.angle != 0 {
                my_size += ::protobuf::rt::uint32_size(1, self.angle);
            }
            my_size += ::protobuf::rt::vec_packed_fixed32_size(2, &self.colors);
            my_size += ::protobuf::rt::vec_packed_float_size(3, &self.positions);
            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.angle != 0 {
                os.write_uint32(1, self.angle)?;
            }
            os.write_repeated_packed_fixed32(2, &self.colors)?;
            os.write_repeated_packed_float(3, &self.positions)?;
            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() -> Gradient {
            Gradient::new()
        }

        fn clear(&mut self) {
            self.angle = 0;
            self.colors.clear();
            self.positions.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Gradient {
            static instance: Gradient = Gradient {
                angle: 0,
                colors: ::std::vec::Vec::new(),
                positions: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ChatStyle.CustomChatColor)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct CustomChatColor {
        // message fields
        #[field_name("id")]
        // @@protoc_insertion_point(field:signal.backup.ChatStyle.CustomChatColor.id)
        pub id: u64,
        // message oneof groups
        pub color: ::std::option::Option<custom_chat_color::Color>,
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ChatStyle.CustomChatColor.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        // fixed32 solid = 2;

        pub fn solid(&self) -> u32 {
            match self.color {
                ::std::option::Option::Some(custom_chat_color::Color::Solid(v)) => v,
                _ => 0,
            }
        }

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

        pub fn has_solid(&self) -> bool {
            match self.color {
                ::std::option::Option::Some(custom_chat_color::Color::Solid(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_solid(&mut self, v: u32) {
            self.color = ::std::option::Option::Some(custom_chat_color::Color::Solid(v))
        }

        // .signal.backup.ChatStyle.Gradient gradient = 3;

        pub fn gradient(&self) -> &Gradient {
            match self.color {
                ::std::option::Option::Some(custom_chat_color::Color::Gradient(ref v)) => v,
                _ => <Gradient as ::protobuf::Message>::default_instance(),
            }
        }

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

        pub fn has_gradient(&self) -> bool {
            match self.color {
                ::std::option::Option::Some(custom_chat_color::Color::Gradient(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_gradient(&mut self, v: Gradient) {
            self.color = ::std::option::Option::Some(custom_chat_color::Color::Gradient(v))
        }

        // Mutable pointer to the field.
        pub fn mut_gradient(&mut self) -> &mut Gradient {
            if let ::std::option::Option::Some(custom_chat_color::Color::Gradient(_)) = self.color {
            } else {
                self.color = ::std::option::Option::Some(custom_chat_color::Color::Gradient(Gradient::new()));
            }
            match self.color {
                ::std::option::Option::Some(custom_chat_color::Color::Gradient(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_gradient(&mut self) -> Gradient {
            if self.has_gradient() {
                match self.color.take() {
                    ::std::option::Option::Some(custom_chat_color::Color::Gradient(v)) => v,
                    _ => panic!(),
                }
            } else {
                Gradient::new()
            }
        }
    }

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

        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.id = is.read_uint64()?;
                    },
                    21 => {
                        self.color = ::std::option::Option::Some(custom_chat_color::Color::Solid(is.read_fixed32()?));
                    },
                    26 => {
                        self.color = ::std::option::Option::Some(custom_chat_color::Color::Gradient(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 self.id != 0 {
                my_size += ::protobuf::rt::uint64_size(1, self.id);
            }
            if let ::std::option::Option::Some(ref v) = self.color {
                match v {
                    &custom_chat_color::Color::Solid(v) => {
                        my_size += 1 + 4;
                    },
                    &custom_chat_color::Color::Gradient(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 self.id != 0 {
                os.write_uint64(1, self.id)?;
            }
            if let ::std::option::Option::Some(ref v) = self.color {
                match v {
                    &custom_chat_color::Color::Solid(v) => {
                        os.write_fixed32(2, v)?;
                    },
                    &custom_chat_color::Color::Gradient(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(3, 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() -> CustomChatColor {
            CustomChatColor::new()
        }

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

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

    /// Nested message and enums of message `CustomChatColor`
    pub mod custom_chat_color {

        #[derive(Clone,PartialEq,Debug)]
        #[non_exhaustive]
        #[derive(crate::unknown::visit_static::VisitUnknownFields)]
        // @@protoc_insertion_point(oneof:signal.backup.ChatStyle.CustomChatColor.color)
        pub enum Color {
            // @@protoc_insertion_point(oneof_field:signal.backup.ChatStyle.CustomChatColor.solid)
            Solid(u32),
            // @@protoc_insertion_point(oneof_field:signal.backup.ChatStyle.CustomChatColor.gradient)
            Gradient(super::Gradient),
        }

        impl ::protobuf::Oneof for Color {
        }

        impl Color {
        }
    }

    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(message:signal.backup.ChatStyle.AutomaticBubbleColor)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct AutomaticBubbleColor {
        // special fields
        // @@protoc_insertion_point(special_field:signal.backup.ChatStyle.AutomaticBubbleColor.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

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

        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() -> AutomaticBubbleColor {
            AutomaticBubbleColor::new()
        }

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

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

    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.ChatStyle.WallpaperPreset)
    pub enum WallpaperPreset {
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.UNKNOWN_WALLPAPER_PRESET)
        UNKNOWN_WALLPAPER_PRESET = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_BLUSH)
        SOLID_BLUSH = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_COPPER)
        SOLID_COPPER = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_DUST)
        SOLID_DUST = 3,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_CELADON)
        SOLID_CELADON = 4,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_RAINFOREST)
        SOLID_RAINFOREST = 5,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_PACIFIC)
        SOLID_PACIFIC = 6,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_FROST)
        SOLID_FROST = 7,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_NAVY)
        SOLID_NAVY = 8,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_LILAC)
        SOLID_LILAC = 9,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_PINK)
        SOLID_PINK = 10,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_EGGPLANT)
        SOLID_EGGPLANT = 11,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.SOLID_SILVER)
        SOLID_SILVER = 12,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.GRADIENT_SUNSET)
        GRADIENT_SUNSET = 13,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.GRADIENT_NOIR)
        GRADIENT_NOIR = 14,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.GRADIENT_HEATMAP)
        GRADIENT_HEATMAP = 15,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.GRADIENT_AQUA)
        GRADIENT_AQUA = 16,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.GRADIENT_IRIDESCENT)
        GRADIENT_IRIDESCENT = 17,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.GRADIENT_MONSTERA)
        GRADIENT_MONSTERA = 18,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.GRADIENT_BLISS)
        GRADIENT_BLISS = 19,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.GRADIENT_SKY)
        GRADIENT_SKY = 20,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.WallpaperPreset.GRADIENT_PEACH)
        GRADIENT_PEACH = 21,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<WallpaperPreset> {
            match value {
                0 => ::std::option::Option::Some(WallpaperPreset::UNKNOWN_WALLPAPER_PRESET),
                1 => ::std::option::Option::Some(WallpaperPreset::SOLID_BLUSH),
                2 => ::std::option::Option::Some(WallpaperPreset::SOLID_COPPER),
                3 => ::std::option::Option::Some(WallpaperPreset::SOLID_DUST),
                4 => ::std::option::Option::Some(WallpaperPreset::SOLID_CELADON),
                5 => ::std::option::Option::Some(WallpaperPreset::SOLID_RAINFOREST),
                6 => ::std::option::Option::Some(WallpaperPreset::SOLID_PACIFIC),
                7 => ::std::option::Option::Some(WallpaperPreset::SOLID_FROST),
                8 => ::std::option::Option::Some(WallpaperPreset::SOLID_NAVY),
                9 => ::std::option::Option::Some(WallpaperPreset::SOLID_LILAC),
                10 => ::std::option::Option::Some(WallpaperPreset::SOLID_PINK),
                11 => ::std::option::Option::Some(WallpaperPreset::SOLID_EGGPLANT),
                12 => ::std::option::Option::Some(WallpaperPreset::SOLID_SILVER),
                13 => ::std::option::Option::Some(WallpaperPreset::GRADIENT_SUNSET),
                14 => ::std::option::Option::Some(WallpaperPreset::GRADIENT_NOIR),
                15 => ::std::option::Option::Some(WallpaperPreset::GRADIENT_HEATMAP),
                16 => ::std::option::Option::Some(WallpaperPreset::GRADIENT_AQUA),
                17 => ::std::option::Option::Some(WallpaperPreset::GRADIENT_IRIDESCENT),
                18 => ::std::option::Option::Some(WallpaperPreset::GRADIENT_MONSTERA),
                19 => ::std::option::Option::Some(WallpaperPreset::GRADIENT_BLISS),
                20 => ::std::option::Option::Some(WallpaperPreset::GRADIENT_SKY),
                21 => ::std::option::Option::Some(WallpaperPreset::GRADIENT_PEACH),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<WallpaperPreset> {
            match str {
                "UNKNOWN_WALLPAPER_PRESET" => ::std::option::Option::Some(WallpaperPreset::UNKNOWN_WALLPAPER_PRESET),
                "SOLID_BLUSH" => ::std::option::Option::Some(WallpaperPreset::SOLID_BLUSH),
                "SOLID_COPPER" => ::std::option::Option::Some(WallpaperPreset::SOLID_COPPER),
                "SOLID_DUST" => ::std::option::Option::Some(WallpaperPreset::SOLID_DUST),
                "SOLID_CELADON" => ::std::option::Option::Some(WallpaperPreset::SOLID_CELADON),
                "SOLID_RAINFOREST" => ::std::option::Option::Some(WallpaperPreset::SOLID_RAINFOREST),
                "SOLID_PACIFIC" => ::std::option::Option::Some(WallpaperPreset::SOLID_PACIFIC),
                "SOLID_FROST" => ::std::option::Option::Some(WallpaperPreset::SOLID_FROST),
                "SOLID_NAVY" => ::std::option::Option::Some(WallpaperPreset::SOLID_NAVY),
                "SOLID_LILAC" => ::std::option::Option::Some(WallpaperPreset::SOLID_LILAC),
                "SOLID_PINK" => ::std::option::Option::Some(WallpaperPreset::SOLID_PINK),
                "SOLID_EGGPLANT" => ::std::option::Option::Some(WallpaperPreset::SOLID_EGGPLANT),
                "SOLID_SILVER" => ::std::option::Option::Some(WallpaperPreset::SOLID_SILVER),
                "GRADIENT_SUNSET" => ::std::option::Option::Some(WallpaperPreset::GRADIENT_SUNSET),
                "GRADIENT_NOIR" => ::std::option::Option::Some(WallpaperPreset::GRADIENT_NOIR),
                "GRADIENT_HEATMAP" => ::std::option::Option::Some(WallpaperPreset::GRADIENT_HEATMAP),
                "GRADIENT_AQUA" => ::std::option::Option::Some(WallpaperPreset::GRADIENT_AQUA),
                "GRADIENT_IRIDESCENT" => ::std::option::Option::Some(WallpaperPreset::GRADIENT_IRIDESCENT),
                "GRADIENT_MONSTERA" => ::std::option::Option::Some(WallpaperPreset::GRADIENT_MONSTERA),
                "GRADIENT_BLISS" => ::std::option::Option::Some(WallpaperPreset::GRADIENT_BLISS),
                "GRADIENT_SKY" => ::std::option::Option::Some(WallpaperPreset::GRADIENT_SKY),
                "GRADIENT_PEACH" => ::std::option::Option::Some(WallpaperPreset::GRADIENT_PEACH),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [WallpaperPreset] = &[
            WallpaperPreset::UNKNOWN_WALLPAPER_PRESET,
            WallpaperPreset::SOLID_BLUSH,
            WallpaperPreset::SOLID_COPPER,
            WallpaperPreset::SOLID_DUST,
            WallpaperPreset::SOLID_CELADON,
            WallpaperPreset::SOLID_RAINFOREST,
            WallpaperPreset::SOLID_PACIFIC,
            WallpaperPreset::SOLID_FROST,
            WallpaperPreset::SOLID_NAVY,
            WallpaperPreset::SOLID_LILAC,
            WallpaperPreset::SOLID_PINK,
            WallpaperPreset::SOLID_EGGPLANT,
            WallpaperPreset::SOLID_SILVER,
            WallpaperPreset::GRADIENT_SUNSET,
            WallpaperPreset::GRADIENT_NOIR,
            WallpaperPreset::GRADIENT_HEATMAP,
            WallpaperPreset::GRADIENT_AQUA,
            WallpaperPreset::GRADIENT_IRIDESCENT,
            WallpaperPreset::GRADIENT_MONSTERA,
            WallpaperPreset::GRADIENT_BLISS,
            WallpaperPreset::GRADIENT_SKY,
            WallpaperPreset::GRADIENT_PEACH,
        ];
    }

    impl ::std::default::Default for WallpaperPreset {
        fn default() -> Self {
            WallpaperPreset::UNKNOWN_WALLPAPER_PRESET
        }
    }


    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.ChatStyle.BubbleColorPreset)
    pub enum BubbleColorPreset {
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.UNKNOWN_BUBBLE_COLOR_PRESET)
        UNKNOWN_BUBBLE_COLOR_PRESET = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_ULTRAMARINE)
        SOLID_ULTRAMARINE = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_CRIMSON)
        SOLID_CRIMSON = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_VERMILION)
        SOLID_VERMILION = 3,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_BURLAP)
        SOLID_BURLAP = 4,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_FOREST)
        SOLID_FOREST = 5,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_WINTERGREEN)
        SOLID_WINTERGREEN = 6,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_TEAL)
        SOLID_TEAL = 7,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_BLUE)
        SOLID_BLUE = 8,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_INDIGO)
        SOLID_INDIGO = 9,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_VIOLET)
        SOLID_VIOLET = 10,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_PLUM)
        SOLID_PLUM = 11,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_TAUPE)
        SOLID_TAUPE = 12,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.SOLID_STEEL)
        SOLID_STEEL = 13,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.GRADIENT_EMBER)
        GRADIENT_EMBER = 14,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.GRADIENT_MIDNIGHT)
        GRADIENT_MIDNIGHT = 15,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.GRADIENT_INFRARED)
        GRADIENT_INFRARED = 16,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.GRADIENT_LAGOON)
        GRADIENT_LAGOON = 17,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.GRADIENT_FLUORESCENT)
        GRADIENT_FLUORESCENT = 18,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.GRADIENT_BASIL)
        GRADIENT_BASIL = 19,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.GRADIENT_SUBLIME)
        GRADIENT_SUBLIME = 20,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.GRADIENT_SEA)
        GRADIENT_SEA = 21,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatStyle.BubbleColorPreset.GRADIENT_TANGERINE)
        GRADIENT_TANGERINE = 22,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<BubbleColorPreset> {
            match value {
                0 => ::std::option::Option::Some(BubbleColorPreset::UNKNOWN_BUBBLE_COLOR_PRESET),
                1 => ::std::option::Option::Some(BubbleColorPreset::SOLID_ULTRAMARINE),
                2 => ::std::option::Option::Some(BubbleColorPreset::SOLID_CRIMSON),
                3 => ::std::option::Option::Some(BubbleColorPreset::SOLID_VERMILION),
                4 => ::std::option::Option::Some(BubbleColorPreset::SOLID_BURLAP),
                5 => ::std::option::Option::Some(BubbleColorPreset::SOLID_FOREST),
                6 => ::std::option::Option::Some(BubbleColorPreset::SOLID_WINTERGREEN),
                7 => ::std::option::Option::Some(BubbleColorPreset::SOLID_TEAL),
                8 => ::std::option::Option::Some(BubbleColorPreset::SOLID_BLUE),
                9 => ::std::option::Option::Some(BubbleColorPreset::SOLID_INDIGO),
                10 => ::std::option::Option::Some(BubbleColorPreset::SOLID_VIOLET),
                11 => ::std::option::Option::Some(BubbleColorPreset::SOLID_PLUM),
                12 => ::std::option::Option::Some(BubbleColorPreset::SOLID_TAUPE),
                13 => ::std::option::Option::Some(BubbleColorPreset::SOLID_STEEL),
                14 => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_EMBER),
                15 => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_MIDNIGHT),
                16 => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_INFRARED),
                17 => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_LAGOON),
                18 => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_FLUORESCENT),
                19 => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_BASIL),
                20 => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_SUBLIME),
                21 => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_SEA),
                22 => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_TANGERINE),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<BubbleColorPreset> {
            match str {
                "UNKNOWN_BUBBLE_COLOR_PRESET" => ::std::option::Option::Some(BubbleColorPreset::UNKNOWN_BUBBLE_COLOR_PRESET),
                "SOLID_ULTRAMARINE" => ::std::option::Option::Some(BubbleColorPreset::SOLID_ULTRAMARINE),
                "SOLID_CRIMSON" => ::std::option::Option::Some(BubbleColorPreset::SOLID_CRIMSON),
                "SOLID_VERMILION" => ::std::option::Option::Some(BubbleColorPreset::SOLID_VERMILION),
                "SOLID_BURLAP" => ::std::option::Option::Some(BubbleColorPreset::SOLID_BURLAP),
                "SOLID_FOREST" => ::std::option::Option::Some(BubbleColorPreset::SOLID_FOREST),
                "SOLID_WINTERGREEN" => ::std::option::Option::Some(BubbleColorPreset::SOLID_WINTERGREEN),
                "SOLID_TEAL" => ::std::option::Option::Some(BubbleColorPreset::SOLID_TEAL),
                "SOLID_BLUE" => ::std::option::Option::Some(BubbleColorPreset::SOLID_BLUE),
                "SOLID_INDIGO" => ::std::option::Option::Some(BubbleColorPreset::SOLID_INDIGO),
                "SOLID_VIOLET" => ::std::option::Option::Some(BubbleColorPreset::SOLID_VIOLET),
                "SOLID_PLUM" => ::std::option::Option::Some(BubbleColorPreset::SOLID_PLUM),
                "SOLID_TAUPE" => ::std::option::Option::Some(BubbleColorPreset::SOLID_TAUPE),
                "SOLID_STEEL" => ::std::option::Option::Some(BubbleColorPreset::SOLID_STEEL),
                "GRADIENT_EMBER" => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_EMBER),
                "GRADIENT_MIDNIGHT" => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_MIDNIGHT),
                "GRADIENT_INFRARED" => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_INFRARED),
                "GRADIENT_LAGOON" => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_LAGOON),
                "GRADIENT_FLUORESCENT" => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_FLUORESCENT),
                "GRADIENT_BASIL" => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_BASIL),
                "GRADIENT_SUBLIME" => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_SUBLIME),
                "GRADIENT_SEA" => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_SEA),
                "GRADIENT_TANGERINE" => ::std::option::Option::Some(BubbleColorPreset::GRADIENT_TANGERINE),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [BubbleColorPreset] = &[
            BubbleColorPreset::UNKNOWN_BUBBLE_COLOR_PRESET,
            BubbleColorPreset::SOLID_ULTRAMARINE,
            BubbleColorPreset::SOLID_CRIMSON,
            BubbleColorPreset::SOLID_VERMILION,
            BubbleColorPreset::SOLID_BURLAP,
            BubbleColorPreset::SOLID_FOREST,
            BubbleColorPreset::SOLID_WINTERGREEN,
            BubbleColorPreset::SOLID_TEAL,
            BubbleColorPreset::SOLID_BLUE,
            BubbleColorPreset::SOLID_INDIGO,
            BubbleColorPreset::SOLID_VIOLET,
            BubbleColorPreset::SOLID_PLUM,
            BubbleColorPreset::SOLID_TAUPE,
            BubbleColorPreset::SOLID_STEEL,
            BubbleColorPreset::GRADIENT_EMBER,
            BubbleColorPreset::GRADIENT_MIDNIGHT,
            BubbleColorPreset::GRADIENT_INFRARED,
            BubbleColorPreset::GRADIENT_LAGOON,
            BubbleColorPreset::GRADIENT_FLUORESCENT,
            BubbleColorPreset::GRADIENT_BASIL,
            BubbleColorPreset::GRADIENT_SUBLIME,
            BubbleColorPreset::GRADIENT_SEA,
            BubbleColorPreset::GRADIENT_TANGERINE,
        ];
    }

    impl ::std::default::Default for BubbleColorPreset {
        fn default() -> Self {
            BubbleColorPreset::UNKNOWN_BUBBLE_COLOR_PRESET
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.NotificationProfile)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct NotificationProfile {
    // message fields
    #[field_name("name")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.name)
    pub name: ::std::string::String,
    #[field_name("emoji")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.emoji)
    pub emoji: ::std::option::Option<::std::string::String>,
    #[field_name("color")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.color)
    pub color: u32,
    #[field_name("createdAtMs")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.createdAtMs)
    pub createdAtMs: u64,
    #[field_name("allowAllCalls")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.allowAllCalls)
    pub allowAllCalls: bool,
    #[field_name("allowAllMentions")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.allowAllMentions)
    pub allowAllMentions: bool,
    #[field_name("allowedMembers")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.allowedMembers)
    pub allowedMembers: ::std::vec::Vec<u64>,
    #[field_name("scheduleEnabled")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.scheduleEnabled)
    pub scheduleEnabled: bool,
    #[field_name("scheduleStartTime")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.scheduleStartTime)
    pub scheduleStartTime: u32,
    #[field_name("scheduleEndTime")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.scheduleEndTime)
    pub scheduleEndTime: u32,
    #[field_name("scheduleDaysEnabled")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.scheduleDaysEnabled)
    pub scheduleDaysEnabled: ::std::vec::Vec<::protobuf::EnumOrUnknown<notification_profile::DayOfWeek>>,
    #[field_name("id")]
    // @@protoc_insertion_point(field:signal.backup.NotificationProfile.id)
    pub id: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.NotificationProfile.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.name = is.read_string()?;
                },
                18 => {
                    self.emoji = ::std::option::Option::Some(is.read_string()?);
                },
                29 => {
                    self.color = is.read_fixed32()?;
                },
                32 => {
                    self.createdAtMs = is.read_uint64()?;
                },
                40 => {
                    self.allowAllCalls = is.read_bool()?;
                },
                48 => {
                    self.allowAllMentions = is.read_bool()?;
                },
                58 => {
                    is.read_repeated_packed_uint64_into(&mut self.allowedMembers)?;
                },
                56 => {
                    self.allowedMembers.push(is.read_uint64()?);
                },
                64 => {
                    self.scheduleEnabled = is.read_bool()?;
                },
                72 => {
                    self.scheduleStartTime = is.read_uint32()?;
                },
                80 => {
                    self.scheduleEndTime = is.read_uint32()?;
                },
                88 => {
                    self.scheduleDaysEnabled.push(is.read_enum_or_unknown()?);
                },
                90 => {
                    ::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.scheduleDaysEnabled)?
                },
                98 => {
                    self.id = 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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if let Some(v) = self.emoji.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if self.color != 0 {
            my_size += 1 + 4;
        }
        if self.createdAtMs != 0 {
            my_size += ::protobuf::rt::uint64_size(4, self.createdAtMs);
        }
        if self.allowAllCalls != false {
            my_size += 1 + 1;
        }
        if self.allowAllMentions != false {
            my_size += 1 + 1;
        }
        my_size += ::protobuf::rt::vec_packed_uint64_size(7, &self.allowedMembers);
        if self.scheduleEnabled != false {
            my_size += 1 + 1;
        }
        if self.scheduleStartTime != 0 {
            my_size += ::protobuf::rt::uint32_size(9, self.scheduleStartTime);
        }
        if self.scheduleEndTime != 0 {
            my_size += ::protobuf::rt::uint32_size(10, self.scheduleEndTime);
        }
        my_size += ::protobuf::rt::vec_packed_enum_or_unknown_size(11, &self.scheduleDaysEnabled);
        if !self.id.is_empty() {
            my_size += ::protobuf::rt::bytes_size(12, &self.id);
        }
        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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if let Some(v) = self.emoji.as_ref() {
            os.write_string(2, v)?;
        }
        if self.color != 0 {
            os.write_fixed32(3, self.color)?;
        }
        if self.createdAtMs != 0 {
            os.write_uint64(4, self.createdAtMs)?;
        }
        if self.allowAllCalls != false {
            os.write_bool(5, self.allowAllCalls)?;
        }
        if self.allowAllMentions != false {
            os.write_bool(6, self.allowAllMentions)?;
        }
        os.write_repeated_packed_uint64(7, &self.allowedMembers)?;
        if self.scheduleEnabled != false {
            os.write_bool(8, self.scheduleEnabled)?;
        }
        if self.scheduleStartTime != 0 {
            os.write_uint32(9, self.scheduleStartTime)?;
        }
        if self.scheduleEndTime != 0 {
            os.write_uint32(10, self.scheduleEndTime)?;
        }
        os.write_repeated_packed_enum_or_unknown(11, &self.scheduleDaysEnabled)?;
        if !self.id.is_empty() {
            os.write_bytes(12, &self.id)?;
        }
        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() -> NotificationProfile {
        NotificationProfile::new()
    }

    fn clear(&mut self) {
        self.name.clear();
        self.emoji = ::std::option::Option::None;
        self.color = 0;
        self.createdAtMs = 0;
        self.allowAllCalls = false;
        self.allowAllMentions = false;
        self.allowedMembers.clear();
        self.scheduleEnabled = false;
        self.scheduleStartTime = 0;
        self.scheduleEndTime = 0;
        self.scheduleDaysEnabled.clear();
        self.id.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static NotificationProfile {
        static instance: NotificationProfile = NotificationProfile {
            name: ::std::string::String::new(),
            emoji: ::std::option::Option::None,
            color: 0,
            createdAtMs: 0,
            allowAllCalls: false,
            allowAllMentions: false,
            allowedMembers: ::std::vec::Vec::new(),
            scheduleEnabled: false,
            scheduleStartTime: 0,
            scheduleEndTime: 0,
            scheduleDaysEnabled: ::std::vec::Vec::new(),
            id: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `NotificationProfile`
pub mod notification_profile {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.NotificationProfile.DayOfWeek)
    pub enum DayOfWeek {
        // @@protoc_insertion_point(enum_value:signal.backup.NotificationProfile.DayOfWeek.UNKNOWN)
        UNKNOWN = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.NotificationProfile.DayOfWeek.MONDAY)
        MONDAY = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.NotificationProfile.DayOfWeek.TUESDAY)
        TUESDAY = 2,
        // @@protoc_insertion_point(enum_value:signal.backup.NotificationProfile.DayOfWeek.WEDNESDAY)
        WEDNESDAY = 3,
        // @@protoc_insertion_point(enum_value:signal.backup.NotificationProfile.DayOfWeek.THURSDAY)
        THURSDAY = 4,
        // @@protoc_insertion_point(enum_value:signal.backup.NotificationProfile.DayOfWeek.FRIDAY)
        FRIDAY = 5,
        // @@protoc_insertion_point(enum_value:signal.backup.NotificationProfile.DayOfWeek.SATURDAY)
        SATURDAY = 6,
        // @@protoc_insertion_point(enum_value:signal.backup.NotificationProfile.DayOfWeek.SUNDAY)
        SUNDAY = 7,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<DayOfWeek> {
            match value {
                0 => ::std::option::Option::Some(DayOfWeek::UNKNOWN),
                1 => ::std::option::Option::Some(DayOfWeek::MONDAY),
                2 => ::std::option::Option::Some(DayOfWeek::TUESDAY),
                3 => ::std::option::Option::Some(DayOfWeek::WEDNESDAY),
                4 => ::std::option::Option::Some(DayOfWeek::THURSDAY),
                5 => ::std::option::Option::Some(DayOfWeek::FRIDAY),
                6 => ::std::option::Option::Some(DayOfWeek::SATURDAY),
                7 => ::std::option::Option::Some(DayOfWeek::SUNDAY),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<DayOfWeek> {
            match str {
                "UNKNOWN" => ::std::option::Option::Some(DayOfWeek::UNKNOWN),
                "MONDAY" => ::std::option::Option::Some(DayOfWeek::MONDAY),
                "TUESDAY" => ::std::option::Option::Some(DayOfWeek::TUESDAY),
                "WEDNESDAY" => ::std::option::Option::Some(DayOfWeek::WEDNESDAY),
                "THURSDAY" => ::std::option::Option::Some(DayOfWeek::THURSDAY),
                "FRIDAY" => ::std::option::Option::Some(DayOfWeek::FRIDAY),
                "SATURDAY" => ::std::option::Option::Some(DayOfWeek::SATURDAY),
                "SUNDAY" => ::std::option::Option::Some(DayOfWeek::SUNDAY),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [DayOfWeek] = &[
            DayOfWeek::UNKNOWN,
            DayOfWeek::MONDAY,
            DayOfWeek::TUESDAY,
            DayOfWeek::WEDNESDAY,
            DayOfWeek::THURSDAY,
            DayOfWeek::FRIDAY,
            DayOfWeek::SATURDAY,
            DayOfWeek::SUNDAY,
        ];
    }

    impl ::std::default::Default for DayOfWeek {
        fn default() -> Self {
            DayOfWeek::UNKNOWN
        }
    }

}

#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(message:signal.backup.ChatFolder)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ChatFolder {
    // message fields
    #[field_name("name")]
    // @@protoc_insertion_point(field:signal.backup.ChatFolder.name)
    pub name: ::std::string::String,
    #[field_name("showOnlyUnread")]
    // @@protoc_insertion_point(field:signal.backup.ChatFolder.showOnlyUnread)
    pub showOnlyUnread: bool,
    #[field_name("showMutedChats")]
    // @@protoc_insertion_point(field:signal.backup.ChatFolder.showMutedChats)
    pub showMutedChats: bool,
    #[field_name("includeAllIndividualChats")]
    // @@protoc_insertion_point(field:signal.backup.ChatFolder.includeAllIndividualChats)
    pub includeAllIndividualChats: bool,
    #[field_name("includeAllGroupChats")]
    // @@protoc_insertion_point(field:signal.backup.ChatFolder.includeAllGroupChats)
    pub includeAllGroupChats: bool,
    #[field_name("folderType")]
    // @@protoc_insertion_point(field:signal.backup.ChatFolder.folderType)
    pub folderType: ::protobuf::EnumOrUnknown<chat_folder::FolderType>,
    #[field_name("includedRecipientIds")]
    // @@protoc_insertion_point(field:signal.backup.ChatFolder.includedRecipientIds)
    pub includedRecipientIds: ::std::vec::Vec<u64>,
    #[field_name("excludedRecipientIds")]
    // @@protoc_insertion_point(field:signal.backup.ChatFolder.excludedRecipientIds)
    pub excludedRecipientIds: ::std::vec::Vec<u64>,
    #[field_name("id")]
    // @@protoc_insertion_point(field:signal.backup.ChatFolder.id)
    pub id: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:signal.backup.ChatFolder.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

    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.name = is.read_string()?;
                },
                16 => {
                    self.showOnlyUnread = is.read_bool()?;
                },
                24 => {
                    self.showMutedChats = is.read_bool()?;
                },
                32 => {
                    self.includeAllIndividualChats = is.read_bool()?;
                },
                40 => {
                    self.includeAllGroupChats = is.read_bool()?;
                },
                48 => {
                    self.folderType = is.read_enum_or_unknown()?;
                },
                58 => {
                    is.read_repeated_packed_uint64_into(&mut self.includedRecipientIds)?;
                },
                56 => {
                    self.includedRecipientIds.push(is.read_uint64()?);
                },
                66 => {
                    is.read_repeated_packed_uint64_into(&mut self.excludedRecipientIds)?;
                },
                64 => {
                    self.excludedRecipientIds.push(is.read_uint64()?);
                },
                74 => {
                    self.id = 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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if self.showOnlyUnread != false {
            my_size += 1 + 1;
        }
        if self.showMutedChats != false {
            my_size += 1 + 1;
        }
        if self.includeAllIndividualChats != false {
            my_size += 1 + 1;
        }
        if self.includeAllGroupChats != false {
            my_size += 1 + 1;
        }
        if self.folderType != ::protobuf::EnumOrUnknown::new(chat_folder::FolderType::UNKNOWN) {
            my_size += ::protobuf::rt::int32_size(6, self.folderType.value());
        }
        my_size += ::protobuf::rt::vec_packed_uint64_size(7, &self.includedRecipientIds);
        my_size += ::protobuf::rt::vec_packed_uint64_size(8, &self.excludedRecipientIds);
        if !self.id.is_empty() {
            my_size += ::protobuf::rt::bytes_size(9, &self.id);
        }
        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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.showOnlyUnread != false {
            os.write_bool(2, self.showOnlyUnread)?;
        }
        if self.showMutedChats != false {
            os.write_bool(3, self.showMutedChats)?;
        }
        if self.includeAllIndividualChats != false {
            os.write_bool(4, self.includeAllIndividualChats)?;
        }
        if self.includeAllGroupChats != false {
            os.write_bool(5, self.includeAllGroupChats)?;
        }
        if self.folderType != ::protobuf::EnumOrUnknown::new(chat_folder::FolderType::UNKNOWN) {
            os.write_enum(6, ::protobuf::EnumOrUnknown::value(&self.folderType))?;
        }
        os.write_repeated_packed_uint64(7, &self.includedRecipientIds)?;
        os.write_repeated_packed_uint64(8, &self.excludedRecipientIds)?;
        if !self.id.is_empty() {
            os.write_bytes(9, &self.id)?;
        }
        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() -> ChatFolder {
        ChatFolder::new()
    }

    fn clear(&mut self) {
        self.name.clear();
        self.showOnlyUnread = false;
        self.showMutedChats = false;
        self.includeAllIndividualChats = false;
        self.includeAllGroupChats = false;
        self.folderType = ::protobuf::EnumOrUnknown::new(chat_folder::FolderType::UNKNOWN);
        self.includedRecipientIds.clear();
        self.excludedRecipientIds.clear();
        self.id.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ChatFolder {
        static instance: ChatFolder = ChatFolder {
            name: ::std::string::String::new(),
            showOnlyUnread: false,
            showMutedChats: false,
            includeAllIndividualChats: false,
            includeAllGroupChats: false,
            folderType: ::protobuf::EnumOrUnknown::from_i32(0),
            includedRecipientIds: ::std::vec::Vec::new(),
            excludedRecipientIds: ::std::vec::Vec::new(),
            id: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `ChatFolder`
pub mod chat_folder {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    #[derive(crate::unknown::visit_static::VisitUnknownFields)]
    // @@protoc_insertion_point(enum:signal.backup.ChatFolder.FolderType)
    pub enum FolderType {
        // @@protoc_insertion_point(enum_value:signal.backup.ChatFolder.FolderType.UNKNOWN)
        UNKNOWN = 0,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatFolder.FolderType.ALL)
        ALL = 1,
        // @@protoc_insertion_point(enum_value:signal.backup.ChatFolder.FolderType.CUSTOM)
        CUSTOM = 2,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<FolderType> {
            match value {
                0 => ::std::option::Option::Some(FolderType::UNKNOWN),
                1 => ::std::option::Option::Some(FolderType::ALL),
                2 => ::std::option::Option::Some(FolderType::CUSTOM),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<FolderType> {
            match str {
                "UNKNOWN" => ::std::option::Option::Some(FolderType::UNKNOWN),
                "ALL" => ::std::option::Option::Some(FolderType::ALL),
                "CUSTOM" => ::std::option::Option::Some(FolderType::CUSTOM),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [FolderType] = &[
            FolderType::UNKNOWN,
            FolderType::ALL,
            FolderType::CUSTOM,
        ];
    }

    impl ::std::default::Default for FolderType {
        fn default() -> Self {
            FolderType::UNKNOWN
        }
    }

}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(enum:signal.backup.AvatarColor)
pub enum AvatarColor {
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A100)
    A100 = 0,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A110)
    A110 = 1,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A120)
    A120 = 2,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A130)
    A130 = 3,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A140)
    A140 = 4,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A150)
    A150 = 5,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A160)
    A160 = 6,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A170)
    A170 = 7,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A180)
    A180 = 8,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A190)
    A190 = 9,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A200)
    A200 = 10,
    // @@protoc_insertion_point(enum_value:signal.backup.AvatarColor.A210)
    A210 = 11,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<AvatarColor> {
        match value {
            0 => ::std::option::Option::Some(AvatarColor::A100),
            1 => ::std::option::Option::Some(AvatarColor::A110),
            2 => ::std::option::Option::Some(AvatarColor::A120),
            3 => ::std::option::Option::Some(AvatarColor::A130),
            4 => ::std::option::Option::Some(AvatarColor::A140),
            5 => ::std::option::Option::Some(AvatarColor::A150),
            6 => ::std::option::Option::Some(AvatarColor::A160),
            7 => ::std::option::Option::Some(AvatarColor::A170),
            8 => ::std::option::Option::Some(AvatarColor::A180),
            9 => ::std::option::Option::Some(AvatarColor::A190),
            10 => ::std::option::Option::Some(AvatarColor::A200),
            11 => ::std::option::Option::Some(AvatarColor::A210),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<AvatarColor> {
        match str {
            "A100" => ::std::option::Option::Some(AvatarColor::A100),
            "A110" => ::std::option::Option::Some(AvatarColor::A110),
            "A120" => ::std::option::Option::Some(AvatarColor::A120),
            "A130" => ::std::option::Option::Some(AvatarColor::A130),
            "A140" => ::std::option::Option::Some(AvatarColor::A140),
            "A150" => ::std::option::Option::Some(AvatarColor::A150),
            "A160" => ::std::option::Option::Some(AvatarColor::A160),
            "A170" => ::std::option::Option::Some(AvatarColor::A170),
            "A180" => ::std::option::Option::Some(AvatarColor::A180),
            "A190" => ::std::option::Option::Some(AvatarColor::A190),
            "A200" => ::std::option::Option::Some(AvatarColor::A200),
            "A210" => ::std::option::Option::Some(AvatarColor::A210),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [AvatarColor] = &[
        AvatarColor::A100,
        AvatarColor::A110,
        AvatarColor::A120,
        AvatarColor::A130,
        AvatarColor::A140,
        AvatarColor::A150,
        AvatarColor::A160,
        AvatarColor::A170,
        AvatarColor::A180,
        AvatarColor::A190,
        AvatarColor::A200,
        AvatarColor::A210,
    ];
}

impl ::std::default::Default for AvatarColor {
    fn default() -> Self {
        AvatarColor::A100
    }
}


#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
#[derive(crate::unknown::visit_static::VisitUnknownFields)]
// @@protoc_insertion_point(enum:signal.backup.GroupV2AccessLevel)
pub enum GroupV2AccessLevel {
    // @@protoc_insertion_point(enum_value:signal.backup.GroupV2AccessLevel.UNKNOWN)
    UNKNOWN = 0,
    // @@protoc_insertion_point(enum_value:signal.backup.GroupV2AccessLevel.ANY)
    ANY = 1,
    // @@protoc_insertion_point(enum_value:signal.backup.GroupV2AccessLevel.MEMBER)
    MEMBER = 2,
    // @@protoc_insertion_point(enum_value:signal.backup.GroupV2AccessLevel.ADMINISTRATOR)
    ADMINISTRATOR = 3,
    // @@protoc_insertion_point(enum_value:signal.backup.GroupV2AccessLevel.UNSATISFIABLE)
    UNSATISFIABLE = 4,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<GroupV2AccessLevel> {
        match value {
            0 => ::std::option::Option::Some(GroupV2AccessLevel::UNKNOWN),
            1 => ::std::option::Option::Some(GroupV2AccessLevel::ANY),
            2 => ::std::option::Option::Some(GroupV2AccessLevel::MEMBER),
            3 => ::std::option::Option::Some(GroupV2AccessLevel::ADMINISTRATOR),
            4 => ::std::option::Option::Some(GroupV2AccessLevel::UNSATISFIABLE),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<GroupV2AccessLevel> {
        match str {
            "UNKNOWN" => ::std::option::Option::Some(GroupV2AccessLevel::UNKNOWN),
            "ANY" => ::std::option::Option::Some(GroupV2AccessLevel::ANY),
            "MEMBER" => ::std::option::Option::Some(GroupV2AccessLevel::MEMBER),
            "ADMINISTRATOR" => ::std::option::Option::Some(GroupV2AccessLevel::ADMINISTRATOR),
            "UNSATISFIABLE" => ::std::option::Option::Some(GroupV2AccessLevel::UNSATISFIABLE),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [GroupV2AccessLevel] = &[
        GroupV2AccessLevel::UNKNOWN,
        GroupV2AccessLevel::ANY,
        GroupV2AccessLevel::MEMBER,
        GroupV2AccessLevel::ADMINISTRATOR,
        GroupV2AccessLevel::UNSATISFIABLE,
    ];
}

impl ::std::default::Default for GroupV2AccessLevel {
    fn default() -> Self {
        GroupV2AccessLevel::UNKNOWN
    }
}

