diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h
--- a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h
+++ b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h
@@ -35,107 +35,113 @@
   class StubInterface {
    public:
     virtual ~StubInterface() {}
-    std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>> ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
-      return std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>>(ResetKeyRaw(context, response));
+    std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> CreateNewBackup(::grpc::ClientContext* context) {
+      return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(CreateNewBackupRaw(context));
     }
-    std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>> AsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
-      return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>>(AsyncResetKeyRaw(context, response, cq, tag));
+    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> AsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(AsyncCreateNewBackupRaw(context, cq, tag));
     }
-    std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>> PrepareAsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>>(PrepareAsyncResetKeyRaw(context, response, cq));
+    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> PrepareAsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(PrepareAsyncCreateNewBackupRaw(context, cq));
     }
-    virtual ::grpc::Status SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) = 0;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncSendLogRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
+      return std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>>(SendLogRaw(context, response));
     }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncSendLogRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>>(AsyncSendLogRaw(context, response, cq, tag));
     }
-    virtual ::grpc::Status PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) = 0;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>> AsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>>(AsyncPullBackupKeyRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>>(PrepareAsyncSendLogRaw(context, response, cq));
     }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>> PrepareAsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>>(PrepareAsyncPullBackupKeyRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> RecoverBackupKey(::grpc::ClientContext* context) {
+      return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(RecoverBackupKeyRaw(context));
     }
-    std::unique_ptr< ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>> PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) {
-      return std::unique_ptr< ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>>(PullCompactionRaw(context, request));
+    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> AsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(AsyncRecoverBackupKeyRaw(context, cq, tag));
     }
-    std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>> AsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
-      return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>>(AsyncPullCompactionRaw(context, request, cq, tag));
+    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> PrepareAsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(PrepareAsyncRecoverBackupKeyRaw(context, cq));
     }
-    std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>> PrepareAsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>>(PrepareAsyncPullCompactionRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PullBackup(::grpc::ClientContext* context) {
+      return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PullBackupRaw(context));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> AsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(AsyncPullBackupRaw(context, cq, tag));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PrepareAsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PrepareAsyncPullBackupRaw(context, cq));
     }
     class async_interface {
      public:
       virtual ~async_interface() {}
-      virtual void ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) = 0;
-      virtual void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) = 0;
-      virtual void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0;
-      virtual void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function<void(::grpc::Status)>) = 0;
-      virtual void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
-      virtual void PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) = 0;
+      virtual void CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) = 0;
+      virtual void SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) = 0;
+      virtual void RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) = 0;
+      virtual void PullBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupRequest,::backup::PullBackupResponse>* reactor) = 0;
     };
     typedef class async_interface experimental_async_interface;
     virtual class async_interface* async() { return nullptr; }
     class async_interface* experimental_async() { return async(); }
    private:
-    virtual ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>* ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) = 0;
-    virtual ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>* AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) = 0;
-    virtual ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>* PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>* AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>* PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) = 0;
-    virtual ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>* PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) = 0;
-    virtual ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>* AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0;
-    virtual ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>* PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackupRaw(::grpc::ClientContext* context) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientWriterInterface< ::backup::SendLogRequest>* SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) = 0;
+    virtual ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>* AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) = 0;
+    virtual ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* RecoverBackupKeyRaw(::grpc::ClientContext* context) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* AsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* PrepareAsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PullBackupRaw(::grpc::ClientContext* context) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* AsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
   };
   class Stub final : public StubInterface {
    public:
     Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
-    std::unique_ptr< ::grpc::ClientWriter< ::backup::ResetKeyRequest>> ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
-      return std::unique_ptr< ::grpc::ClientWriter< ::backup::ResetKeyRequest>>(ResetKeyRaw(context, response));
+    std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> CreateNewBackup(::grpc::ClientContext* context) {
+      return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(CreateNewBackupRaw(context));
+    }
+    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> AsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(AsyncCreateNewBackupRaw(context, cq, tag));
     }
-    std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>> AsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
-      return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>>(AsyncResetKeyRaw(context, response, cq, tag));
+    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> PrepareAsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(PrepareAsyncCreateNewBackupRaw(context, cq));
     }
-    std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>> PrepareAsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>>(PrepareAsyncResetKeyRaw(context, response, cq));
+    std::unique_ptr< ::grpc::ClientWriter< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
+      return std::unique_ptr< ::grpc::ClientWriter< ::backup::SendLogRequest>>(SendLogRaw(context, response));
     }
-    ::grpc::Status SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) override;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncSendLogRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>>(AsyncSendLogRaw(context, response, cq, tag));
     }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncSendLogRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>>(PrepareAsyncSendLogRaw(context, response, cq));
     }
-    ::grpc::Status PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) override;
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>> AsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>>(AsyncPullBackupKeyRaw(context, request, cq));
+    std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> RecoverBackupKey(::grpc::ClientContext* context) {
+      return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(RecoverBackupKeyRaw(context));
     }
-    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>> PrepareAsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>>(PrepareAsyncPullBackupKeyRaw(context, request, cq));
+    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> AsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(AsyncRecoverBackupKeyRaw(context, cq, tag));
     }
-    std::unique_ptr< ::grpc::ClientReader< ::backup::PullCompactionResponse>> PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) {
-      return std::unique_ptr< ::grpc::ClientReader< ::backup::PullCompactionResponse>>(PullCompactionRaw(context, request));
+    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> PrepareAsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(PrepareAsyncRecoverBackupKeyRaw(context, cq));
     }
-    std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>> AsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
-      return std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>>(AsyncPullCompactionRaw(context, request, cq, tag));
+    std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PullBackup(::grpc::ClientContext* context) {
+      return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PullBackupRaw(context));
     }
-    std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>> PrepareAsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) {
-      return std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>>(PrepareAsyncPullCompactionRaw(context, request, cq));
+    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> AsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(AsyncPullBackupRaw(context, cq, tag));
+    }
+    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PrepareAsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PrepareAsyncPullBackupRaw(context, cq));
     }
     class async final :
       public StubInterface::async_interface {
      public:
-      void ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) override;
-      void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) override;
-      void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override;
-      void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function<void(::grpc::Status)>) override;
-      void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
-      void PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) override;
+      void CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) override;
+      void SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) override;
+      void RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) override;
+      void PullBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupRequest,::backup::PullBackupResponse>* reactor) override;
      private:
       friend class Stub;
       explicit async(Stub* stub): stub_(stub) { }
@@ -147,20 +153,22 @@
    private:
     std::shared_ptr< ::grpc::ChannelInterface> channel_;
     class async async_stub_{this};
-    ::grpc::ClientWriter< ::backup::ResetKeyRequest>* ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) override;
-    ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) override;
-    ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) override;
-    ::grpc::ClientReader< ::backup::PullCompactionResponse>* PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) override;
-    ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) override;
-    ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) override;
-    const ::grpc::internal::RpcMethod rpcmethod_ResetKey_;
+    ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackupRaw(::grpc::ClientContext* context) override;
+    ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
+    ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientWriter< ::backup::SendLogRequest>* SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) override;
+    ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) override;
+    ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* RecoverBackupKeyRaw(::grpc::ClientContext* context) override;
+    ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* AsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
+    ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* PrepareAsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PullBackupRaw(::grpc::ClientContext* context) override;
+    ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* AsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
+    ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
+    const ::grpc::internal::RpcMethod rpcmethod_CreateNewBackup_;
     const ::grpc::internal::RpcMethod rpcmethod_SendLog_;
-    const ::grpc::internal::RpcMethod rpcmethod_PullBackupKey_;
-    const ::grpc::internal::RpcMethod rpcmethod_PullCompaction_;
+    const ::grpc::internal::RpcMethod rpcmethod_RecoverBackupKey_;
+    const ::grpc::internal::RpcMethod rpcmethod_PullBackup_;
   };
   static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
 
@@ -168,29 +176,29 @@
    public:
     Service();
     virtual ~Service();
-    virtual ::grpc::Status ResetKey(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::ResetKeyRequest>* reader, ::google::protobuf::Empty* response);
-    virtual ::grpc::Status SendLog(::grpc::ServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response);
-    virtual ::grpc::Status PullBackupKey(::grpc::ServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response);
-    virtual ::grpc::Status PullCompaction(::grpc::ServerContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* writer);
+    virtual ::grpc::Status CreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream);
+    virtual ::grpc::Status SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::google::protobuf::Empty* response);
+    virtual ::grpc::Status RecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* stream);
+    virtual ::grpc::Status PullBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* stream);
   };
   template <class BaseClass>
-  class WithAsyncMethod_ResetKey : public BaseClass {
+  class WithAsyncMethod_CreateNewBackup : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithAsyncMethod_ResetKey() {
+    WithAsyncMethod_CreateNewBackup() {
       ::grpc::Service::MarkMethodAsync(0);
     }
-    ~WithAsyncMethod_ResetKey() override {
+    ~WithAsyncMethod_CreateNewBackup() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
+    ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestResetKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::google::protobuf::Empty, ::backup::ResetKeyRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncClientStreaming(0, context, reader, new_call_cq, notification_cq, tag);
+    void RequestCreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
@@ -205,76 +213,77 @@
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestSendLog(::grpc::ServerContext* context, ::backup::SendLogRequest* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    void RequestSendLog(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::google::protobuf::Empty, ::backup::SendLogRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
-  class WithAsyncMethod_PullBackupKey : public BaseClass {
+  class WithAsyncMethod_RecoverBackupKey : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithAsyncMethod_PullBackupKey() {
+    WithAsyncMethod_RecoverBackupKey() {
       ::grpc::Service::MarkMethodAsync(2);
     }
-    ~WithAsyncMethod_PullBackupKey() override {
+    ~WithAsyncMethod_RecoverBackupKey() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
+    ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestPullBackupKey(::grpc::ServerContext* context, ::backup::PullBackupKeyRequest* request, ::grpc::ServerAsyncResponseWriter< ::backup::PullBackupKeyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+    void RequestRecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(2, context, stream, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
-  class WithAsyncMethod_PullCompaction : public BaseClass {
+  class WithAsyncMethod_PullBackup : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithAsyncMethod_PullCompaction() {
+    WithAsyncMethod_PullBackup() {
       ::grpc::Service::MarkMethodAsync(3);
     }
-    ~WithAsyncMethod_PullCompaction() override {
+    ~WithAsyncMethod_PullBackup() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
+    ::grpc::Status PullBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestPullCompaction(::grpc::ServerContext* context, ::backup::PullCompactionRequest* request, ::grpc::ServerAsyncWriter< ::backup::PullCompactionResponse>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag);
+    void RequestPullBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag);
     }
   };
-  typedef WithAsyncMethod_ResetKey<WithAsyncMethod_SendLog<WithAsyncMethod_PullBackupKey<WithAsyncMethod_PullCompaction<Service > > > > AsyncService;
+  typedef WithAsyncMethod_CreateNewBackup<WithAsyncMethod_SendLog<WithAsyncMethod_RecoverBackupKey<WithAsyncMethod_PullBackup<Service > > > > AsyncService;
   template <class BaseClass>
-  class WithCallbackMethod_ResetKey : public BaseClass {
+  class WithCallbackMethod_CreateNewBackup : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithCallbackMethod_ResetKey() {
+    WithCallbackMethod_CreateNewBackup() {
       ::grpc::Service::MarkMethodCallback(0,
-          new ::grpc::internal::CallbackClientStreamingHandler< ::backup::ResetKeyRequest, ::google::protobuf::Empty>(
+          new ::grpc::internal::CallbackBidiHandler< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>(
             [this](
-                   ::grpc::CallbackServerContext* context, ::google::protobuf::Empty* response) { return this->ResetKey(context, response); }));
+                   ::grpc::CallbackServerContext* context) { return this->CreateNewBackup(context); }));
     }
-    ~WithCallbackMethod_ResetKey() override {
+    ~WithCallbackMethod_CreateNewBackup() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
+    ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual ::grpc::ServerReadReactor< ::backup::ResetKeyRequest>* ResetKey(
-      ::grpc::CallbackServerContext* /*context*/, ::google::protobuf::Empty* /*response*/)  { return nullptr; }
+    virtual ::grpc::ServerBidiReactor< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackup(
+      ::grpc::CallbackServerContext* /*context*/)
+      { return nullptr; }
   };
   template <class BaseClass>
   class WithCallbackMethod_SendLog : public BaseClass {
@@ -283,90 +292,82 @@
    public:
     WithCallbackMethod_SendLog() {
       ::grpc::Service::MarkMethodCallback(1,
-          new ::grpc::internal::CallbackUnaryHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>(
+          new ::grpc::internal::CallbackClientStreamingHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>(
             [this](
-                   ::grpc::CallbackServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response) { return this->SendLog(context, request, response); }));}
-    void SetMessageAllocatorFor_SendLog(
-        ::grpc::MessageAllocator< ::backup::SendLogRequest, ::google::protobuf::Empty>* allocator) {
-      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
-      static_cast<::grpc::internal::CallbackUnaryHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>*>(handler)
-              ->SetMessageAllocator(allocator);
+                   ::grpc::CallbackServerContext* context, ::google::protobuf::Empty* response) { return this->SendLog(context, response); }));
     }
     ~WithCallbackMethod_SendLog() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual ::grpc::ServerUnaryReactor* SendLog(
-      ::grpc::CallbackServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/)  { return nullptr; }
+    virtual ::grpc::ServerReadReactor< ::backup::SendLogRequest>* SendLog(
+      ::grpc::CallbackServerContext* /*context*/, ::google::protobuf::Empty* /*response*/)  { return nullptr; }
   };
   template <class BaseClass>
-  class WithCallbackMethod_PullBackupKey : public BaseClass {
+  class WithCallbackMethod_RecoverBackupKey : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithCallbackMethod_PullBackupKey() {
+    WithCallbackMethod_RecoverBackupKey() {
       ::grpc::Service::MarkMethodCallback(2,
-          new ::grpc::internal::CallbackUnaryHandler< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>(
+          new ::grpc::internal::CallbackBidiHandler< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>(
             [this](
-                   ::grpc::CallbackServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response) { return this->PullBackupKey(context, request, response); }));}
-    void SetMessageAllocatorFor_PullBackupKey(
-        ::grpc::MessageAllocator< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* allocator) {
-      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
-      static_cast<::grpc::internal::CallbackUnaryHandler< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>*>(handler)
-              ->SetMessageAllocator(allocator);
-    }
-    ~WithCallbackMethod_PullBackupKey() override {
+                   ::grpc::CallbackServerContext* context) { return this->RecoverBackupKey(context); }));
+    }
+    ~WithCallbackMethod_RecoverBackupKey() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
+    ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual ::grpc::ServerUnaryReactor* PullBackupKey(
-      ::grpc::CallbackServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/)  { return nullptr; }
+    virtual ::grpc::ServerBidiReactor< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* RecoverBackupKey(
+      ::grpc::CallbackServerContext* /*context*/)
+      { return nullptr; }
   };
   template <class BaseClass>
-  class WithCallbackMethod_PullCompaction : public BaseClass {
+  class WithCallbackMethod_PullBackup : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithCallbackMethod_PullCompaction() {
+    WithCallbackMethod_PullBackup() {
       ::grpc::Service::MarkMethodCallback(3,
-          new ::grpc::internal::CallbackServerStreamingHandler< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>(
+          new ::grpc::internal::CallbackBidiHandler< ::backup::PullBackupRequest, ::backup::PullBackupResponse>(
             [this](
-                   ::grpc::CallbackServerContext* context, const ::backup::PullCompactionRequest* request) { return this->PullCompaction(context, request); }));
+                   ::grpc::CallbackServerContext* context) { return this->PullBackup(context); }));
     }
-    ~WithCallbackMethod_PullCompaction() override {
+    ~WithCallbackMethod_PullBackup() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
+    ::grpc::Status PullBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual ::grpc::ServerWriteReactor< ::backup::PullCompactionResponse>* PullCompaction(
-      ::grpc::CallbackServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/)  { return nullptr; }
+    virtual ::grpc::ServerBidiReactor< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PullBackup(
+      ::grpc::CallbackServerContext* /*context*/)
+      { return nullptr; }
   };
-  typedef WithCallbackMethod_ResetKey<WithCallbackMethod_SendLog<WithCallbackMethod_PullBackupKey<WithCallbackMethod_PullCompaction<Service > > > > CallbackService;
+  typedef WithCallbackMethod_CreateNewBackup<WithCallbackMethod_SendLog<WithCallbackMethod_RecoverBackupKey<WithCallbackMethod_PullBackup<Service > > > > CallbackService;
   typedef CallbackService ExperimentalCallbackService;
   template <class BaseClass>
-  class WithGenericMethod_ResetKey : public BaseClass {
+  class WithGenericMethod_CreateNewBackup : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithGenericMethod_ResetKey() {
+    WithGenericMethod_CreateNewBackup() {
       ::grpc::Service::MarkMethodGeneric(0);
     }
-    ~WithGenericMethod_ResetKey() override {
+    ~WithGenericMethod_CreateNewBackup() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
+    ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
@@ -383,63 +384,63 @@
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
   };
   template <class BaseClass>
-  class WithGenericMethod_PullBackupKey : public BaseClass {
+  class WithGenericMethod_RecoverBackupKey : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithGenericMethod_PullBackupKey() {
+    WithGenericMethod_RecoverBackupKey() {
       ::grpc::Service::MarkMethodGeneric(2);
     }
-    ~WithGenericMethod_PullBackupKey() override {
+    ~WithGenericMethod_RecoverBackupKey() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
+    ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
   };
   template <class BaseClass>
-  class WithGenericMethod_PullCompaction : public BaseClass {
+  class WithGenericMethod_PullBackup : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithGenericMethod_PullCompaction() {
+    WithGenericMethod_PullBackup() {
       ::grpc::Service::MarkMethodGeneric(3);
     }
-    ~WithGenericMethod_PullCompaction() override {
+    ~WithGenericMethod_PullBackup() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
+    ::grpc::Status PullBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
   };
   template <class BaseClass>
-  class WithRawMethod_ResetKey : public BaseClass {
+  class WithRawMethod_CreateNewBackup : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithRawMethod_ResetKey() {
+    WithRawMethod_CreateNewBackup() {
       ::grpc::Service::MarkMethodRaw(0);
     }
-    ~WithRawMethod_ResetKey() override {
+    ~WithRawMethod_CreateNewBackup() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
+    ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestResetKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncClientStreaming(0, context, reader, new_call_cq, notification_cq, tag);
+    void RequestCreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
@@ -454,75 +455,76 @@
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestSendLog(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    void RequestSendLog(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
-  class WithRawMethod_PullBackupKey : public BaseClass {
+  class WithRawMethod_RecoverBackupKey : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithRawMethod_PullBackupKey() {
+    WithRawMethod_RecoverBackupKey() {
       ::grpc::Service::MarkMethodRaw(2);
     }
-    ~WithRawMethod_PullBackupKey() override {
+    ~WithRawMethod_RecoverBackupKey() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
+    ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestPullBackupKey(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+    void RequestRecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(2, context, stream, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
-  class WithRawMethod_PullCompaction : public BaseClass {
+  class WithRawMethod_PullBackup : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithRawMethod_PullCompaction() {
+    WithRawMethod_PullBackup() {
       ::grpc::Service::MarkMethodRaw(3);
     }
-    ~WithRawMethod_PullCompaction() override {
+    ~WithRawMethod_PullBackup() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
+    ::grpc::Status PullBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    void RequestPullCompaction(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
-      ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag);
+    void RequestPullBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag);
     }
   };
   template <class BaseClass>
-  class WithRawCallbackMethod_ResetKey : public BaseClass {
+  class WithRawCallbackMethod_CreateNewBackup : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithRawCallbackMethod_ResetKey() {
+    WithRawCallbackMethod_CreateNewBackup() {
       ::grpc::Service::MarkMethodRawCallback(0,
-          new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
             [this](
-                   ::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->ResetKey(context, response); }));
+                   ::grpc::CallbackServerContext* context) { return this->CreateNewBackup(context); }));
     }
-    ~WithRawCallbackMethod_ResetKey() override {
+    ~WithRawCallbackMethod_CreateNewBackup() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
+    ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* ResetKey(
-      ::grpc::CallbackServerContext* /*context*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
+    virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* CreateNewBackup(
+      ::grpc::CallbackServerContext* /*context*/)
+      { return nullptr; }
   };
   template <class BaseClass>
   class WithRawCallbackMethod_SendLog : public BaseClass {
@@ -531,149 +533,70 @@
    public:
     WithRawCallbackMethod_SendLog() {
       ::grpc::Service::MarkMethodRawCallback(1,
-          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
             [this](
-                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendLog(context, request, response); }));
+                   ::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->SendLog(context, response); }));
     }
     ~WithRawCallbackMethod_SendLog() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual ::grpc::ServerUnaryReactor* SendLog(
-      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
+    virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* SendLog(
+      ::grpc::CallbackServerContext* /*context*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
   };
   template <class BaseClass>
-  class WithRawCallbackMethod_PullBackupKey : public BaseClass {
+  class WithRawCallbackMethod_RecoverBackupKey : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithRawCallbackMethod_PullBackupKey() {
+    WithRawCallbackMethod_RecoverBackupKey() {
       ::grpc::Service::MarkMethodRawCallback(2,
-          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
             [this](
-                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PullBackupKey(context, request, response); }));
+                   ::grpc::CallbackServerContext* context) { return this->RecoverBackupKey(context); }));
     }
-    ~WithRawCallbackMethod_PullBackupKey() override {
+    ~WithRawCallbackMethod_RecoverBackupKey() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
+    ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    virtual ::grpc::ServerUnaryReactor* PullBackupKey(
-      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
+    virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* RecoverBackupKey(
+      ::grpc::CallbackServerContext* /*context*/)
+      { return nullptr; }
   };
   template <class BaseClass>
-  class WithRawCallbackMethod_PullCompaction : public BaseClass {
+  class WithRawCallbackMethod_PullBackup : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
    public:
-    WithRawCallbackMethod_PullCompaction() {
+    WithRawCallbackMethod_PullBackup() {
       ::grpc::Service::MarkMethodRawCallback(3,
-          new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
             [this](
-                   ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->PullCompaction(context, request); }));
+                   ::grpc::CallbackServerContext* context) { return this->PullBackup(context); }));
     }
-    ~WithRawCallbackMethod_PullCompaction() override {
+    ~WithRawCallbackMethod_PullBackup() override {
       BaseClassMustBeDerivedFromService(this);
     }
     // disable synchronous version of this method
-    ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
-      abort();
-      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
-    }
-    virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* PullCompaction(
-      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/)  { return nullptr; }
-  };
-  template <class BaseClass>
-  class WithStreamedUnaryMethod_SendLog : public BaseClass {
-   private:
-    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
-   public:
-    WithStreamedUnaryMethod_SendLog() {
-      ::grpc::Service::MarkMethodStreamed(1,
-        new ::grpc::internal::StreamedUnaryHandler<
-          ::backup::SendLogRequest, ::google::protobuf::Empty>(
-            [this](::grpc::ServerContext* context,
-                   ::grpc::ServerUnaryStreamer<
-                     ::backup::SendLogRequest, ::google::protobuf::Empty>* streamer) {
-                       return this->StreamedSendLog(context,
-                         streamer);
-                  }));
-    }
-    ~WithStreamedUnaryMethod_SendLog() override {
-      BaseClassMustBeDerivedFromService(this);
-    }
-    // disable regular version of this method
-    ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
-      abort();
-      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
-    }
-    // replace default version of method with streamed unary
-    virtual ::grpc::Status StreamedSendLog(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::backup::SendLogRequest,::google::protobuf::Empty>* server_unary_streamer) = 0;
-  };
-  template <class BaseClass>
-  class WithStreamedUnaryMethod_PullBackupKey : public BaseClass {
-   private:
-    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
-   public:
-    WithStreamedUnaryMethod_PullBackupKey() {
-      ::grpc::Service::MarkMethodStreamed(2,
-        new ::grpc::internal::StreamedUnaryHandler<
-          ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>(
-            [this](::grpc::ServerContext* context,
-                   ::grpc::ServerUnaryStreamer<
-                     ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* streamer) {
-                       return this->StreamedPullBackupKey(context,
-                         streamer);
-                  }));
-    }
-    ~WithStreamedUnaryMethod_PullBackupKey() override {
-      BaseClassMustBeDerivedFromService(this);
-    }
-    // disable regular version of this method
-    ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
-      abort();
-      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
-    }
-    // replace default version of method with streamed unary
-    virtual ::grpc::Status StreamedPullBackupKey(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::backup::PullBackupKeyRequest,::backup::PullBackupKeyResponse>* server_unary_streamer) = 0;
-  };
-  typedef WithStreamedUnaryMethod_SendLog<WithStreamedUnaryMethod_PullBackupKey<Service > > StreamedUnaryService;
-  template <class BaseClass>
-  class WithSplitStreamingMethod_PullCompaction : public BaseClass {
-   private:
-    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
-   public:
-    WithSplitStreamingMethod_PullCompaction() {
-      ::grpc::Service::MarkMethodStreamed(3,
-        new ::grpc::internal::SplitServerStreamingHandler<
-          ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>(
-            [this](::grpc::ServerContext* context,
-                   ::grpc::ServerSplitStreamer<
-                     ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* streamer) {
-                       return this->StreamedPullCompaction(context,
-                         streamer);
-                  }));
-    }
-    ~WithSplitStreamingMethod_PullCompaction() override {
-      BaseClassMustBeDerivedFromService(this);
-    }
-    // disable regular version of this method
-    ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
+    ::grpc::Status PullBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /*stream*/)  override {
       abort();
       return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
-    // replace default version of method with split streamed
-    virtual ::grpc::Status StreamedPullCompaction(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::backup::PullCompactionRequest,::backup::PullCompactionResponse>* server_split_streamer) = 0;
+    virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* PullBackup(
+      ::grpc::CallbackServerContext* /*context*/)
+      { return nullptr; }
   };
-  typedef WithSplitStreamingMethod_PullCompaction<Service > SplitStreamedService;
-  typedef WithStreamedUnaryMethod_SendLog<WithStreamedUnaryMethod_PullBackupKey<WithSplitStreamingMethod_PullCompaction<Service > > > StreamedService;
+  typedef Service StreamedUnaryService;
+  typedef Service SplitStreamedService;
+  typedef Service StreamedService;
 };
 
 }  // namespace backup
diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
--- a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
+++ b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
@@ -22,10 +22,10 @@
 namespace backup {
 
 static const char* BackupService_method_names[] = {
-  "/backup.BackupService/ResetKey",
+  "/backup.BackupService/CreateNewBackup",
   "/backup.BackupService/SendLog",
-  "/backup.BackupService/PullBackupKey",
-  "/backup.BackupService/PullCompaction",
+  "/backup.BackupService/RecoverBackupKey",
+  "/backup.BackupService/PullBackup",
 };
 
 std::unique_ptr< BackupService::Stub> BackupService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
@@ -35,161 +35,144 @@
 }
 
 BackupService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
-  : channel_(channel), rpcmethod_ResetKey_(BackupService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel)
-  , rpcmethod_SendLog_(BackupService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
-  , rpcmethod_PullBackupKey_(BackupService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
-  , rpcmethod_PullCompaction_(BackupService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
+  : channel_(channel), rpcmethod_CreateNewBackup_(BackupService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
+  , rpcmethod_SendLog_(BackupService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel)
+  , rpcmethod_RecoverBackupKey_(BackupService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
+  , rpcmethod_PullBackup_(BackupService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
   {}
 
-::grpc::ClientWriter< ::backup::ResetKeyRequest>* BackupService::Stub::ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
-  return ::grpc::internal::ClientWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), rpcmethod_ResetKey_, context, response);
+::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::CreateNewBackupRaw(::grpc::ClientContext* context) {
+  return ::grpc::internal::ClientReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), rpcmethod_CreateNewBackup_, context);
 }
 
-void BackupService::Stub::async::ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) {
-  ::grpc::internal::ClientCallbackWriterFactory< ::backup::ResetKeyRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_ResetKey_, context, response, reactor);
+void BackupService::Stub::async::CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) {
+  ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_CreateNewBackup_, context, reactor);
 }
 
-::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* BackupService::Stub::AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
-  return ::grpc::internal::ClientAsyncWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), cq, rpcmethod_ResetKey_, context, response, true, tag);
+::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), cq, rpcmethod_CreateNewBackup_, context, true, tag);
 }
 
-::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* BackupService::Stub::PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
-  return ::grpc::internal::ClientAsyncWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), cq, rpcmethod_ResetKey_, context, response, false, nullptr);
+::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), cq, rpcmethod_CreateNewBackup_, context, false, nullptr);
 }
 
-::grpc::Status BackupService::Stub::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) {
-  return ::grpc::internal::BlockingUnaryCall< ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SendLog_, context, request, response);
+::grpc::ClientWriter< ::backup::SendLogRequest>* BackupService::Stub::SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
+  return ::grpc::internal::ClientWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), rpcmethod_SendLog_, context, response);
 }
 
-void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
-  ::grpc::internal::CallbackUnaryCall< ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, request, response, std::move(f));
+void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) {
+  ::grpc::internal::ClientCallbackWriterFactory< ::backup::SendLogRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, response, reactor);
 }
 
-void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
-  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, request, response, reactor);
+::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
+  return ::grpc::internal::ClientAsyncWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), cq, rpcmethod_SendLog_, context, response, true, tag);
 }
 
-::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* BackupService::Stub::PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::backup::SendLogRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SendLog_, context, request);
+::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), cq, rpcmethod_SendLog_, context, response, false, nullptr);
 }
 
-::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* BackupService::Stub::AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
-  auto* result =
-    this->PrepareAsyncSendLogRaw(context, request, cq);
-  result->StartCall();
-  return result;
+::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* BackupService::Stub::RecoverBackupKeyRaw(::grpc::ClientContext* context) {
+  return ::grpc::internal::ClientReaderWriterFactory< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>::Create(channel_.get(), rpcmethod_RecoverBackupKey_, context);
 }
 
-::grpc::Status BackupService::Stub::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) {
-  return ::grpc::internal::BlockingUnaryCall< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PullBackupKey_, context, request, response);
+void BackupService::Stub::async::RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) {
+  ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_RecoverBackupKey_, context, reactor);
 }
 
-void BackupService::Stub::async::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function<void(::grpc::Status)> f) {
-  ::grpc::internal::CallbackUnaryCall< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PullBackupKey_, context, request, response, std::move(f));
+::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* BackupService::Stub::AsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>::Create(channel_.get(), cq, rpcmethod_RecoverBackupKey_, context, true, tag);
 }
 
-void BackupService::Stub::async::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) {
-  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PullBackupKey_, context, request, response, reactor);
+::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* BackupService::Stub::PrepareAsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>::Create(channel_.get(), cq, rpcmethod_RecoverBackupKey_, context, false, nullptr);
 }
 
-::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* BackupService::Stub::PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PullBackupKey_, context, request);
+::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* BackupService::Stub::PullBackupRaw(::grpc::ClientContext* context) {
+  return ::grpc::internal::ClientReaderWriterFactory< ::backup::PullBackupRequest, ::backup::PullBackupResponse>::Create(channel_.get(), rpcmethod_PullBackup_, context);
 }
 
-::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* BackupService::Stub::AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
-  auto* result =
-    this->PrepareAsyncPullBackupKeyRaw(context, request, cq);
-  result->StartCall();
-  return result;
+void BackupService::Stub::async::PullBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupRequest,::backup::PullBackupResponse>* reactor) {
+  ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::PullBackupRequest,::backup::PullBackupResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_PullBackup_, context, reactor);
 }
 
-::grpc::ClientReader< ::backup::PullCompactionResponse>* BackupService::Stub::PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) {
-  return ::grpc::internal::ClientReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), rpcmethod_PullCompaction_, context, request);
+::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* BackupService::Stub::AsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::PullBackupRequest, ::backup::PullBackupResponse>::Create(channel_.get(), cq, rpcmethod_PullBackup_, context, true, tag);
 }
 
-void BackupService::Stub::async::PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) {
-  ::grpc::internal::ClientCallbackReaderFactory< ::backup::PullCompactionResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_PullCompaction_, context, request, reactor);
-}
-
-::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* BackupService::Stub::AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
-  return ::grpc::internal::ClientAsyncReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), cq, rpcmethod_PullCompaction_, context, request, true, tag);
-}
-
-::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* BackupService::Stub::PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc::internal::ClientAsyncReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), cq, rpcmethod_PullCompaction_, context, request, false, nullptr);
+::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* BackupService::Stub::PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::PullBackupRequest, ::backup::PullBackupResponse>::Create(channel_.get(), cq, rpcmethod_PullBackup_, context, false, nullptr);
 }
 
 BackupService::Service::Service() {
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       BackupService_method_names[0],
-      ::grpc::internal::RpcMethod::CLIENT_STREAMING,
-      new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::ResetKeyRequest, ::google::protobuf::Empty>(
+      ::grpc::internal::RpcMethod::BIDI_STREAMING,
+      new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>(
           [](BackupService::Service* service,
              ::grpc::ServerContext* ctx,
-             ::grpc::ServerReader<::backup::ResetKeyRequest>* reader,
-             ::google::protobuf::Empty* resp) {
-               return service->ResetKey(ctx, reader, resp);
+             ::grpc::ServerReaderWriter<::backup::CreateNewBackupResponse,
+             ::backup::CreateNewBackupRequest>* stream) {
+               return service->CreateNewBackup(ctx, stream);
              }, this)));
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       BackupService_method_names[1],
-      ::grpc::internal::RpcMethod::NORMAL_RPC,
-      new ::grpc::internal::RpcMethodHandler< BackupService::Service, ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+      ::grpc::internal::RpcMethod::CLIENT_STREAMING,
+      new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::SendLogRequest, ::google::protobuf::Empty>(
           [](BackupService::Service* service,
              ::grpc::ServerContext* ctx,
-             const ::backup::SendLogRequest* req,
+             ::grpc::ServerReader<::backup::SendLogRequest>* reader,
              ::google::protobuf::Empty* resp) {
-               return service->SendLog(ctx, req, resp);
+               return service->SendLog(ctx, reader, resp);
              }, this)));
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       BackupService_method_names[2],
-      ::grpc::internal::RpcMethod::NORMAL_RPC,
-      new ::grpc::internal::RpcMethodHandler< BackupService::Service, ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+      ::grpc::internal::RpcMethod::BIDI_STREAMING,
+      new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>(
           [](BackupService::Service* service,
              ::grpc::ServerContext* ctx,
-             const ::backup::PullBackupKeyRequest* req,
-             ::backup::PullBackupKeyResponse* resp) {
-               return service->PullBackupKey(ctx, req, resp);
+             ::grpc::ServerReaderWriter<::backup::RecoverBackupKeyResponse,
+             ::backup::RecoverBackupKeyRequest>* stream) {
+               return service->RecoverBackupKey(ctx, stream);
              }, this)));
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       BackupService_method_names[3],
-      ::grpc::internal::RpcMethod::SERVER_STREAMING,
-      new ::grpc::internal::ServerStreamingHandler< BackupService::Service, ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>(
+      ::grpc::internal::RpcMethod::BIDI_STREAMING,
+      new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::PullBackupRequest, ::backup::PullBackupResponse>(
           [](BackupService::Service* service,
              ::grpc::ServerContext* ctx,
-             const ::backup::PullCompactionRequest* req,
-             ::grpc::ServerWriter<::backup::PullCompactionResponse>* writer) {
-               return service->PullCompaction(ctx, req, writer);
+             ::grpc::ServerReaderWriter<::backup::PullBackupResponse,
+             ::backup::PullBackupRequest>* stream) {
+               return service->PullBackup(ctx, stream);
              }, this)));
 }
 
 BackupService::Service::~Service() {
 }
 
-::grpc::Status BackupService::Service::ResetKey(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::ResetKeyRequest>* reader, ::google::protobuf::Empty* response) {
+::grpc::Status BackupService::Service::CreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream) {
   (void) context;
-  (void) reader;
-  (void) response;
+  (void) stream;
   return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
 }
 
-::grpc::Status BackupService::Service::SendLog(::grpc::ServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response) {
+::grpc::Status BackupService::Service::SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::google::protobuf::Empty* response) {
   (void) context;
-  (void) request;
+  (void) reader;
   (void) response;
   return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
 }
 
-::grpc::Status BackupService::Service::PullBackupKey(::grpc::ServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response) {
+::grpc::Status BackupService::Service::RecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* stream) {
   (void) context;
-  (void) request;
-  (void) response;
+  (void) stream;
   return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
 }
 
-::grpc::Status BackupService::Service::PullCompaction(::grpc::ServerContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* writer) {
+::grpc::Status BackupService::Service::PullBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* stream) {
   (void) context;
-  (void) request;
-  (void) writer;
+  (void) stream;
   return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
 }
 
diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.h b/native/cpp/CommonCpp/grpc/_generated/backup.pb.h
--- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.h
+++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.h
@@ -47,7 +47,7 @@
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[11]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
   static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -56,55 +56,75 @@
 extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_backup_2eproto;
 ::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_backup_2eproto_metadata_getter(int index);
 namespace backup {
-class PullBackupKeyRequest;
-struct PullBackupKeyRequestDefaultTypeInternal;
-extern PullBackupKeyRequestDefaultTypeInternal _PullBackupKeyRequest_default_instance_;
-class PullBackupKeyResponse;
-struct PullBackupKeyResponseDefaultTypeInternal;
-extern PullBackupKeyResponseDefaultTypeInternal _PullBackupKeyResponse_default_instance_;
-class PullCompactionRequest;
-struct PullCompactionRequestDefaultTypeInternal;
-extern PullCompactionRequestDefaultTypeInternal _PullCompactionRequest_default_instance_;
-class PullCompactionResponse;
-struct PullCompactionResponseDefaultTypeInternal;
-extern PullCompactionResponseDefaultTypeInternal _PullCompactionResponse_default_instance_;
-class ResetKeyRequest;
-struct ResetKeyRequestDefaultTypeInternal;
-extern ResetKeyRequestDefaultTypeInternal _ResetKeyRequest_default_instance_;
+class AuthenticationInformationData;
+struct AuthenticationInformationDataDefaultTypeInternal;
+extern AuthenticationInformationDataDefaultTypeInternal _AuthenticationInformationData_default_instance_;
+class CreateNewBackupRequest;
+struct CreateNewBackupRequestDefaultTypeInternal;
+extern CreateNewBackupRequestDefaultTypeInternal _CreateNewBackupRequest_default_instance_;
+class CreateNewBackupResponse;
+struct CreateNewBackupResponseDefaultTypeInternal;
+extern CreateNewBackupResponseDefaultTypeInternal _CreateNewBackupResponse_default_instance_;
+class FullAuthenticationRequestData;
+struct FullAuthenticationRequestDataDefaultTypeInternal;
+extern FullAuthenticationRequestDataDefaultTypeInternal _FullAuthenticationRequestData_default_instance_;
+class FullAuthenticationResponseData;
+struct FullAuthenticationResponseDataDefaultTypeInternal;
+extern FullAuthenticationResponseDataDefaultTypeInternal _FullAuthenticationResponseData_default_instance_;
+class PullBackupRequest;
+struct PullBackupRequestDefaultTypeInternal;
+extern PullBackupRequestDefaultTypeInternal _PullBackupRequest_default_instance_;
+class PullBackupResponse;
+struct PullBackupResponseDefaultTypeInternal;
+extern PullBackupResponseDefaultTypeInternal _PullBackupResponse_default_instance_;
+class RecoverBackupKeyRequest;
+struct RecoverBackupKeyRequestDefaultTypeInternal;
+extern RecoverBackupKeyRequestDefaultTypeInternal _RecoverBackupKeyRequest_default_instance_;
+class RecoverBackupKeyResponse;
+struct RecoverBackupKeyResponseDefaultTypeInternal;
+extern RecoverBackupKeyResponseDefaultTypeInternal _RecoverBackupKeyResponse_default_instance_;
 class SendLogRequest;
 struct SendLogRequestDefaultTypeInternal;
 extern SendLogRequestDefaultTypeInternal _SendLogRequest_default_instance_;
+class SimpleAuthenticationRequestData;
+struct SimpleAuthenticationRequestDataDefaultTypeInternal;
+extern SimpleAuthenticationRequestDataDefaultTypeInternal _SimpleAuthenticationRequestData_default_instance_;
 }  // namespace backup
 PROTOBUF_NAMESPACE_OPEN
-template<> ::backup::PullBackupKeyRequest* Arena::CreateMaybeMessage<::backup::PullBackupKeyRequest>(Arena*);
-template<> ::backup::PullBackupKeyResponse* Arena::CreateMaybeMessage<::backup::PullBackupKeyResponse>(Arena*);
-template<> ::backup::PullCompactionRequest* Arena::CreateMaybeMessage<::backup::PullCompactionRequest>(Arena*);
-template<> ::backup::PullCompactionResponse* Arena::CreateMaybeMessage<::backup::PullCompactionResponse>(Arena*);
-template<> ::backup::ResetKeyRequest* Arena::CreateMaybeMessage<::backup::ResetKeyRequest>(Arena*);
+template<> ::backup::AuthenticationInformationData* Arena::CreateMaybeMessage<::backup::AuthenticationInformationData>(Arena*);
+template<> ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage<::backup::CreateNewBackupRequest>(Arena*);
+template<> ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage<::backup::CreateNewBackupResponse>(Arena*);
+template<> ::backup::FullAuthenticationRequestData* Arena::CreateMaybeMessage<::backup::FullAuthenticationRequestData>(Arena*);
+template<> ::backup::FullAuthenticationResponseData* Arena::CreateMaybeMessage<::backup::FullAuthenticationResponseData>(Arena*);
+template<> ::backup::PullBackupRequest* Arena::CreateMaybeMessage<::backup::PullBackupRequest>(Arena*);
+template<> ::backup::PullBackupResponse* Arena::CreateMaybeMessage<::backup::PullBackupResponse>(Arena*);
+template<> ::backup::RecoverBackupKeyRequest* Arena::CreateMaybeMessage<::backup::RecoverBackupKeyRequest>(Arena*);
+template<> ::backup::RecoverBackupKeyResponse* Arena::CreateMaybeMessage<::backup::RecoverBackupKeyResponse>(Arena*);
 template<> ::backup::SendLogRequest* Arena::CreateMaybeMessage<::backup::SendLogRequest>(Arena*);
+template<> ::backup::SimpleAuthenticationRequestData* Arena::CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 namespace backup {
 
 // ===================================================================
 
-class ResetKeyRequest PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.ResetKeyRequest) */ {
+class FullAuthenticationRequestData PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.FullAuthenticationRequestData) */ {
  public:
-  inline ResetKeyRequest() : ResetKeyRequest(nullptr) {}
-  virtual ~ResetKeyRequest();
-  explicit constexpr ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline FullAuthenticationRequestData() : FullAuthenticationRequestData(nullptr) {}
+  virtual ~FullAuthenticationRequestData();
+  explicit constexpr FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  ResetKeyRequest(const ResetKeyRequest& from);
-  ResetKeyRequest(ResetKeyRequest&& from) noexcept
-    : ResetKeyRequest() {
+  FullAuthenticationRequestData(const FullAuthenticationRequestData& from);
+  FullAuthenticationRequestData(FullAuthenticationRequestData&& from) noexcept
+    : FullAuthenticationRequestData() {
     *this = ::std::move(from);
   }
 
-  inline ResetKeyRequest& operator=(const ResetKeyRequest& from) {
+  inline FullAuthenticationRequestData& operator=(const FullAuthenticationRequestData& from) {
     CopyFrom(from);
     return *this;
   }
-  inline ResetKeyRequest& operator=(ResetKeyRequest&& from) noexcept {
+  inline FullAuthenticationRequestData& operator=(FullAuthenticationRequestData&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -122,26 +142,30 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const ResetKeyRequest& default_instance() {
+  static const FullAuthenticationRequestData& default_instance() {
     return *internal_default_instance();
   }
-  enum DataCase {
-    kNewKey = 2,
-    kCompactionChunk = 3,
-    DATA_NOT_SET = 0,
+  enum RequestBytesCase {
+    kPakeRegistrationRequest = 1,
+    kPakeRegistrationUpload = 2,
+    kPakeCredentialRequest = 3,
+    kPakeCredentialFinalization = 4,
+    kPakeChallengeResponse = 5,
+    kWalletAuthenticationRequest = 6,
+    REQUESTBYTES_NOT_SET = 0,
   };
 
-  static inline const ResetKeyRequest* internal_default_instance() {
-    return reinterpret_cast<const ResetKeyRequest*>(
-               &_ResetKeyRequest_default_instance_);
+  static inline const FullAuthenticationRequestData* internal_default_instance() {
+    return reinterpret_cast<const FullAuthenticationRequestData*>(
+               &_FullAuthenticationRequestData_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     0;
 
-  friend void swap(ResetKeyRequest& a, ResetKeyRequest& b) {
+  friend void swap(FullAuthenticationRequestData& a, FullAuthenticationRequestData& b) {
     a.Swap(&b);
   }
-  inline void Swap(ResetKeyRequest* other) {
+  inline void Swap(FullAuthenticationRequestData* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -149,7 +173,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(ResetKeyRequest* other) {
+  void UnsafeArenaSwap(FullAuthenticationRequestData* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -157,17 +181,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline ResetKeyRequest* New() const final {
-    return CreateMaybeMessage<ResetKeyRequest>(nullptr);
+  inline FullAuthenticationRequestData* New() const final {
+    return CreateMaybeMessage<FullAuthenticationRequestData>(nullptr);
   }
 
-  ResetKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<ResetKeyRequest>(arena);
+  FullAuthenticationRequestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<FullAuthenticationRequestData>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const ResetKeyRequest& from);
-  void MergeFrom(const ResetKeyRequest& from);
+  void CopyFrom(const FullAuthenticationRequestData& from);
+  void MergeFrom(const FullAuthenticationRequestData& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -181,13 +205,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(ResetKeyRequest* other);
+  void InternalSwap(FullAuthenticationRequestData* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "backup.ResetKeyRequest";
+    return "backup.FullAuthenticationRequestData";
   }
   protected:
-  explicit ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -206,11 +230,15 @@
   // accessors -------------------------------------------------------
 
   enum : int {
-    kUserIdFieldNumber = 1,
-    kNewKeyFieldNumber = 2,
-    kCompactionChunkFieldNumber = 3,
+    kUserIDFieldNumber = 7,
+    kPakeRegistrationRequestFieldNumber = 1,
+    kPakeRegistrationUploadFieldNumber = 2,
+    kPakeCredentialRequestFieldNumber = 3,
+    kPakeCredentialFinalizationFieldNumber = 4,
+    kPakeChallengeResponseFieldNumber = 5,
+    kWalletAuthenticationRequestFieldNumber = 6,
   };
-  // string userId = 1;
+  // string userID = 7;
   void clear_userid();
   const std::string& userid() const;
   void set_userid(const std::string& value);
@@ -226,67 +254,155 @@
   std::string* _internal_mutable_userid();
   public:
 
-  // bytes newKey = 2;
-  bool has_newkey() const;
+  // bytes pakeRegistrationRequest = 1;
+  bool has_pakeregistrationrequest() const;
   private:
-  bool _internal_has_newkey() const;
+  bool _internal_has_pakeregistrationrequest() const;
   public:
-  void clear_newkey();
-  const std::string& newkey() const;
-  void set_newkey(const std::string& value);
-  void set_newkey(std::string&& value);
-  void set_newkey(const char* value);
-  void set_newkey(const void* value, size_t size);
-  std::string* mutable_newkey();
-  std::string* release_newkey();
-  void set_allocated_newkey(std::string* newkey);
+  void clear_pakeregistrationrequest();
+  const std::string& pakeregistrationrequest() const;
+  void set_pakeregistrationrequest(const std::string& value);
+  void set_pakeregistrationrequest(std::string&& value);
+  void set_pakeregistrationrequest(const char* value);
+  void set_pakeregistrationrequest(const void* value, size_t size);
+  std::string* mutable_pakeregistrationrequest();
+  std::string* release_pakeregistrationrequest();
+  void set_allocated_pakeregistrationrequest(std::string* pakeregistrationrequest);
   private:
-  const std::string& _internal_newkey() const;
-  void _internal_set_newkey(const std::string& value);
-  std::string* _internal_mutable_newkey();
+  const std::string& _internal_pakeregistrationrequest() const;
+  void _internal_set_pakeregistrationrequest(const std::string& value);
+  std::string* _internal_mutable_pakeregistrationrequest();
   public:
 
-  // bytes compactionChunk = 3;
-  bool has_compactionchunk() const;
+  // bytes pakeRegistrationUpload = 2;
+  bool has_pakeregistrationupload() const;
   private:
-  bool _internal_has_compactionchunk() const;
+  bool _internal_has_pakeregistrationupload() const;
   public:
-  void clear_compactionchunk();
-  const std::string& compactionchunk() const;
-  void set_compactionchunk(const std::string& value);
-  void set_compactionchunk(std::string&& value);
-  void set_compactionchunk(const char* value);
-  void set_compactionchunk(const void* value, size_t size);
-  std::string* mutable_compactionchunk();
-  std::string* release_compactionchunk();
-  void set_allocated_compactionchunk(std::string* compactionchunk);
+  void clear_pakeregistrationupload();
+  const std::string& pakeregistrationupload() const;
+  void set_pakeregistrationupload(const std::string& value);
+  void set_pakeregistrationupload(std::string&& value);
+  void set_pakeregistrationupload(const char* value);
+  void set_pakeregistrationupload(const void* value, size_t size);
+  std::string* mutable_pakeregistrationupload();
+  std::string* release_pakeregistrationupload();
+  void set_allocated_pakeregistrationupload(std::string* pakeregistrationupload);
   private:
-  const std::string& _internal_compactionchunk() const;
-  void _internal_set_compactionchunk(const std::string& value);
-  std::string* _internal_mutable_compactionchunk();
+  const std::string& _internal_pakeregistrationupload() const;
+  void _internal_set_pakeregistrationupload(const std::string& value);
+  std::string* _internal_mutable_pakeregistrationupload();
   public:
 
-  void clear_data();
-  DataCase data_case() const;
-  // @@protoc_insertion_point(class_scope:backup.ResetKeyRequest)
+  // bytes pakeCredentialRequest = 3;
+  bool has_pakecredentialrequest() const;
+  private:
+  bool _internal_has_pakecredentialrequest() const;
+  public:
+  void clear_pakecredentialrequest();
+  const std::string& pakecredentialrequest() const;
+  void set_pakecredentialrequest(const std::string& value);
+  void set_pakecredentialrequest(std::string&& value);
+  void set_pakecredentialrequest(const char* value);
+  void set_pakecredentialrequest(const void* value, size_t size);
+  std::string* mutable_pakecredentialrequest();
+  std::string* release_pakecredentialrequest();
+  void set_allocated_pakecredentialrequest(std::string* pakecredentialrequest);
+  private:
+  const std::string& _internal_pakecredentialrequest() const;
+  void _internal_set_pakecredentialrequest(const std::string& value);
+  std::string* _internal_mutable_pakecredentialrequest();
+  public:
+
+  // bytes pakeCredentialFinalization = 4;
+  bool has_pakecredentialfinalization() const;
+  private:
+  bool _internal_has_pakecredentialfinalization() const;
+  public:
+  void clear_pakecredentialfinalization();
+  const std::string& pakecredentialfinalization() const;
+  void set_pakecredentialfinalization(const std::string& value);
+  void set_pakecredentialfinalization(std::string&& value);
+  void set_pakecredentialfinalization(const char* value);
+  void set_pakecredentialfinalization(const void* value, size_t size);
+  std::string* mutable_pakecredentialfinalization();
+  std::string* release_pakecredentialfinalization();
+  void set_allocated_pakecredentialfinalization(std::string* pakecredentialfinalization);
+  private:
+  const std::string& _internal_pakecredentialfinalization() const;
+  void _internal_set_pakecredentialfinalization(const std::string& value);
+  std::string* _internal_mutable_pakecredentialfinalization();
+  public:
+
+  // bytes pakeChallengeResponse = 5;
+  bool has_pakechallengeresponse() const;
+  private:
+  bool _internal_has_pakechallengeresponse() const;
+  public:
+  void clear_pakechallengeresponse();
+  const std::string& pakechallengeresponse() const;
+  void set_pakechallengeresponse(const std::string& value);
+  void set_pakechallengeresponse(std::string&& value);
+  void set_pakechallengeresponse(const char* value);
+  void set_pakechallengeresponse(const void* value, size_t size);
+  std::string* mutable_pakechallengeresponse();
+  std::string* release_pakechallengeresponse();
+  void set_allocated_pakechallengeresponse(std::string* pakechallengeresponse);
+  private:
+  const std::string& _internal_pakechallengeresponse() const;
+  void _internal_set_pakechallengeresponse(const std::string& value);
+  std::string* _internal_mutable_pakechallengeresponse();
+  public:
+
+  // bytes walletAuthenticationRequest = 6;
+  bool has_walletauthenticationrequest() const;
+  private:
+  bool _internal_has_walletauthenticationrequest() const;
+  public:
+  void clear_walletauthenticationrequest();
+  const std::string& walletauthenticationrequest() const;
+  void set_walletauthenticationrequest(const std::string& value);
+  void set_walletauthenticationrequest(std::string&& value);
+  void set_walletauthenticationrequest(const char* value);
+  void set_walletauthenticationrequest(const void* value, size_t size);
+  std::string* mutable_walletauthenticationrequest();
+  std::string* release_walletauthenticationrequest();
+  void set_allocated_walletauthenticationrequest(std::string* walletauthenticationrequest);
+  private:
+  const std::string& _internal_walletauthenticationrequest() const;
+  void _internal_set_walletauthenticationrequest(const std::string& value);
+  std::string* _internal_mutable_walletauthenticationrequest();
+  public:
+
+  void clear_requestBytes();
+  RequestBytesCase requestBytes_case() const;
+  // @@protoc_insertion_point(class_scope:backup.FullAuthenticationRequestData)
  private:
   class _Internal;
-  void set_has_newkey();
-  void set_has_compactionchunk();
+  void set_has_pakeregistrationrequest();
+  void set_has_pakeregistrationupload();
+  void set_has_pakecredentialrequest();
+  void set_has_pakecredentialfinalization();
+  void set_has_pakechallengeresponse();
+  void set_has_walletauthenticationrequest();
 
-  inline bool has_data() const;
-  inline void clear_has_data();
+  inline bool has_requestBytes() const;
+  inline void clear_has_requestBytes();
 
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
-  union DataUnion {
-    constexpr DataUnion() : _constinit_{} {}
+  union RequestBytesUnion {
+    constexpr RequestBytesUnion() : _constinit_{} {}
       ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newkey_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_;
-  } data_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationrequest_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationupload_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialrequest_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialfinalization_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakechallengeresponse_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr walletauthenticationrequest_;
+  } requestBytes_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
 
@@ -294,24 +410,24 @@
 };
 // -------------------------------------------------------------------
 
-class SendLogRequest PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SendLogRequest) */ {
+class FullAuthenticationResponseData PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.FullAuthenticationResponseData) */ {
  public:
-  inline SendLogRequest() : SendLogRequest(nullptr) {}
-  virtual ~SendLogRequest();
-  explicit constexpr SendLogRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline FullAuthenticationResponseData() : FullAuthenticationResponseData(nullptr) {}
+  virtual ~FullAuthenticationResponseData();
+  explicit constexpr FullAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  SendLogRequest(const SendLogRequest& from);
-  SendLogRequest(SendLogRequest&& from) noexcept
-    : SendLogRequest() {
+  FullAuthenticationResponseData(const FullAuthenticationResponseData& from);
+  FullAuthenticationResponseData(FullAuthenticationResponseData&& from) noexcept
+    : FullAuthenticationResponseData() {
     *this = ::std::move(from);
   }
 
-  inline SendLogRequest& operator=(const SendLogRequest& from) {
+  inline FullAuthenticationResponseData& operator=(const FullAuthenticationResponseData& from) {
     CopyFrom(from);
     return *this;
   }
-  inline SendLogRequest& operator=(SendLogRequest&& from) noexcept {
+  inline FullAuthenticationResponseData& operator=(FullAuthenticationResponseData&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -329,20 +445,29 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const SendLogRequest& default_instance() {
+  static const FullAuthenticationResponseData& default_instance() {
     return *internal_default_instance();
   }
-  static inline const SendLogRequest* internal_default_instance() {
-    return reinterpret_cast<const SendLogRequest*>(
-               &_SendLogRequest_default_instance_);
+  enum ResponseDataCase {
+    kPakeRegistrationResponse = 1,
+    kPakeRegistrationSuccess = 2,
+    kPakeCredentialResponse = 3,
+    kPakeChallengeMessage = 4,
+    kWalletAuthenticationResponse = 5,
+    RESPONSEDATA_NOT_SET = 0,
+  };
+
+  static inline const FullAuthenticationResponseData* internal_default_instance() {
+    return reinterpret_cast<const FullAuthenticationResponseData*>(
+               &_FullAuthenticationResponseData_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     1;
 
-  friend void swap(SendLogRequest& a, SendLogRequest& b) {
+  friend void swap(FullAuthenticationResponseData& a, FullAuthenticationResponseData& b) {
     a.Swap(&b);
   }
-  inline void Swap(SendLogRequest* other) {
+  inline void Swap(FullAuthenticationResponseData* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -350,7 +475,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(SendLogRequest* other) {
+  void UnsafeArenaSwap(FullAuthenticationResponseData* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -358,17 +483,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline SendLogRequest* New() const final {
-    return CreateMaybeMessage<SendLogRequest>(nullptr);
+  inline FullAuthenticationResponseData* New() const final {
+    return CreateMaybeMessage<FullAuthenticationResponseData>(nullptr);
   }
 
-  SendLogRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<SendLogRequest>(arena);
+  FullAuthenticationResponseData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<FullAuthenticationResponseData>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const SendLogRequest& from);
-  void MergeFrom(const SendLogRequest& from);
+  void CopyFrom(const FullAuthenticationResponseData& from);
+  void MergeFrom(const FullAuthenticationResponseData& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -382,13 +507,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(SendLogRequest* other);
+  void InternalSwap(FullAuthenticationResponseData* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "backup.SendLogRequest";
+    return "backup.FullAuthenticationResponseData";
   }
   protected:
-  explicit SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit FullAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -407,73 +532,156 @@
   // accessors -------------------------------------------------------
 
   enum : int {
-    kUserIdFieldNumber = 1,
-    kDataFieldNumber = 2,
+    kPakeRegistrationResponseFieldNumber = 1,
+    kPakeRegistrationSuccessFieldNumber = 2,
+    kPakeCredentialResponseFieldNumber = 3,
+    kPakeChallengeMessageFieldNumber = 4,
+    kWalletAuthenticationResponseFieldNumber = 5,
   };
-  // string userId = 1;
-  void clear_userid();
-  const std::string& userid() const;
-  void set_userid(const std::string& value);
-  void set_userid(std::string&& value);
-  void set_userid(const char* value);
-  void set_userid(const char* value, size_t size);
-  std::string* mutable_userid();
-  std::string* release_userid();
-  void set_allocated_userid(std::string* userid);
+  // bytes pakeRegistrationResponse = 1;
+  bool has_pakeregistrationresponse() const;
   private:
-  const std::string& _internal_userid() const;
-  void _internal_set_userid(const std::string& value);
-  std::string* _internal_mutable_userid();
+  bool _internal_has_pakeregistrationresponse() const;
+  public:
+  void clear_pakeregistrationresponse();
+  const std::string& pakeregistrationresponse() const;
+  void set_pakeregistrationresponse(const std::string& value);
+  void set_pakeregistrationresponse(std::string&& value);
+  void set_pakeregistrationresponse(const char* value);
+  void set_pakeregistrationresponse(const void* value, size_t size);
+  std::string* mutable_pakeregistrationresponse();
+  std::string* release_pakeregistrationresponse();
+  void set_allocated_pakeregistrationresponse(std::string* pakeregistrationresponse);
+  private:
+  const std::string& _internal_pakeregistrationresponse() const;
+  void _internal_set_pakeregistrationresponse(const std::string& value);
+  std::string* _internal_mutable_pakeregistrationresponse();
   public:
 
-  // bytes data = 2;
-  void clear_data();
-  const std::string& data() const;
-  void set_data(const std::string& value);
-  void set_data(std::string&& value);
-  void set_data(const char* value);
-  void set_data(const void* value, size_t size);
-  std::string* mutable_data();
-  std::string* release_data();
-  void set_allocated_data(std::string* data);
+  // bool pakeRegistrationSuccess = 2;
+  bool has_pakeregistrationsuccess() const;
   private:
-  const std::string& _internal_data() const;
-  void _internal_set_data(const std::string& value);
-  std::string* _internal_mutable_data();
+  bool _internal_has_pakeregistrationsuccess() const;
+  public:
+  void clear_pakeregistrationsuccess();
+  bool pakeregistrationsuccess() const;
+  void set_pakeregistrationsuccess(bool value);
+  private:
+  bool _internal_pakeregistrationsuccess() const;
+  void _internal_set_pakeregistrationsuccess(bool value);
   public:
 
-  // @@protoc_insertion_point(class_scope:backup.SendLogRequest)
+  // bytes pakeCredentialResponse = 3;
+  bool has_pakecredentialresponse() const;
+  private:
+  bool _internal_has_pakecredentialresponse() const;
+  public:
+  void clear_pakecredentialresponse();
+  const std::string& pakecredentialresponse() const;
+  void set_pakecredentialresponse(const std::string& value);
+  void set_pakecredentialresponse(std::string&& value);
+  void set_pakecredentialresponse(const char* value);
+  void set_pakecredentialresponse(const void* value, size_t size);
+  std::string* mutable_pakecredentialresponse();
+  std::string* release_pakecredentialresponse();
+  void set_allocated_pakecredentialresponse(std::string* pakecredentialresponse);
+  private:
+  const std::string& _internal_pakecredentialresponse() const;
+  void _internal_set_pakecredentialresponse(const std::string& value);
+  std::string* _internal_mutable_pakecredentialresponse();
+  public:
+
+  // bytes pakeChallengeMessage = 4;
+  bool has_pakechallengemessage() const;
+  private:
+  bool _internal_has_pakechallengemessage() const;
+  public:
+  void clear_pakechallengemessage();
+  const std::string& pakechallengemessage() const;
+  void set_pakechallengemessage(const std::string& value);
+  void set_pakechallengemessage(std::string&& value);
+  void set_pakechallengemessage(const char* value);
+  void set_pakechallengemessage(const void* value, size_t size);
+  std::string* mutable_pakechallengemessage();
+  std::string* release_pakechallengemessage();
+  void set_allocated_pakechallengemessage(std::string* pakechallengemessage);
+  private:
+  const std::string& _internal_pakechallengemessage() const;
+  void _internal_set_pakechallengemessage(const std::string& value);
+  std::string* _internal_mutable_pakechallengemessage();
+  public:
+
+  // bytes walletAuthenticationResponse = 5;
+  bool has_walletauthenticationresponse() const;
+  private:
+  bool _internal_has_walletauthenticationresponse() const;
+  public:
+  void clear_walletauthenticationresponse();
+  const std::string& walletauthenticationresponse() const;
+  void set_walletauthenticationresponse(const std::string& value);
+  void set_walletauthenticationresponse(std::string&& value);
+  void set_walletauthenticationresponse(const char* value);
+  void set_walletauthenticationresponse(const void* value, size_t size);
+  std::string* mutable_walletauthenticationresponse();
+  std::string* release_walletauthenticationresponse();
+  void set_allocated_walletauthenticationresponse(std::string* walletauthenticationresponse);
+  private:
+  const std::string& _internal_walletauthenticationresponse() const;
+  void _internal_set_walletauthenticationresponse(const std::string& value);
+  std::string* _internal_mutable_walletauthenticationresponse();
+  public:
+
+  void clear_responseData();
+  ResponseDataCase responseData_case() const;
+  // @@protoc_insertion_point(class_scope:backup.FullAuthenticationResponseData)
  private:
   class _Internal;
+  void set_has_pakeregistrationresponse();
+  void set_has_pakeregistrationsuccess();
+  void set_has_pakecredentialresponse();
+  void set_has_pakechallengemessage();
+  void set_has_walletauthenticationresponse();
+
+  inline bool has_responseData() const;
+  inline void clear_has_responseData();
 
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
+  union ResponseDataUnion {
+    constexpr ResponseDataUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationresponse_;
+    bool pakeregistrationsuccess_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialresponse_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakechallengemessage_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr walletauthenticationresponse_;
+  } responseData_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
   friend struct ::TableStruct_backup_2eproto;
 };
 // -------------------------------------------------------------------
 
-class PullBackupKeyRequest PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupKeyRequest) */ {
+class SimpleAuthenticationRequestData PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SimpleAuthenticationRequestData) */ {
  public:
-  inline PullBackupKeyRequest() : PullBackupKeyRequest(nullptr) {}
-  virtual ~PullBackupKeyRequest();
-  explicit constexpr PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline SimpleAuthenticationRequestData() : SimpleAuthenticationRequestData(nullptr) {}
+  virtual ~SimpleAuthenticationRequestData();
+  explicit constexpr SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  PullBackupKeyRequest(const PullBackupKeyRequest& from);
-  PullBackupKeyRequest(PullBackupKeyRequest&& from) noexcept
-    : PullBackupKeyRequest() {
+  SimpleAuthenticationRequestData(const SimpleAuthenticationRequestData& from);
+  SimpleAuthenticationRequestData(SimpleAuthenticationRequestData&& from) noexcept
+    : SimpleAuthenticationRequestData() {
     *this = ::std::move(from);
   }
 
-  inline PullBackupKeyRequest& operator=(const PullBackupKeyRequest& from) {
+  inline SimpleAuthenticationRequestData& operator=(const SimpleAuthenticationRequestData& from) {
     CopyFrom(from);
     return *this;
   }
-  inline PullBackupKeyRequest& operator=(PullBackupKeyRequest&& from) noexcept {
+  inline SimpleAuthenticationRequestData& operator=(SimpleAuthenticationRequestData&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -491,20 +699,20 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const PullBackupKeyRequest& default_instance() {
+  static const SimpleAuthenticationRequestData& default_instance() {
     return *internal_default_instance();
   }
-  static inline const PullBackupKeyRequest* internal_default_instance() {
-    return reinterpret_cast<const PullBackupKeyRequest*>(
-               &_PullBackupKeyRequest_default_instance_);
+  static inline const SimpleAuthenticationRequestData* internal_default_instance() {
+    return reinterpret_cast<const SimpleAuthenticationRequestData*>(
+               &_SimpleAuthenticationRequestData_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     2;
 
-  friend void swap(PullBackupKeyRequest& a, PullBackupKeyRequest& b) {
+  friend void swap(SimpleAuthenticationRequestData& a, SimpleAuthenticationRequestData& b) {
     a.Swap(&b);
   }
-  inline void Swap(PullBackupKeyRequest* other) {
+  inline void Swap(SimpleAuthenticationRequestData* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -512,7 +720,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(PullBackupKeyRequest* other) {
+  void UnsafeArenaSwap(SimpleAuthenticationRequestData* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -520,17 +728,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline PullBackupKeyRequest* New() const final {
-    return CreateMaybeMessage<PullBackupKeyRequest>(nullptr);
+  inline SimpleAuthenticationRequestData* New() const final {
+    return CreateMaybeMessage<SimpleAuthenticationRequestData>(nullptr);
   }
 
-  PullBackupKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<PullBackupKeyRequest>(arena);
+  SimpleAuthenticationRequestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleAuthenticationRequestData>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const PullBackupKeyRequest& from);
-  void MergeFrom(const PullBackupKeyRequest& from);
+  void CopyFrom(const SimpleAuthenticationRequestData& from);
+  void MergeFrom(const SimpleAuthenticationRequestData& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -544,13 +752,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(PullBackupKeyRequest* other);
+  void InternalSwap(SimpleAuthenticationRequestData* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "backup.PullBackupKeyRequest";
+    return "backup.SimpleAuthenticationRequestData";
   }
   protected:
-  explicit PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -569,10 +777,26 @@
   // accessors -------------------------------------------------------
 
   enum : int {
-    kUserIdFieldNumber = 1,
-    kPakeKeyFieldNumber = 2,
+    kBackupIDFieldNumber = 1,
+    kUserIDFieldNumber = 2,
   };
-  // string userId = 1;
+  // string backupID = 1;
+  void clear_backupid();
+  const std::string& backupid() const;
+  void set_backupid(const std::string& value);
+  void set_backupid(std::string&& value);
+  void set_backupid(const char* value);
+  void set_backupid(const char* value, size_t size);
+  std::string* mutable_backupid();
+  std::string* release_backupid();
+  void set_allocated_backupid(std::string* backupid);
+  private:
+  const std::string& _internal_backupid() const;
+  void _internal_set_backupid(const std::string& value);
+  std::string* _internal_mutable_backupid();
+  public:
+
+  // string userID = 2;
   void clear_userid();
   const std::string& userid() const;
   void set_userid(const std::string& value);
@@ -588,54 +812,38 @@
   std::string* _internal_mutable_userid();
   public:
 
-  // bytes pakeKey = 2;
-  void clear_pakekey();
-  const std::string& pakekey() const;
-  void set_pakekey(const std::string& value);
-  void set_pakekey(std::string&& value);
-  void set_pakekey(const char* value);
-  void set_pakekey(const void* value, size_t size);
-  std::string* mutable_pakekey();
-  std::string* release_pakekey();
-  void set_allocated_pakekey(std::string* pakekey);
-  private:
-  const std::string& _internal_pakekey() const;
-  void _internal_set_pakekey(const std::string& value);
-  std::string* _internal_mutable_pakekey();
-  public:
-
-  // @@protoc_insertion_point(class_scope:backup.PullBackupKeyRequest)
+  // @@protoc_insertion_point(class_scope:backup.SimpleAuthenticationRequestData)
  private:
   class _Internal;
 
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_;
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakekey_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   friend struct ::TableStruct_backup_2eproto;
 };
 // -------------------------------------------------------------------
 
-class PullBackupKeyResponse PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupKeyResponse) */ {
+class AuthenticationInformationData PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.AuthenticationInformationData) */ {
  public:
-  inline PullBackupKeyResponse() : PullBackupKeyResponse(nullptr) {}
-  virtual ~PullBackupKeyResponse();
-  explicit constexpr PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline AuthenticationInformationData() : AuthenticationInformationData(nullptr) {}
+  virtual ~AuthenticationInformationData();
+  explicit constexpr AuthenticationInformationData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  PullBackupKeyResponse(const PullBackupKeyResponse& from);
-  PullBackupKeyResponse(PullBackupKeyResponse&& from) noexcept
-    : PullBackupKeyResponse() {
+  AuthenticationInformationData(const AuthenticationInformationData& from);
+  AuthenticationInformationData(AuthenticationInformationData&& from) noexcept
+    : AuthenticationInformationData() {
     *this = ::std::move(from);
   }
 
-  inline PullBackupKeyResponse& operator=(const PullBackupKeyResponse& from) {
+  inline AuthenticationInformationData& operator=(const AuthenticationInformationData& from) {
     CopyFrom(from);
     return *this;
   }
-  inline PullBackupKeyResponse& operator=(PullBackupKeyResponse&& from) noexcept {
+  inline AuthenticationInformationData& operator=(AuthenticationInformationData&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -653,20 +861,26 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const PullBackupKeyResponse& default_instance() {
+  static const AuthenticationInformationData& default_instance() {
     return *internal_default_instance();
   }
-  static inline const PullBackupKeyResponse* internal_default_instance() {
-    return reinterpret_cast<const PullBackupKeyResponse*>(
-               &_PullBackupKeyResponse_default_instance_);
+  enum DataCase {
+    kNonce = 1,
+    kRawMessage = 2,
+    DATA_NOT_SET = 0,
+  };
+
+  static inline const AuthenticationInformationData* internal_default_instance() {
+    return reinterpret_cast<const AuthenticationInformationData*>(
+               &_AuthenticationInformationData_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     3;
 
-  friend void swap(PullBackupKeyResponse& a, PullBackupKeyResponse& b) {
+  friend void swap(AuthenticationInformationData& a, AuthenticationInformationData& b) {
     a.Swap(&b);
   }
-  inline void Swap(PullBackupKeyResponse* other) {
+  inline void Swap(AuthenticationInformationData* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -674,7 +888,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(PullBackupKeyResponse* other) {
+  void UnsafeArenaSwap(AuthenticationInformationData* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -682,17 +896,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline PullBackupKeyResponse* New() const final {
-    return CreateMaybeMessage<PullBackupKeyResponse>(nullptr);
+  inline AuthenticationInformationData* New() const final {
+    return CreateMaybeMessage<AuthenticationInformationData>(nullptr);
   }
 
-  PullBackupKeyResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<PullBackupKeyResponse>(arena);
+  AuthenticationInformationData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<AuthenticationInformationData>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const PullBackupKeyResponse& from);
-  void MergeFrom(const PullBackupKeyResponse& from);
+  void CopyFrom(const AuthenticationInformationData& from);
+  void MergeFrom(const AuthenticationInformationData& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -706,13 +920,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(PullBackupKeyResponse* other);
+  void InternalSwap(AuthenticationInformationData* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "backup.PullBackupKeyResponse";
+    return "backup.AuthenticationInformationData";
   }
   protected:
-  explicit PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit AuthenticationInformationData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -731,55 +945,94 @@
   // accessors -------------------------------------------------------
 
   enum : int {
-    kEncryptedBackupKeyFieldNumber = 1,
+    kNonceFieldNumber = 1,
+    kRawMessageFieldNumber = 2,
   };
-  // bytes encryptedBackupKey = 1;
-  void clear_encryptedbackupkey();
-  const std::string& encryptedbackupkey() const;
-  void set_encryptedbackupkey(const std::string& value);
-  void set_encryptedbackupkey(std::string&& value);
-  void set_encryptedbackupkey(const char* value);
-  void set_encryptedbackupkey(const void* value, size_t size);
-  std::string* mutable_encryptedbackupkey();
-  std::string* release_encryptedbackupkey();
-  void set_allocated_encryptedbackupkey(std::string* encryptedbackupkey);
-  private:
-  const std::string& _internal_encryptedbackupkey() const;
-  void _internal_set_encryptedbackupkey(const std::string& value);
-  std::string* _internal_mutable_encryptedbackupkey();
-  public:
-
-  // @@protoc_insertion_point(class_scope:backup.PullBackupKeyResponse)
+  // bytes nonce = 1;
+  bool has_nonce() const;
+  private:
+  bool _internal_has_nonce() const;
+  public:
+  void clear_nonce();
+  const std::string& nonce() const;
+  void set_nonce(const std::string& value);
+  void set_nonce(std::string&& value);
+  void set_nonce(const char* value);
+  void set_nonce(const void* value, size_t size);
+  std::string* mutable_nonce();
+  std::string* release_nonce();
+  void set_allocated_nonce(std::string* nonce);
+  private:
+  const std::string& _internal_nonce() const;
+  void _internal_set_nonce(const std::string& value);
+  std::string* _internal_mutable_nonce();
+  public:
+
+  // bytes rawMessage = 2;
+  bool has_rawmessage() const;
+  private:
+  bool _internal_has_rawmessage() const;
+  public:
+  void clear_rawmessage();
+  const std::string& rawmessage() const;
+  void set_rawmessage(const std::string& value);
+  void set_rawmessage(std::string&& value);
+  void set_rawmessage(const char* value);
+  void set_rawmessage(const void* value, size_t size);
+  std::string* mutable_rawmessage();
+  std::string* release_rawmessage();
+  void set_allocated_rawmessage(std::string* rawmessage);
+  private:
+  const std::string& _internal_rawmessage() const;
+  void _internal_set_rawmessage(const std::string& value);
+  std::string* _internal_mutable_rawmessage();
+  public:
+
+  void clear_data();
+  DataCase data_case() const;
+  // @@protoc_insertion_point(class_scope:backup.AuthenticationInformationData)
  private:
   class _Internal;
+  void set_has_nonce();
+  void set_has_rawmessage();
+
+  inline bool has_data() const;
+  inline void clear_has_data();
 
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryptedbackupkey_;
+  union DataUnion {
+    constexpr DataUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nonce_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rawmessage_;
+  } data_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
   friend struct ::TableStruct_backup_2eproto;
 };
 // -------------------------------------------------------------------
 
-class PullCompactionRequest PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullCompactionRequest) */ {
+class CreateNewBackupRequest PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.CreateNewBackupRequest) */ {
  public:
-  inline PullCompactionRequest() : PullCompactionRequest(nullptr) {}
-  virtual ~PullCompactionRequest();
-  explicit constexpr PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline CreateNewBackupRequest() : CreateNewBackupRequest(nullptr) {}
+  virtual ~CreateNewBackupRequest();
+  explicit constexpr CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  PullCompactionRequest(const PullCompactionRequest& from);
-  PullCompactionRequest(PullCompactionRequest&& from) noexcept
-    : PullCompactionRequest() {
+  CreateNewBackupRequest(const CreateNewBackupRequest& from);
+  CreateNewBackupRequest(CreateNewBackupRequest&& from) noexcept
+    : CreateNewBackupRequest() {
     *this = ::std::move(from);
   }
 
-  inline PullCompactionRequest& operator=(const PullCompactionRequest& from) {
+  inline CreateNewBackupRequest& operator=(const CreateNewBackupRequest& from) {
     CopyFrom(from);
     return *this;
   }
-  inline PullCompactionRequest& operator=(PullCompactionRequest&& from) noexcept {
+  inline CreateNewBackupRequest& operator=(CreateNewBackupRequest&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -797,20 +1050,27 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const PullCompactionRequest& default_instance() {
+  static const CreateNewBackupRequest& default_instance() {
     return *internal_default_instance();
   }
-  static inline const PullCompactionRequest* internal_default_instance() {
-    return reinterpret_cast<const PullCompactionRequest*>(
-               &_PullCompactionRequest_default_instance_);
+  enum DataCase {
+    kAuthenticationRequestData = 1,
+    kAuthenticationInformationData = 2,
+    kNewCompactionChunk = 3,
+    DATA_NOT_SET = 0,
+  };
+
+  static inline const CreateNewBackupRequest* internal_default_instance() {
+    return reinterpret_cast<const CreateNewBackupRequest*>(
+               &_CreateNewBackupRequest_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     4;
 
-  friend void swap(PullCompactionRequest& a, PullCompactionRequest& b) {
+  friend void swap(CreateNewBackupRequest& a, CreateNewBackupRequest& b) {
     a.Swap(&b);
   }
-  inline void Swap(PullCompactionRequest* other) {
+  inline void Swap(CreateNewBackupRequest* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -818,7 +1078,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(PullCompactionRequest* other) {
+  void UnsafeArenaSwap(CreateNewBackupRequest* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -826,17 +1086,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline PullCompactionRequest* New() const final {
-    return CreateMaybeMessage<PullCompactionRequest>(nullptr);
+  inline CreateNewBackupRequest* New() const final {
+    return CreateMaybeMessage<CreateNewBackupRequest>(nullptr);
   }
 
-  PullCompactionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<PullCompactionRequest>(arena);
+  CreateNewBackupRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<CreateNewBackupRequest>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const PullCompactionRequest& from);
-  void MergeFrom(const PullCompactionRequest& from);
+  void CopyFrom(const CreateNewBackupRequest& from);
+  void MergeFrom(const CreateNewBackupRequest& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -850,13 +1110,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(PullCompactionRequest* other);
+  void InternalSwap(CreateNewBackupRequest* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "backup.PullCompactionRequest";
+    return "backup.CreateNewBackupRequest";
   }
   protected:
-  explicit PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -875,73 +1135,113 @@
   // accessors -------------------------------------------------------
 
   enum : int {
-    kUserIdFieldNumber = 1,
-    kMessageFieldNumber = 2,
+    kAuthenticationRequestDataFieldNumber = 1,
+    kAuthenticationInformationDataFieldNumber = 2,
+    kNewCompactionChunkFieldNumber = 3,
   };
-  // string userId = 1;
-  void clear_userid();
-  const std::string& userid() const;
-  void set_userid(const std::string& value);
-  void set_userid(std::string&& value);
-  void set_userid(const char* value);
-  void set_userid(const char* value, size_t size);
-  std::string* mutable_userid();
-  std::string* release_userid();
-  void set_allocated_userid(std::string* userid);
+  // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
+  bool has_authenticationrequestdata() const;
   private:
-  const std::string& _internal_userid() const;
-  void _internal_set_userid(const std::string& value);
-  std::string* _internal_mutable_userid();
+  bool _internal_has_authenticationrequestdata() const;
+  public:
+  void clear_authenticationrequestdata();
+  const ::backup::FullAuthenticationRequestData& authenticationrequestdata() const;
+  ::backup::FullAuthenticationRequestData* release_authenticationrequestdata();
+  ::backup::FullAuthenticationRequestData* mutable_authenticationrequestdata();
+  void set_allocated_authenticationrequestdata(::backup::FullAuthenticationRequestData* authenticationrequestdata);
+  private:
+  const ::backup::FullAuthenticationRequestData& _internal_authenticationrequestdata() const;
+  ::backup::FullAuthenticationRequestData* _internal_mutable_authenticationrequestdata();
   public:
+  void unsafe_arena_set_allocated_authenticationrequestdata(
+      ::backup::FullAuthenticationRequestData* authenticationrequestdata);
+  ::backup::FullAuthenticationRequestData* unsafe_arena_release_authenticationrequestdata();
 
-  // bytes message = 2;
-  void clear_message();
-  const std::string& message() const;
-  void set_message(const std::string& value);
-  void set_message(std::string&& value);
-  void set_message(const char* value);
-  void set_message(const void* value, size_t size);
-  std::string* mutable_message();
-  std::string* release_message();
-  void set_allocated_message(std::string* message);
+  // .backup.AuthenticationInformationData authenticationInformationData = 2;
+  bool has_authenticationinformationdata() const;
   private:
-  const std::string& _internal_message() const;
-  void _internal_set_message(const std::string& value);
-  std::string* _internal_mutable_message();
+  bool _internal_has_authenticationinformationdata() const;
+  public:
+  void clear_authenticationinformationdata();
+  const ::backup::AuthenticationInformationData& authenticationinformationdata() const;
+  ::backup::AuthenticationInformationData* release_authenticationinformationdata();
+  ::backup::AuthenticationInformationData* mutable_authenticationinformationdata();
+  void set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata);
+  private:
+  const ::backup::AuthenticationInformationData& _internal_authenticationinformationdata() const;
+  ::backup::AuthenticationInformationData* _internal_mutable_authenticationinformationdata();
+  public:
+  void unsafe_arena_set_allocated_authenticationinformationdata(
+      ::backup::AuthenticationInformationData* authenticationinformationdata);
+  ::backup::AuthenticationInformationData* unsafe_arena_release_authenticationinformationdata();
+
+  // bytes newCompactionChunk = 3;
+  bool has_newcompactionchunk() const;
+  private:
+  bool _internal_has_newcompactionchunk() const;
+  public:
+  void clear_newcompactionchunk();
+  const std::string& newcompactionchunk() const;
+  void set_newcompactionchunk(const std::string& value);
+  void set_newcompactionchunk(std::string&& value);
+  void set_newcompactionchunk(const char* value);
+  void set_newcompactionchunk(const void* value, size_t size);
+  std::string* mutable_newcompactionchunk();
+  std::string* release_newcompactionchunk();
+  void set_allocated_newcompactionchunk(std::string* newcompactionchunk);
+  private:
+  const std::string& _internal_newcompactionchunk() const;
+  void _internal_set_newcompactionchunk(const std::string& value);
+  std::string* _internal_mutable_newcompactionchunk();
   public:
 
-  // @@protoc_insertion_point(class_scope:backup.PullCompactionRequest)
+  void clear_data();
+  DataCase data_case() const;
+  // @@protoc_insertion_point(class_scope:backup.CreateNewBackupRequest)
  private:
   class _Internal;
+  void set_has_authenticationrequestdata();
+  void set_has_authenticationinformationdata();
+  void set_has_newcompactionchunk();
+
+  inline bool has_data() const;
+  inline void clear_has_data();
 
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
+  union DataUnion {
+    constexpr DataUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::backup::FullAuthenticationRequestData* authenticationrequestdata_;
+    ::backup::AuthenticationInformationData* authenticationinformationdata_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newcompactionchunk_;
+  } data_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
   friend struct ::TableStruct_backup_2eproto;
 };
 // -------------------------------------------------------------------
 
-class PullCompactionResponse PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullCompactionResponse) */ {
+class CreateNewBackupResponse PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.CreateNewBackupResponse) */ {
  public:
-  inline PullCompactionResponse() : PullCompactionResponse(nullptr) {}
-  virtual ~PullCompactionResponse();
-  explicit constexpr PullCompactionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline CreateNewBackupResponse() : CreateNewBackupResponse(nullptr) {}
+  virtual ~CreateNewBackupResponse();
+  explicit constexpr CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  PullCompactionResponse(const PullCompactionResponse& from);
-  PullCompactionResponse(PullCompactionResponse&& from) noexcept
-    : PullCompactionResponse() {
+  CreateNewBackupResponse(const CreateNewBackupResponse& from);
+  CreateNewBackupResponse(CreateNewBackupResponse&& from) noexcept
+    : CreateNewBackupResponse() {
     *this = ::std::move(from);
   }
 
-  inline PullCompactionResponse& operator=(const PullCompactionResponse& from) {
+  inline CreateNewBackupResponse& operator=(const CreateNewBackupResponse& from) {
     CopyFrom(from);
     return *this;
   }
-  inline PullCompactionResponse& operator=(PullCompactionResponse&& from) noexcept {
+  inline CreateNewBackupResponse& operator=(CreateNewBackupResponse&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -959,26 +1259,26 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const PullCompactionResponse& default_instance() {
+  static const CreateNewBackupResponse& default_instance() {
     return *internal_default_instance();
   }
   enum DataCase {
-    kCompactionChunk = 1,
-    kLogChunk = 2,
+    kAuthenticationResponseData = 1,
+    kBackupID = 2,
     DATA_NOT_SET = 0,
   };
 
-  static inline const PullCompactionResponse* internal_default_instance() {
-    return reinterpret_cast<const PullCompactionResponse*>(
-               &_PullCompactionResponse_default_instance_);
+  static inline const CreateNewBackupResponse* internal_default_instance() {
+    return reinterpret_cast<const CreateNewBackupResponse*>(
+               &_CreateNewBackupResponse_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     5;
 
-  friend void swap(PullCompactionResponse& a, PullCompactionResponse& b) {
+  friend void swap(CreateNewBackupResponse& a, CreateNewBackupResponse& b) {
     a.Swap(&b);
   }
-  inline void Swap(PullCompactionResponse* other) {
+  inline void Swap(CreateNewBackupResponse* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -986,7 +1286,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(PullCompactionResponse* other) {
+  void UnsafeArenaSwap(CreateNewBackupResponse* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -994,17 +1294,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline PullCompactionResponse* New() const final {
-    return CreateMaybeMessage<PullCompactionResponse>(nullptr);
+  inline CreateNewBackupResponse* New() const final {
+    return CreateMaybeMessage<CreateNewBackupResponse>(nullptr);
   }
 
-  PullCompactionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<PullCompactionResponse>(arena);
+  CreateNewBackupResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<CreateNewBackupResponse>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const PullCompactionResponse& from);
-  void MergeFrom(const PullCompactionResponse& from);
+  void CopyFrom(const CreateNewBackupResponse& from);
+  void MergeFrom(const CreateNewBackupResponse& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -1018,13 +1318,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(PullCompactionResponse* other);
+  void InternalSwap(CreateNewBackupResponse* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "backup.PullCompactionResponse";
+    return "backup.CreateNewBackupResponse";
   }
   protected:
-  explicit PullCompactionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -1043,56 +1343,54 @@
   // accessors -------------------------------------------------------
 
   enum : int {
-    kCompactionChunkFieldNumber = 1,
-    kLogChunkFieldNumber = 2,
+    kAuthenticationResponseDataFieldNumber = 1,
+    kBackupIDFieldNumber = 2,
   };
-  // bytes compactionChunk = 1;
-  bool has_compactionchunk() const;
+  // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+  bool has_authenticationresponsedata() const;
   private:
-  bool _internal_has_compactionchunk() const;
+  bool _internal_has_authenticationresponsedata() const;
   public:
-  void clear_compactionchunk();
-  const std::string& compactionchunk() const;
-  void set_compactionchunk(const std::string& value);
-  void set_compactionchunk(std::string&& value);
-  void set_compactionchunk(const char* value);
-  void set_compactionchunk(const void* value, size_t size);
-  std::string* mutable_compactionchunk();
-  std::string* release_compactionchunk();
-  void set_allocated_compactionchunk(std::string* compactionchunk);
+  void clear_authenticationresponsedata();
+  const ::backup::FullAuthenticationResponseData& authenticationresponsedata() const;
+  ::backup::FullAuthenticationResponseData* release_authenticationresponsedata();
+  ::backup::FullAuthenticationResponseData* mutable_authenticationresponsedata();
+  void set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata);
   private:
-  const std::string& _internal_compactionchunk() const;
-  void _internal_set_compactionchunk(const std::string& value);
-  std::string* _internal_mutable_compactionchunk();
+  const ::backup::FullAuthenticationResponseData& _internal_authenticationresponsedata() const;
+  ::backup::FullAuthenticationResponseData* _internal_mutable_authenticationresponsedata();
   public:
+  void unsafe_arena_set_allocated_authenticationresponsedata(
+      ::backup::FullAuthenticationResponseData* authenticationresponsedata);
+  ::backup::FullAuthenticationResponseData* unsafe_arena_release_authenticationresponsedata();
 
-  // bytes logChunk = 2;
-  bool has_logchunk() const;
+  // string backupID = 2;
+  bool has_backupid() const;
   private:
-  bool _internal_has_logchunk() const;
+  bool _internal_has_backupid() const;
   public:
-  void clear_logchunk();
-  const std::string& logchunk() const;
-  void set_logchunk(const std::string& value);
-  void set_logchunk(std::string&& value);
-  void set_logchunk(const char* value);
-  void set_logchunk(const void* value, size_t size);
-  std::string* mutable_logchunk();
-  std::string* release_logchunk();
-  void set_allocated_logchunk(std::string* logchunk);
+  void clear_backupid();
+  const std::string& backupid() const;
+  void set_backupid(const std::string& value);
+  void set_backupid(std::string&& value);
+  void set_backupid(const char* value);
+  void set_backupid(const char* value, size_t size);
+  std::string* mutable_backupid();
+  std::string* release_backupid();
+  void set_allocated_backupid(std::string* backupid);
   private:
-  const std::string& _internal_logchunk() const;
-  void _internal_set_logchunk(const std::string& value);
-  std::string* _internal_mutable_logchunk();
+  const std::string& _internal_backupid() const;
+  void _internal_set_backupid(const std::string& value);
+  std::string* _internal_mutable_backupid();
   public:
 
   void clear_data();
   DataCase data_case() const;
-  // @@protoc_insertion_point(class_scope:backup.PullCompactionResponse)
+  // @@protoc_insertion_point(class_scope:backup.CreateNewBackupResponse)
  private:
   class _Internal;
-  void set_has_compactionchunk();
-  void set_has_logchunk();
+  void set_has_authenticationresponsedata();
+  void set_has_backupid();
 
   inline bool has_data() const;
   inline void clear_has_data();
@@ -1103,76 +1401,2216 @@
   union DataUnion {
     constexpr DataUnion() : _constinit_{} {}
       ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logchunk_;
+    ::backup::FullAuthenticationResponseData* authenticationresponsedata_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_;
   } data_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
 
   friend struct ::TableStruct_backup_2eproto;
 };
-// ===================================================================
+// -------------------------------------------------------------------
 
+class SendLogRequest PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SendLogRequest) */ {
+ public:
+  inline SendLogRequest() : SendLogRequest(nullptr) {}
+  virtual ~SendLogRequest();
+  explicit constexpr SendLogRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-// ===================================================================
+  SendLogRequest(const SendLogRequest& from);
+  SendLogRequest(SendLogRequest&& from) noexcept
+    : SendLogRequest() {
+    *this = ::std::move(from);
+  }
 
-#ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif  // __GNUC__
-// ResetKeyRequest
+  inline SendLogRequest& operator=(const SendLogRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SendLogRequest& operator=(SendLogRequest&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
 
-// string userId = 1;
-inline void ResetKeyRequest::clear_userid() {
-  userid_.ClearToEmpty();
-}
-inline const std::string& ResetKeyRequest::userid() const {
-  // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.userId)
-  return _internal_userid();
-}
-inline void ResetKeyRequest::set_userid(const std::string& value) {
-  _internal_set_userid(value);
-  // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.userId)
-}
-inline std::string* ResetKeyRequest::mutable_userid() {
-  // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.userId)
-  return _internal_mutable_userid();
-}
-inline const std::string& ResetKeyRequest::_internal_userid() const {
-  return userid_.Get();
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const SendLogRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SendLogRequest* internal_default_instance() {
+    return reinterpret_cast<const SendLogRequest*>(
+               &_SendLogRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(SendLogRequest& a, SendLogRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SendLogRequest* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SendLogRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SendLogRequest* New() const final {
+    return CreateMaybeMessage<SendLogRequest>(nullptr);
+  }
+
+  SendLogRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SendLogRequest>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const SendLogRequest& from);
+  void MergeFrom(const SendLogRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SendLogRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "backup.SendLogRequest";
+  }
+  protected:
+  explicit SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLogDataFieldNumber = 2,
+    kAuthenticationDataFieldNumber = 1,
+  };
+  // bytes logData = 2;
+  void clear_logdata();
+  const std::string& logdata() const;
+  void set_logdata(const std::string& value);
+  void set_logdata(std::string&& value);
+  void set_logdata(const char* value);
+  void set_logdata(const void* value, size_t size);
+  std::string* mutable_logdata();
+  std::string* release_logdata();
+  void set_allocated_logdata(std::string* logdata);
+  private:
+  const std::string& _internal_logdata() const;
+  void _internal_set_logdata(const std::string& value);
+  std::string* _internal_mutable_logdata();
+  public:
+
+  // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+  bool has_authenticationdata() const;
+  private:
+  bool _internal_has_authenticationdata() const;
+  public:
+  void clear_authenticationdata();
+  const ::backup::SimpleAuthenticationRequestData& authenticationdata() const;
+  ::backup::SimpleAuthenticationRequestData* release_authenticationdata();
+  ::backup::SimpleAuthenticationRequestData* mutable_authenticationdata();
+  void set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata);
+  private:
+  const ::backup::SimpleAuthenticationRequestData& _internal_authenticationdata() const;
+  ::backup::SimpleAuthenticationRequestData* _internal_mutable_authenticationdata();
+  public:
+  void unsafe_arena_set_allocated_authenticationdata(
+      ::backup::SimpleAuthenticationRequestData* authenticationdata);
+  ::backup::SimpleAuthenticationRequestData* unsafe_arena_release_authenticationdata();
+
+  // @@protoc_insertion_point(class_scope:backup.SendLogRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logdata_;
+  ::backup::SimpleAuthenticationRequestData* authenticationdata_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RecoverBackupKeyRequest PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.RecoverBackupKeyRequest) */ {
+ public:
+  inline RecoverBackupKeyRequest() : RecoverBackupKeyRequest(nullptr) {}
+  virtual ~RecoverBackupKeyRequest();
+  explicit constexpr RecoverBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RecoverBackupKeyRequest(const RecoverBackupKeyRequest& from);
+  RecoverBackupKeyRequest(RecoverBackupKeyRequest&& from) noexcept
+    : RecoverBackupKeyRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline RecoverBackupKeyRequest& operator=(const RecoverBackupKeyRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RecoverBackupKeyRequest& operator=(RecoverBackupKeyRequest&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const RecoverBackupKeyRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RecoverBackupKeyRequest* internal_default_instance() {
+    return reinterpret_cast<const RecoverBackupKeyRequest*>(
+               &_RecoverBackupKeyRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(RecoverBackupKeyRequest& a, RecoverBackupKeyRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RecoverBackupKeyRequest* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RecoverBackupKeyRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RecoverBackupKeyRequest* New() const final {
+    return CreateMaybeMessage<RecoverBackupKeyRequest>(nullptr);
+  }
+
+  RecoverBackupKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<RecoverBackupKeyRequest>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const RecoverBackupKeyRequest& from);
+  void MergeFrom(const RecoverBackupKeyRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RecoverBackupKeyRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "backup.RecoverBackupKeyRequest";
+  }
+  protected:
+  explicit RecoverBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAuthenticationDataFieldNumber = 1,
+  };
+  // .backup.FullAuthenticationRequestData authenticationData = 1;
+  bool has_authenticationdata() const;
+  private:
+  bool _internal_has_authenticationdata() const;
+  public:
+  void clear_authenticationdata();
+  const ::backup::FullAuthenticationRequestData& authenticationdata() const;
+  ::backup::FullAuthenticationRequestData* release_authenticationdata();
+  ::backup::FullAuthenticationRequestData* mutable_authenticationdata();
+  void set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata);
+  private:
+  const ::backup::FullAuthenticationRequestData& _internal_authenticationdata() const;
+  ::backup::FullAuthenticationRequestData* _internal_mutable_authenticationdata();
+  public:
+  void unsafe_arena_set_allocated_authenticationdata(
+      ::backup::FullAuthenticationRequestData* authenticationdata);
+  ::backup::FullAuthenticationRequestData* unsafe_arena_release_authenticationdata();
+
+  // @@protoc_insertion_point(class_scope:backup.RecoverBackupKeyRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::backup::FullAuthenticationRequestData* authenticationdata_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RecoverBackupKeyResponse PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.RecoverBackupKeyResponse) */ {
+ public:
+  inline RecoverBackupKeyResponse() : RecoverBackupKeyResponse(nullptr) {}
+  virtual ~RecoverBackupKeyResponse();
+  explicit constexpr RecoverBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RecoverBackupKeyResponse(const RecoverBackupKeyResponse& from);
+  RecoverBackupKeyResponse(RecoverBackupKeyResponse&& from) noexcept
+    : RecoverBackupKeyResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline RecoverBackupKeyResponse& operator=(const RecoverBackupKeyResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RecoverBackupKeyResponse& operator=(RecoverBackupKeyResponse&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const RecoverBackupKeyResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  enum DataCase {
+    kAuthenticationResponseData = 1,
+    kAuthenticationInformationData = 2,
+    kBackupID = 3,
+    DATA_NOT_SET = 0,
+  };
+
+  static inline const RecoverBackupKeyResponse* internal_default_instance() {
+    return reinterpret_cast<const RecoverBackupKeyResponse*>(
+               &_RecoverBackupKeyResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(RecoverBackupKeyResponse& a, RecoverBackupKeyResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RecoverBackupKeyResponse* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RecoverBackupKeyResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RecoverBackupKeyResponse* New() const final {
+    return CreateMaybeMessage<RecoverBackupKeyResponse>(nullptr);
+  }
+
+  RecoverBackupKeyResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<RecoverBackupKeyResponse>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const RecoverBackupKeyResponse& from);
+  void MergeFrom(const RecoverBackupKeyResponse& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RecoverBackupKeyResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "backup.RecoverBackupKeyResponse";
+  }
+  protected:
+  explicit RecoverBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAuthenticationResponseDataFieldNumber = 1,
+    kAuthenticationInformationDataFieldNumber = 2,
+    kBackupIDFieldNumber = 3,
+  };
+  // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+  bool has_authenticationresponsedata() const;
+  private:
+  bool _internal_has_authenticationresponsedata() const;
+  public:
+  void clear_authenticationresponsedata();
+  const ::backup::FullAuthenticationResponseData& authenticationresponsedata() const;
+  ::backup::FullAuthenticationResponseData* release_authenticationresponsedata();
+  ::backup::FullAuthenticationResponseData* mutable_authenticationresponsedata();
+  void set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata);
+  private:
+  const ::backup::FullAuthenticationResponseData& _internal_authenticationresponsedata() const;
+  ::backup::FullAuthenticationResponseData* _internal_mutable_authenticationresponsedata();
+  public:
+  void unsafe_arena_set_allocated_authenticationresponsedata(
+      ::backup::FullAuthenticationResponseData* authenticationresponsedata);
+  ::backup::FullAuthenticationResponseData* unsafe_arena_release_authenticationresponsedata();
+
+  // .backup.AuthenticationInformationData authenticationInformationData = 2;
+  bool has_authenticationinformationdata() const;
+  private:
+  bool _internal_has_authenticationinformationdata() const;
+  public:
+  void clear_authenticationinformationdata();
+  const ::backup::AuthenticationInformationData& authenticationinformationdata() const;
+  ::backup::AuthenticationInformationData* release_authenticationinformationdata();
+  ::backup::AuthenticationInformationData* mutable_authenticationinformationdata();
+  void set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata);
+  private:
+  const ::backup::AuthenticationInformationData& _internal_authenticationinformationdata() const;
+  ::backup::AuthenticationInformationData* _internal_mutable_authenticationinformationdata();
+  public:
+  void unsafe_arena_set_allocated_authenticationinformationdata(
+      ::backup::AuthenticationInformationData* authenticationinformationdata);
+  ::backup::AuthenticationInformationData* unsafe_arena_release_authenticationinformationdata();
+
+  // string backupID = 3;
+  bool has_backupid() const;
+  private:
+  bool _internal_has_backupid() const;
+  public:
+  void clear_backupid();
+  const std::string& backupid() const;
+  void set_backupid(const std::string& value);
+  void set_backupid(std::string&& value);
+  void set_backupid(const char* value);
+  void set_backupid(const char* value, size_t size);
+  std::string* mutable_backupid();
+  std::string* release_backupid();
+  void set_allocated_backupid(std::string* backupid);
+  private:
+  const std::string& _internal_backupid() const;
+  void _internal_set_backupid(const std::string& value);
+  std::string* _internal_mutable_backupid();
+  public:
+
+  void clear_data();
+  DataCase data_case() const;
+  // @@protoc_insertion_point(class_scope:backup.RecoverBackupKeyResponse)
+ private:
+  class _Internal;
+  void set_has_authenticationresponsedata();
+  void set_has_authenticationinformationdata();
+  void set_has_backupid();
+
+  inline bool has_data() const;
+  inline void clear_has_data();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union DataUnion {
+    constexpr DataUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::backup::FullAuthenticationResponseData* authenticationresponsedata_;
+    ::backup::AuthenticationInformationData* authenticationinformationdata_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_;
+  } data_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+  friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PullBackupRequest PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupRequest) */ {
+ public:
+  inline PullBackupRequest() : PullBackupRequest(nullptr) {}
+  virtual ~PullBackupRequest();
+  explicit constexpr PullBackupRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PullBackupRequest(const PullBackupRequest& from);
+  PullBackupRequest(PullBackupRequest&& from) noexcept
+    : PullBackupRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline PullBackupRequest& operator=(const PullBackupRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PullBackupRequest& operator=(PullBackupRequest&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const PullBackupRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PullBackupRequest* internal_default_instance() {
+    return reinterpret_cast<const PullBackupRequest*>(
+               &_PullBackupRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(PullBackupRequest& a, PullBackupRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PullBackupRequest* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PullBackupRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PullBackupRequest* New() const final {
+    return CreateMaybeMessage<PullBackupRequest>(nullptr);
+  }
+
+  PullBackupRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PullBackupRequest>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const PullBackupRequest& from);
+  void MergeFrom(const PullBackupRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PullBackupRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "backup.PullBackupRequest";
+  }
+  protected:
+  explicit PullBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAuthenticationDataFieldNumber = 1,
+  };
+  // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+  bool has_authenticationdata() const;
+  private:
+  bool _internal_has_authenticationdata() const;
+  public:
+  void clear_authenticationdata();
+  const ::backup::SimpleAuthenticationRequestData& authenticationdata() const;
+  ::backup::SimpleAuthenticationRequestData* release_authenticationdata();
+  ::backup::SimpleAuthenticationRequestData* mutable_authenticationdata();
+  void set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata);
+  private:
+  const ::backup::SimpleAuthenticationRequestData& _internal_authenticationdata() const;
+  ::backup::SimpleAuthenticationRequestData* _internal_mutable_authenticationdata();
+  public:
+  void unsafe_arena_set_allocated_authenticationdata(
+      ::backup::SimpleAuthenticationRequestData* authenticationdata);
+  ::backup::SimpleAuthenticationRequestData* unsafe_arena_release_authenticationdata();
+
+  // @@protoc_insertion_point(class_scope:backup.PullBackupRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::backup::SimpleAuthenticationRequestData* authenticationdata_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PullBackupResponse PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupResponse) */ {
+ public:
+  inline PullBackupResponse() : PullBackupResponse(nullptr) {}
+  virtual ~PullBackupResponse();
+  explicit constexpr PullBackupResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PullBackupResponse(const PullBackupResponse& from);
+  PullBackupResponse(PullBackupResponse&& from) noexcept
+    : PullBackupResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline PullBackupResponse& operator=(const PullBackupResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PullBackupResponse& operator=(PullBackupResponse&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const PullBackupResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  enum DataCase {
+    kCompactionChunk = 1,
+    kLogChunk = 2,
+    DATA_NOT_SET = 0,
+  };
+
+  static inline const PullBackupResponse* internal_default_instance() {
+    return reinterpret_cast<const PullBackupResponse*>(
+               &_PullBackupResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(PullBackupResponse& a, PullBackupResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PullBackupResponse* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PullBackupResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PullBackupResponse* New() const final {
+    return CreateMaybeMessage<PullBackupResponse>(nullptr);
+  }
+
+  PullBackupResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PullBackupResponse>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const PullBackupResponse& from);
+  void MergeFrom(const PullBackupResponse& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PullBackupResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "backup.PullBackupResponse";
+  }
+  protected:
+  explicit PullBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCompactionChunkFieldNumber = 1,
+    kLogChunkFieldNumber = 2,
+  };
+  // bytes compactionChunk = 1;
+  bool has_compactionchunk() const;
+  private:
+  bool _internal_has_compactionchunk() const;
+  public:
+  void clear_compactionchunk();
+  const std::string& compactionchunk() const;
+  void set_compactionchunk(const std::string& value);
+  void set_compactionchunk(std::string&& value);
+  void set_compactionchunk(const char* value);
+  void set_compactionchunk(const void* value, size_t size);
+  std::string* mutable_compactionchunk();
+  std::string* release_compactionchunk();
+  void set_allocated_compactionchunk(std::string* compactionchunk);
+  private:
+  const std::string& _internal_compactionchunk() const;
+  void _internal_set_compactionchunk(const std::string& value);
+  std::string* _internal_mutable_compactionchunk();
+  public:
+
+  // bytes logChunk = 2;
+  bool has_logchunk() const;
+  private:
+  bool _internal_has_logchunk() const;
+  public:
+  void clear_logchunk();
+  const std::string& logchunk() const;
+  void set_logchunk(const std::string& value);
+  void set_logchunk(std::string&& value);
+  void set_logchunk(const char* value);
+  void set_logchunk(const void* value, size_t size);
+  std::string* mutable_logchunk();
+  std::string* release_logchunk();
+  void set_allocated_logchunk(std::string* logchunk);
+  private:
+  const std::string& _internal_logchunk() const;
+  void _internal_set_logchunk(const std::string& value);
+  std::string* _internal_mutable_logchunk();
+  public:
+
+  void clear_data();
+  DataCase data_case() const;
+  // @@protoc_insertion_point(class_scope:backup.PullBackupResponse)
+ private:
+  class _Internal;
+  void set_has_compactionchunk();
+  void set_has_logchunk();
+
+  inline bool has_data() const;
+  inline void clear_has_data();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union DataUnion {
+    constexpr DataUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logchunk_;
+  } data_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+  friend struct ::TableStruct_backup_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// FullAuthenticationRequestData
+
+// bytes pakeRegistrationRequest = 1;
+inline bool FullAuthenticationRequestData::_internal_has_pakeregistrationrequest() const {
+  return requestBytes_case() == kPakeRegistrationRequest;
+}
+inline bool FullAuthenticationRequestData::has_pakeregistrationrequest() const {
+  return _internal_has_pakeregistrationrequest();
+}
+inline void FullAuthenticationRequestData::set_has_pakeregistrationrequest() {
+  _oneof_case_[0] = kPakeRegistrationRequest;
+}
+inline void FullAuthenticationRequestData::clear_pakeregistrationrequest() {
+  if (_internal_has_pakeregistrationrequest()) {
+    requestBytes_.pakeregistrationrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_requestBytes();
+  }
+}
+inline const std::string& FullAuthenticationRequestData::pakeregistrationrequest() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
+  return _internal_pakeregistrationrequest();
+}
+inline void FullAuthenticationRequestData::set_pakeregistrationrequest(const std::string& value) {
+  _internal_set_pakeregistrationrequest(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
+}
+inline std::string* FullAuthenticationRequestData::mutable_pakeregistrationrequest() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
+  return _internal_mutable_pakeregistrationrequest();
+}
+inline const std::string& FullAuthenticationRequestData::_internal_pakeregistrationrequest() const {
+  if (_internal_has_pakeregistrationrequest()) {
+    return requestBytes_.pakeregistrationrequest_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullAuthenticationRequestData::_internal_set_pakeregistrationrequest(const std::string& value) {
+  if (!_internal_has_pakeregistrationrequest()) {
+    clear_requestBytes();
+    set_has_pakeregistrationrequest();
+    requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationRequestData::set_pakeregistrationrequest(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
+  if (!_internal_has_pakeregistrationrequest()) {
+    clear_requestBytes();
+    set_has_pakeregistrationrequest();
+    requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakeregistrationrequest_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
+}
+inline void FullAuthenticationRequestData::set_pakeregistrationrequest(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_pakeregistrationrequest()) {
+    clear_requestBytes();
+    set_has_pakeregistrationrequest();
+    requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
+}
+inline void FullAuthenticationRequestData::set_pakeregistrationrequest(const void* value,
+                             size_t size) {
+  if (!_internal_has_pakeregistrationrequest()) {
+    clear_requestBytes();
+    set_has_pakeregistrationrequest();
+    requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakeregistrationrequest_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
+}
+inline std::string* FullAuthenticationRequestData::_internal_mutable_pakeregistrationrequest() {
+  if (!_internal_has_pakeregistrationrequest()) {
+    clear_requestBytes();
+    set_has_pakeregistrationrequest();
+    requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return requestBytes_.pakeregistrationrequest_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationRequestData::release_pakeregistrationrequest() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
+  if (_internal_has_pakeregistrationrequest()) {
+    clear_has_requestBytes();
+    return requestBytes_.pakeregistrationrequest_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void FullAuthenticationRequestData::set_allocated_pakeregistrationrequest(std::string* pakeregistrationrequest) {
+  if (has_requestBytes()) {
+    clear_requestBytes();
+  }
+  if (pakeregistrationrequest != nullptr) {
+    set_has_pakeregistrationrequest();
+    requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(pakeregistrationrequest);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(pakeregistrationrequest);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
+}
+
+// bytes pakeRegistrationUpload = 2;
+inline bool FullAuthenticationRequestData::_internal_has_pakeregistrationupload() const {
+  return requestBytes_case() == kPakeRegistrationUpload;
+}
+inline bool FullAuthenticationRequestData::has_pakeregistrationupload() const {
+  return _internal_has_pakeregistrationupload();
+}
+inline void FullAuthenticationRequestData::set_has_pakeregistrationupload() {
+  _oneof_case_[0] = kPakeRegistrationUpload;
+}
+inline void FullAuthenticationRequestData::clear_pakeregistrationupload() {
+  if (_internal_has_pakeregistrationupload()) {
+    requestBytes_.pakeregistrationupload_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_requestBytes();
+  }
+}
+inline const std::string& FullAuthenticationRequestData::pakeregistrationupload() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
+  return _internal_pakeregistrationupload();
+}
+inline void FullAuthenticationRequestData::set_pakeregistrationupload(const std::string& value) {
+  _internal_set_pakeregistrationupload(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
+}
+inline std::string* FullAuthenticationRequestData::mutable_pakeregistrationupload() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
+  return _internal_mutable_pakeregistrationupload();
+}
+inline const std::string& FullAuthenticationRequestData::_internal_pakeregistrationupload() const {
+  if (_internal_has_pakeregistrationupload()) {
+    return requestBytes_.pakeregistrationupload_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullAuthenticationRequestData::_internal_set_pakeregistrationupload(const std::string& value) {
+  if (!_internal_has_pakeregistrationupload()) {
+    clear_requestBytes();
+    set_has_pakeregistrationupload();
+    requestBytes_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationRequestData::set_pakeregistrationupload(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
+  if (!_internal_has_pakeregistrationupload()) {
+    clear_requestBytes();
+    set_has_pakeregistrationupload();
+    requestBytes_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakeregistrationupload_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
+}
+inline void FullAuthenticationRequestData::set_pakeregistrationupload(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_pakeregistrationupload()) {
+    clear_requestBytes();
+    set_has_pakeregistrationupload();
+    requestBytes_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
+}
+inline void FullAuthenticationRequestData::set_pakeregistrationupload(const void* value,
+                             size_t size) {
+  if (!_internal_has_pakeregistrationupload()) {
+    clear_requestBytes();
+    set_has_pakeregistrationupload();
+    requestBytes_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakeregistrationupload_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
+}
+inline std::string* FullAuthenticationRequestData::_internal_mutable_pakeregistrationupload() {
+  if (!_internal_has_pakeregistrationupload()) {
+    clear_requestBytes();
+    set_has_pakeregistrationupload();
+    requestBytes_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return requestBytes_.pakeregistrationupload_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationRequestData::release_pakeregistrationupload() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
+  if (_internal_has_pakeregistrationupload()) {
+    clear_has_requestBytes();
+    return requestBytes_.pakeregistrationupload_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void FullAuthenticationRequestData::set_allocated_pakeregistrationupload(std::string* pakeregistrationupload) {
+  if (has_requestBytes()) {
+    clear_requestBytes();
+  }
+  if (pakeregistrationupload != nullptr) {
+    set_has_pakeregistrationupload();
+    requestBytes_.pakeregistrationupload_.UnsafeSetDefault(pakeregistrationupload);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(pakeregistrationupload);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
+}
+
+// bytes pakeCredentialRequest = 3;
+inline bool FullAuthenticationRequestData::_internal_has_pakecredentialrequest() const {
+  return requestBytes_case() == kPakeCredentialRequest;
+}
+inline bool FullAuthenticationRequestData::has_pakecredentialrequest() const {
+  return _internal_has_pakecredentialrequest();
+}
+inline void FullAuthenticationRequestData::set_has_pakecredentialrequest() {
+  _oneof_case_[0] = kPakeCredentialRequest;
+}
+inline void FullAuthenticationRequestData::clear_pakecredentialrequest() {
+  if (_internal_has_pakecredentialrequest()) {
+    requestBytes_.pakecredentialrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_requestBytes();
+  }
+}
+inline const std::string& FullAuthenticationRequestData::pakecredentialrequest() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeCredentialRequest)
+  return _internal_pakecredentialrequest();
+}
+inline void FullAuthenticationRequestData::set_pakecredentialrequest(const std::string& value) {
+  _internal_set_pakecredentialrequest(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeCredentialRequest)
+}
+inline std::string* FullAuthenticationRequestData::mutable_pakecredentialrequest() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeCredentialRequest)
+  return _internal_mutable_pakecredentialrequest();
+}
+inline const std::string& FullAuthenticationRequestData::_internal_pakecredentialrequest() const {
+  if (_internal_has_pakecredentialrequest()) {
+    return requestBytes_.pakecredentialrequest_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullAuthenticationRequestData::_internal_set_pakecredentialrequest(const std::string& value) {
+  if (!_internal_has_pakecredentialrequest()) {
+    clear_requestBytes();
+    set_has_pakecredentialrequest();
+    requestBytes_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationRequestData::set_pakecredentialrequest(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeCredentialRequest)
+  if (!_internal_has_pakecredentialrequest()) {
+    clear_requestBytes();
+    set_has_pakecredentialrequest();
+    requestBytes_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakecredentialrequest_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.pakeCredentialRequest)
+}
+inline void FullAuthenticationRequestData::set_pakecredentialrequest(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_pakecredentialrequest()) {
+    clear_requestBytes();
+    set_has_pakecredentialrequest();
+    requestBytes_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.pakeCredentialRequest)
+}
+inline void FullAuthenticationRequestData::set_pakecredentialrequest(const void* value,
+                             size_t size) {
+  if (!_internal_has_pakecredentialrequest()) {
+    clear_requestBytes();
+    set_has_pakecredentialrequest();
+    requestBytes_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakecredentialrequest_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.pakeCredentialRequest)
+}
+inline std::string* FullAuthenticationRequestData::_internal_mutable_pakecredentialrequest() {
+  if (!_internal_has_pakecredentialrequest()) {
+    clear_requestBytes();
+    set_has_pakecredentialrequest();
+    requestBytes_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return requestBytes_.pakecredentialrequest_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationRequestData::release_pakecredentialrequest() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeCredentialRequest)
+  if (_internal_has_pakecredentialrequest()) {
+    clear_has_requestBytes();
+    return requestBytes_.pakecredentialrequest_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void FullAuthenticationRequestData::set_allocated_pakecredentialrequest(std::string* pakecredentialrequest) {
+  if (has_requestBytes()) {
+    clear_requestBytes();
+  }
+  if (pakecredentialrequest != nullptr) {
+    set_has_pakecredentialrequest();
+    requestBytes_.pakecredentialrequest_.UnsafeSetDefault(pakecredentialrequest);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(pakecredentialrequest);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeCredentialRequest)
+}
+
+// bytes pakeCredentialFinalization = 4;
+inline bool FullAuthenticationRequestData::_internal_has_pakecredentialfinalization() const {
+  return requestBytes_case() == kPakeCredentialFinalization;
+}
+inline bool FullAuthenticationRequestData::has_pakecredentialfinalization() const {
+  return _internal_has_pakecredentialfinalization();
+}
+inline void FullAuthenticationRequestData::set_has_pakecredentialfinalization() {
+  _oneof_case_[0] = kPakeCredentialFinalization;
+}
+inline void FullAuthenticationRequestData::clear_pakecredentialfinalization() {
+  if (_internal_has_pakecredentialfinalization()) {
+    requestBytes_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_requestBytes();
+  }
+}
+inline const std::string& FullAuthenticationRequestData::pakecredentialfinalization() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
+  return _internal_pakecredentialfinalization();
+}
+inline void FullAuthenticationRequestData::set_pakecredentialfinalization(const std::string& value) {
+  _internal_set_pakecredentialfinalization(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
+}
+inline std::string* FullAuthenticationRequestData::mutable_pakecredentialfinalization() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
+  return _internal_mutable_pakecredentialfinalization();
+}
+inline const std::string& FullAuthenticationRequestData::_internal_pakecredentialfinalization() const {
+  if (_internal_has_pakecredentialfinalization()) {
+    return requestBytes_.pakecredentialfinalization_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullAuthenticationRequestData::_internal_set_pakecredentialfinalization(const std::string& value) {
+  if (!_internal_has_pakecredentialfinalization()) {
+    clear_requestBytes();
+    set_has_pakecredentialfinalization();
+    requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakecredentialfinalization_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationRequestData::set_pakecredentialfinalization(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
+  if (!_internal_has_pakecredentialfinalization()) {
+    clear_requestBytes();
+    set_has_pakecredentialfinalization();
+    requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakecredentialfinalization_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
+}
+inline void FullAuthenticationRequestData::set_pakecredentialfinalization(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_pakecredentialfinalization()) {
+    clear_requestBytes();
+    set_has_pakecredentialfinalization();
+    requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakecredentialfinalization_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
+}
+inline void FullAuthenticationRequestData::set_pakecredentialfinalization(const void* value,
+                             size_t size) {
+  if (!_internal_has_pakecredentialfinalization()) {
+    clear_requestBytes();
+    set_has_pakecredentialfinalization();
+    requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakecredentialfinalization_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
+}
+inline std::string* FullAuthenticationRequestData::_internal_mutable_pakecredentialfinalization() {
+  if (!_internal_has_pakecredentialfinalization()) {
+    clear_requestBytes();
+    set_has_pakecredentialfinalization();
+    requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return requestBytes_.pakecredentialfinalization_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationRequestData::release_pakecredentialfinalization() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
+  if (_internal_has_pakecredentialfinalization()) {
+    clear_has_requestBytes();
+    return requestBytes_.pakecredentialfinalization_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void FullAuthenticationRequestData::set_allocated_pakecredentialfinalization(std::string* pakecredentialfinalization) {
+  if (has_requestBytes()) {
+    clear_requestBytes();
+  }
+  if (pakecredentialfinalization != nullptr) {
+    set_has_pakecredentialfinalization();
+    requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(pakecredentialfinalization);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(pakecredentialfinalization);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
+}
+
+// bytes pakeChallengeResponse = 5;
+inline bool FullAuthenticationRequestData::_internal_has_pakechallengeresponse() const {
+  return requestBytes_case() == kPakeChallengeResponse;
+}
+inline bool FullAuthenticationRequestData::has_pakechallengeresponse() const {
+  return _internal_has_pakechallengeresponse();
+}
+inline void FullAuthenticationRequestData::set_has_pakechallengeresponse() {
+  _oneof_case_[0] = kPakeChallengeResponse;
+}
+inline void FullAuthenticationRequestData::clear_pakechallengeresponse() {
+  if (_internal_has_pakechallengeresponse()) {
+    requestBytes_.pakechallengeresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_requestBytes();
+  }
+}
+inline const std::string& FullAuthenticationRequestData::pakechallengeresponse() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeChallengeResponse)
+  return _internal_pakechallengeresponse();
+}
+inline void FullAuthenticationRequestData::set_pakechallengeresponse(const std::string& value) {
+  _internal_set_pakechallengeresponse(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeChallengeResponse)
+}
+inline std::string* FullAuthenticationRequestData::mutable_pakechallengeresponse() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeChallengeResponse)
+  return _internal_mutable_pakechallengeresponse();
+}
+inline const std::string& FullAuthenticationRequestData::_internal_pakechallengeresponse() const {
+  if (_internal_has_pakechallengeresponse()) {
+    return requestBytes_.pakechallengeresponse_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullAuthenticationRequestData::_internal_set_pakechallengeresponse(const std::string& value) {
+  if (!_internal_has_pakechallengeresponse()) {
+    clear_requestBytes();
+    set_has_pakechallengeresponse();
+    requestBytes_.pakechallengeresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakechallengeresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationRequestData::set_pakechallengeresponse(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeChallengeResponse)
+  if (!_internal_has_pakechallengeresponse()) {
+    clear_requestBytes();
+    set_has_pakechallengeresponse();
+    requestBytes_.pakechallengeresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakechallengeresponse_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.pakeChallengeResponse)
+}
+inline void FullAuthenticationRequestData::set_pakechallengeresponse(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_pakechallengeresponse()) {
+    clear_requestBytes();
+    set_has_pakechallengeresponse();
+    requestBytes_.pakechallengeresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakechallengeresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.pakeChallengeResponse)
+}
+inline void FullAuthenticationRequestData::set_pakechallengeresponse(const void* value,
+                             size_t size) {
+  if (!_internal_has_pakechallengeresponse()) {
+    clear_requestBytes();
+    set_has_pakechallengeresponse();
+    requestBytes_.pakechallengeresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.pakechallengeresponse_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.pakeChallengeResponse)
+}
+inline std::string* FullAuthenticationRequestData::_internal_mutable_pakechallengeresponse() {
+  if (!_internal_has_pakechallengeresponse()) {
+    clear_requestBytes();
+    set_has_pakechallengeresponse();
+    requestBytes_.pakechallengeresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return requestBytes_.pakechallengeresponse_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationRequestData::release_pakechallengeresponse() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeChallengeResponse)
+  if (_internal_has_pakechallengeresponse()) {
+    clear_has_requestBytes();
+    return requestBytes_.pakechallengeresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void FullAuthenticationRequestData::set_allocated_pakechallengeresponse(std::string* pakechallengeresponse) {
+  if (has_requestBytes()) {
+    clear_requestBytes();
+  }
+  if (pakechallengeresponse != nullptr) {
+    set_has_pakechallengeresponse();
+    requestBytes_.pakechallengeresponse_.UnsafeSetDefault(pakechallengeresponse);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(pakechallengeresponse);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeChallengeResponse)
+}
+
+// bytes walletAuthenticationRequest = 6;
+inline bool FullAuthenticationRequestData::_internal_has_walletauthenticationrequest() const {
+  return requestBytes_case() == kWalletAuthenticationRequest;
+}
+inline bool FullAuthenticationRequestData::has_walletauthenticationrequest() const {
+  return _internal_has_walletauthenticationrequest();
+}
+inline void FullAuthenticationRequestData::set_has_walletauthenticationrequest() {
+  _oneof_case_[0] = kWalletAuthenticationRequest;
+}
+inline void FullAuthenticationRequestData::clear_walletauthenticationrequest() {
+  if (_internal_has_walletauthenticationrequest()) {
+    requestBytes_.walletauthenticationrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_requestBytes();
+  }
+}
+inline const std::string& FullAuthenticationRequestData::walletauthenticationrequest() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
+  return _internal_walletauthenticationrequest();
+}
+inline void FullAuthenticationRequestData::set_walletauthenticationrequest(const std::string& value) {
+  _internal_set_walletauthenticationrequest(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
+}
+inline std::string* FullAuthenticationRequestData::mutable_walletauthenticationrequest() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
+  return _internal_mutable_walletauthenticationrequest();
+}
+inline const std::string& FullAuthenticationRequestData::_internal_walletauthenticationrequest() const {
+  if (_internal_has_walletauthenticationrequest()) {
+    return requestBytes_.walletauthenticationrequest_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullAuthenticationRequestData::_internal_set_walletauthenticationrequest(const std::string& value) {
+  if (!_internal_has_walletauthenticationrequest()) {
+    clear_requestBytes();
+    set_has_walletauthenticationrequest();
+    requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.walletauthenticationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationRequestData::set_walletauthenticationrequest(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
+  if (!_internal_has_walletauthenticationrequest()) {
+    clear_requestBytes();
+    set_has_walletauthenticationrequest();
+    requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.walletauthenticationrequest_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
+}
+inline void FullAuthenticationRequestData::set_walletauthenticationrequest(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_walletauthenticationrequest()) {
+    clear_requestBytes();
+    set_has_walletauthenticationrequest();
+    requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.walletauthenticationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
+}
+inline void FullAuthenticationRequestData::set_walletauthenticationrequest(const void* value,
+                             size_t size) {
+  if (!_internal_has_walletauthenticationrequest()) {
+    clear_requestBytes();
+    set_has_walletauthenticationrequest();
+    requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  requestBytes_.walletauthenticationrequest_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
+}
+inline std::string* FullAuthenticationRequestData::_internal_mutable_walletauthenticationrequest() {
+  if (!_internal_has_walletauthenticationrequest()) {
+    clear_requestBytes();
+    set_has_walletauthenticationrequest();
+    requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return requestBytes_.walletauthenticationrequest_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationRequestData::release_walletauthenticationrequest() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
+  if (_internal_has_walletauthenticationrequest()) {
+    clear_has_requestBytes();
+    return requestBytes_.walletauthenticationrequest_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void FullAuthenticationRequestData::set_allocated_walletauthenticationrequest(std::string* walletauthenticationrequest) {
+  if (has_requestBytes()) {
+    clear_requestBytes();
+  }
+  if (walletauthenticationrequest != nullptr) {
+    set_has_walletauthenticationrequest();
+    requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(walletauthenticationrequest);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(walletauthenticationrequest);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
+}
+
+// string userID = 7;
+inline void FullAuthenticationRequestData::clear_userid() {
+  userid_.ClearToEmpty();
+}
+inline const std::string& FullAuthenticationRequestData::userid() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.userID)
+  return _internal_userid();
+}
+inline void FullAuthenticationRequestData::set_userid(const std::string& value) {
+  _internal_set_userid(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.userID)
+}
+inline std::string* FullAuthenticationRequestData::mutable_userid() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.userID)
+  return _internal_mutable_userid();
+}
+inline const std::string& FullAuthenticationRequestData::_internal_userid() const {
+  return userid_.Get();
+}
+inline void FullAuthenticationRequestData::_internal_set_userid(const std::string& value) {
+  
+  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationRequestData::set_userid(std::string&& value) {
+  
+  userid_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.userID)
+}
+inline void FullAuthenticationRequestData::set_userid(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.userID)
+}
+inline void FullAuthenticationRequestData::set_userid(const char* value,
+    size_t size) {
+  
+  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.userID)
+}
+inline std::string* FullAuthenticationRequestData::_internal_mutable_userid() {
+  
+  return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationRequestData::release_userid() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.userID)
+  return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void FullAuthenticationRequestData::set_allocated_userid(std::string* userid) {
+  if (userid != nullptr) {
+    
+  } else {
+    
+  }
+  userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.userID)
+}
+
+inline bool FullAuthenticationRequestData::has_requestBytes() const {
+  return requestBytes_case() != REQUESTBYTES_NOT_SET;
+}
+inline void FullAuthenticationRequestData::clear_has_requestBytes() {
+  _oneof_case_[0] = REQUESTBYTES_NOT_SET;
+}
+inline FullAuthenticationRequestData::RequestBytesCase FullAuthenticationRequestData::requestBytes_case() const {
+  return FullAuthenticationRequestData::RequestBytesCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// FullAuthenticationResponseData
+
+// bytes pakeRegistrationResponse = 1;
+inline bool FullAuthenticationResponseData::_internal_has_pakeregistrationresponse() const {
+  return responseData_case() == kPakeRegistrationResponse;
+}
+inline bool FullAuthenticationResponseData::has_pakeregistrationresponse() const {
+  return _internal_has_pakeregistrationresponse();
+}
+inline void FullAuthenticationResponseData::set_has_pakeregistrationresponse() {
+  _oneof_case_[0] = kPakeRegistrationResponse;
+}
+inline void FullAuthenticationResponseData::clear_pakeregistrationresponse() {
+  if (_internal_has_pakeregistrationresponse()) {
+    responseData_.pakeregistrationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_responseData();
+  }
+}
+inline const std::string& FullAuthenticationResponseData::pakeregistrationresponse() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
+  return _internal_pakeregistrationresponse();
+}
+inline void FullAuthenticationResponseData::set_pakeregistrationresponse(const std::string& value) {
+  _internal_set_pakeregistrationresponse(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
+}
+inline std::string* FullAuthenticationResponseData::mutable_pakeregistrationresponse() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
+  return _internal_mutable_pakeregistrationresponse();
+}
+inline const std::string& FullAuthenticationResponseData::_internal_pakeregistrationresponse() const {
+  if (_internal_has_pakeregistrationresponse()) {
+    return responseData_.pakeregistrationresponse_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullAuthenticationResponseData::_internal_set_pakeregistrationresponse(const std::string& value) {
+  if (!_internal_has_pakeregistrationresponse()) {
+    clear_responseData();
+    set_has_pakeregistrationresponse();
+    responseData_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakeregistrationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationResponseData::set_pakeregistrationresponse(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
+  if (!_internal_has_pakeregistrationresponse()) {
+    clear_responseData();
+    set_has_pakeregistrationresponse();
+    responseData_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakeregistrationresponse_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
+}
+inline void FullAuthenticationResponseData::set_pakeregistrationresponse(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_pakeregistrationresponse()) {
+    clear_responseData();
+    set_has_pakeregistrationresponse();
+    responseData_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakeregistrationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
+}
+inline void FullAuthenticationResponseData::set_pakeregistrationresponse(const void* value,
+                             size_t size) {
+  if (!_internal_has_pakeregistrationresponse()) {
+    clear_responseData();
+    set_has_pakeregistrationresponse();
+    responseData_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakeregistrationresponse_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
+}
+inline std::string* FullAuthenticationResponseData::_internal_mutable_pakeregistrationresponse() {
+  if (!_internal_has_pakeregistrationresponse()) {
+    clear_responseData();
+    set_has_pakeregistrationresponse();
+    responseData_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return responseData_.pakeregistrationresponse_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationResponseData::release_pakeregistrationresponse() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
+  if (_internal_has_pakeregistrationresponse()) {
+    clear_has_responseData();
+    return responseData_.pakeregistrationresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void FullAuthenticationResponseData::set_allocated_pakeregistrationresponse(std::string* pakeregistrationresponse) {
+  if (has_responseData()) {
+    clear_responseData();
+  }
+  if (pakeregistrationresponse != nullptr) {
+    set_has_pakeregistrationresponse();
+    responseData_.pakeregistrationresponse_.UnsafeSetDefault(pakeregistrationresponse);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(pakeregistrationresponse);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
+}
+
+// bool pakeRegistrationSuccess = 2;
+inline bool FullAuthenticationResponseData::_internal_has_pakeregistrationsuccess() const {
+  return responseData_case() == kPakeRegistrationSuccess;
+}
+inline bool FullAuthenticationResponseData::has_pakeregistrationsuccess() const {
+  return _internal_has_pakeregistrationsuccess();
+}
+inline void FullAuthenticationResponseData::set_has_pakeregistrationsuccess() {
+  _oneof_case_[0] = kPakeRegistrationSuccess;
+}
+inline void FullAuthenticationResponseData::clear_pakeregistrationsuccess() {
+  if (_internal_has_pakeregistrationsuccess()) {
+    responseData_.pakeregistrationsuccess_ = false;
+    clear_has_responseData();
+  }
+}
+inline bool FullAuthenticationResponseData::_internal_pakeregistrationsuccess() const {
+  if (_internal_has_pakeregistrationsuccess()) {
+    return responseData_.pakeregistrationsuccess_;
+  }
+  return false;
+}
+inline void FullAuthenticationResponseData::_internal_set_pakeregistrationsuccess(bool value) {
+  if (!_internal_has_pakeregistrationsuccess()) {
+    clear_responseData();
+    set_has_pakeregistrationsuccess();
+  }
+  responseData_.pakeregistrationsuccess_ = value;
+}
+inline bool FullAuthenticationResponseData::pakeregistrationsuccess() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.pakeRegistrationSuccess)
+  return _internal_pakeregistrationsuccess();
+}
+inline void FullAuthenticationResponseData::set_pakeregistrationsuccess(bool value) {
+  _internal_set_pakeregistrationsuccess(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeRegistrationSuccess)
+}
+
+// bytes pakeCredentialResponse = 3;
+inline bool FullAuthenticationResponseData::_internal_has_pakecredentialresponse() const {
+  return responseData_case() == kPakeCredentialResponse;
+}
+inline bool FullAuthenticationResponseData::has_pakecredentialresponse() const {
+  return _internal_has_pakecredentialresponse();
+}
+inline void FullAuthenticationResponseData::set_has_pakecredentialresponse() {
+  _oneof_case_[0] = kPakeCredentialResponse;
+}
+inline void FullAuthenticationResponseData::clear_pakecredentialresponse() {
+  if (_internal_has_pakecredentialresponse()) {
+    responseData_.pakecredentialresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_responseData();
+  }
+}
+inline const std::string& FullAuthenticationResponseData::pakecredentialresponse() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.pakeCredentialResponse)
+  return _internal_pakecredentialresponse();
+}
+inline void FullAuthenticationResponseData::set_pakecredentialresponse(const std::string& value) {
+  _internal_set_pakecredentialresponse(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeCredentialResponse)
+}
+inline std::string* FullAuthenticationResponseData::mutable_pakecredentialresponse() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationResponseData.pakeCredentialResponse)
+  return _internal_mutable_pakecredentialresponse();
+}
+inline const std::string& FullAuthenticationResponseData::_internal_pakecredentialresponse() const {
+  if (_internal_has_pakecredentialresponse()) {
+    return responseData_.pakecredentialresponse_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullAuthenticationResponseData::_internal_set_pakecredentialresponse(const std::string& value) {
+  if (!_internal_has_pakecredentialresponse()) {
+    clear_responseData();
+    set_has_pakecredentialresponse();
+    responseData_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakecredentialresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationResponseData::set_pakecredentialresponse(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeCredentialResponse)
+  if (!_internal_has_pakecredentialresponse()) {
+    clear_responseData();
+    set_has_pakecredentialresponse();
+    responseData_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakecredentialresponse_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationResponseData.pakeCredentialResponse)
+}
+inline void FullAuthenticationResponseData::set_pakecredentialresponse(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_pakecredentialresponse()) {
+    clear_responseData();
+    set_has_pakecredentialresponse();
+    responseData_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakecredentialresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationResponseData.pakeCredentialResponse)
+}
+inline void FullAuthenticationResponseData::set_pakecredentialresponse(const void* value,
+                             size_t size) {
+  if (!_internal_has_pakecredentialresponse()) {
+    clear_responseData();
+    set_has_pakecredentialresponse();
+    responseData_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakecredentialresponse_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationResponseData.pakeCredentialResponse)
+}
+inline std::string* FullAuthenticationResponseData::_internal_mutable_pakecredentialresponse() {
+  if (!_internal_has_pakecredentialresponse()) {
+    clear_responseData();
+    set_has_pakecredentialresponse();
+    responseData_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return responseData_.pakecredentialresponse_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationResponseData::release_pakecredentialresponse() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationResponseData.pakeCredentialResponse)
+  if (_internal_has_pakecredentialresponse()) {
+    clear_has_responseData();
+    return responseData_.pakecredentialresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void FullAuthenticationResponseData::set_allocated_pakecredentialresponse(std::string* pakecredentialresponse) {
+  if (has_responseData()) {
+    clear_responseData();
+  }
+  if (pakecredentialresponse != nullptr) {
+    set_has_pakecredentialresponse();
+    responseData_.pakecredentialresponse_.UnsafeSetDefault(pakecredentialresponse);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(pakecredentialresponse);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationResponseData.pakeCredentialResponse)
+}
+
+// bytes pakeChallengeMessage = 4;
+inline bool FullAuthenticationResponseData::_internal_has_pakechallengemessage() const {
+  return responseData_case() == kPakeChallengeMessage;
+}
+inline bool FullAuthenticationResponseData::has_pakechallengemessage() const {
+  return _internal_has_pakechallengemessage();
+}
+inline void FullAuthenticationResponseData::set_has_pakechallengemessage() {
+  _oneof_case_[0] = kPakeChallengeMessage;
+}
+inline void FullAuthenticationResponseData::clear_pakechallengemessage() {
+  if (_internal_has_pakechallengemessage()) {
+    responseData_.pakechallengemessage_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_responseData();
+  }
+}
+inline const std::string& FullAuthenticationResponseData::pakechallengemessage() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.pakeChallengeMessage)
+  return _internal_pakechallengemessage();
+}
+inline void FullAuthenticationResponseData::set_pakechallengemessage(const std::string& value) {
+  _internal_set_pakechallengemessage(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeChallengeMessage)
+}
+inline std::string* FullAuthenticationResponseData::mutable_pakechallengemessage() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationResponseData.pakeChallengeMessage)
+  return _internal_mutable_pakechallengemessage();
+}
+inline const std::string& FullAuthenticationResponseData::_internal_pakechallengemessage() const {
+  if (_internal_has_pakechallengemessage()) {
+    return responseData_.pakechallengemessage_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullAuthenticationResponseData::_internal_set_pakechallengemessage(const std::string& value) {
+  if (!_internal_has_pakechallengemessage()) {
+    clear_responseData();
+    set_has_pakechallengemessage();
+    responseData_.pakechallengemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakechallengemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationResponseData::set_pakechallengemessage(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeChallengeMessage)
+  if (!_internal_has_pakechallengemessage()) {
+    clear_responseData();
+    set_has_pakechallengemessage();
+    responseData_.pakechallengemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakechallengemessage_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationResponseData.pakeChallengeMessage)
+}
+inline void FullAuthenticationResponseData::set_pakechallengemessage(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_pakechallengemessage()) {
+    clear_responseData();
+    set_has_pakechallengemessage();
+    responseData_.pakechallengemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakechallengemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationResponseData.pakeChallengeMessage)
+}
+inline void FullAuthenticationResponseData::set_pakechallengemessage(const void* value,
+                             size_t size) {
+  if (!_internal_has_pakechallengemessage()) {
+    clear_responseData();
+    set_has_pakechallengemessage();
+    responseData_.pakechallengemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.pakechallengemessage_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationResponseData.pakeChallengeMessage)
+}
+inline std::string* FullAuthenticationResponseData::_internal_mutable_pakechallengemessage() {
+  if (!_internal_has_pakechallengemessage()) {
+    clear_responseData();
+    set_has_pakechallengemessage();
+    responseData_.pakechallengemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return responseData_.pakechallengemessage_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationResponseData::release_pakechallengemessage() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationResponseData.pakeChallengeMessage)
+  if (_internal_has_pakechallengemessage()) {
+    clear_has_responseData();
+    return responseData_.pakechallengemessage_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void FullAuthenticationResponseData::set_allocated_pakechallengemessage(std::string* pakechallengemessage) {
+  if (has_responseData()) {
+    clear_responseData();
+  }
+  if (pakechallengemessage != nullptr) {
+    set_has_pakechallengemessage();
+    responseData_.pakechallengemessage_.UnsafeSetDefault(pakechallengemessage);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(pakechallengemessage);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationResponseData.pakeChallengeMessage)
+}
+
+// bytes walletAuthenticationResponse = 5;
+inline bool FullAuthenticationResponseData::_internal_has_walletauthenticationresponse() const {
+  return responseData_case() == kWalletAuthenticationResponse;
+}
+inline bool FullAuthenticationResponseData::has_walletauthenticationresponse() const {
+  return _internal_has_walletauthenticationresponse();
+}
+inline void FullAuthenticationResponseData::set_has_walletauthenticationresponse() {
+  _oneof_case_[0] = kWalletAuthenticationResponse;
+}
+inline void FullAuthenticationResponseData::clear_walletauthenticationresponse() {
+  if (_internal_has_walletauthenticationresponse()) {
+    responseData_.walletauthenticationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_responseData();
+  }
+}
+inline const std::string& FullAuthenticationResponseData::walletauthenticationresponse() const {
+  // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
+  return _internal_walletauthenticationresponse();
+}
+inline void FullAuthenticationResponseData::set_walletauthenticationresponse(const std::string& value) {
+  _internal_set_walletauthenticationresponse(value);
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
+}
+inline std::string* FullAuthenticationResponseData::mutable_walletauthenticationresponse() {
+  // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
+  return _internal_mutable_walletauthenticationresponse();
+}
+inline const std::string& FullAuthenticationResponseData::_internal_walletauthenticationresponse() const {
+  if (_internal_has_walletauthenticationresponse()) {
+    return responseData_.walletauthenticationresponse_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullAuthenticationResponseData::_internal_set_walletauthenticationresponse(const std::string& value) {
+  if (!_internal_has_walletauthenticationresponse()) {
+    clear_responseData();
+    set_has_walletauthenticationresponse();
+    responseData_.walletauthenticationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.walletauthenticationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void FullAuthenticationResponseData::set_walletauthenticationresponse(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
+  if (!_internal_has_walletauthenticationresponse()) {
+    clear_responseData();
+    set_has_walletauthenticationresponse();
+    responseData_.walletauthenticationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.walletauthenticationresponse_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
+}
+inline void FullAuthenticationResponseData::set_walletauthenticationresponse(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_walletauthenticationresponse()) {
+    clear_responseData();
+    set_has_walletauthenticationresponse();
+    responseData_.walletauthenticationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.walletauthenticationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
+}
+inline void FullAuthenticationResponseData::set_walletauthenticationresponse(const void* value,
+                             size_t size) {
+  if (!_internal_has_walletauthenticationresponse()) {
+    clear_responseData();
+    set_has_walletauthenticationresponse();
+    responseData_.walletauthenticationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  responseData_.walletauthenticationresponse_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
+}
+inline std::string* FullAuthenticationResponseData::_internal_mutable_walletauthenticationresponse() {
+  if (!_internal_has_walletauthenticationresponse()) {
+    clear_responseData();
+    set_has_walletauthenticationresponse();
+    responseData_.walletauthenticationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return responseData_.walletauthenticationresponse_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* FullAuthenticationResponseData::release_walletauthenticationresponse() {
+  // @@protoc_insertion_point(field_release:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
+  if (_internal_has_walletauthenticationresponse()) {
+    clear_has_responseData();
+    return responseData_.walletauthenticationresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void FullAuthenticationResponseData::set_allocated_walletauthenticationresponse(std::string* walletauthenticationresponse) {
+  if (has_responseData()) {
+    clear_responseData();
+  }
+  if (walletauthenticationresponse != nullptr) {
+    set_has_walletauthenticationresponse();
+    responseData_.walletauthenticationresponse_.UnsafeSetDefault(walletauthenticationresponse);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(walletauthenticationresponse);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
+}
+
+inline bool FullAuthenticationResponseData::has_responseData() const {
+  return responseData_case() != RESPONSEDATA_NOT_SET;
+}
+inline void FullAuthenticationResponseData::clear_has_responseData() {
+  _oneof_case_[0] = RESPONSEDATA_NOT_SET;
+}
+inline FullAuthenticationResponseData::ResponseDataCase FullAuthenticationResponseData::responseData_case() const {
+  return FullAuthenticationResponseData::ResponseDataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// SimpleAuthenticationRequestData
+
+// string backupID = 1;
+inline void SimpleAuthenticationRequestData::clear_backupid() {
+  backupid_.ClearToEmpty();
+}
+inline const std::string& SimpleAuthenticationRequestData::backupid() const {
+  // @@protoc_insertion_point(field_get:backup.SimpleAuthenticationRequestData.backupID)
+  return _internal_backupid();
+}
+inline void SimpleAuthenticationRequestData::set_backupid(const std::string& value) {
+  _internal_set_backupid(value);
+  // @@protoc_insertion_point(field_set:backup.SimpleAuthenticationRequestData.backupID)
+}
+inline std::string* SimpleAuthenticationRequestData::mutable_backupid() {
+  // @@protoc_insertion_point(field_mutable:backup.SimpleAuthenticationRequestData.backupID)
+  return _internal_mutable_backupid();
+}
+inline const std::string& SimpleAuthenticationRequestData::_internal_backupid() const {
+  return backupid_.Get();
+}
+inline void SimpleAuthenticationRequestData::_internal_set_backupid(const std::string& value) {
+  
+  backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void SimpleAuthenticationRequestData::set_backupid(std::string&& value) {
+  
+  backupid_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.SimpleAuthenticationRequestData.backupID)
+}
+inline void SimpleAuthenticationRequestData::set_backupid(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.SimpleAuthenticationRequestData.backupID)
 }
-inline void ResetKeyRequest::_internal_set_userid(const std::string& value) {
+inline void SimpleAuthenticationRequestData::set_backupid(const char* value,
+    size_t size) {
+  
+  backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.SimpleAuthenticationRequestData.backupID)
+}
+inline std::string* SimpleAuthenticationRequestData::_internal_mutable_backupid() {
+  
+  return backupid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* SimpleAuthenticationRequestData::release_backupid() {
+  // @@protoc_insertion_point(field_release:backup.SimpleAuthenticationRequestData.backupID)
+  return backupid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void SimpleAuthenticationRequestData::set_allocated_backupid(std::string* backupid) {
+  if (backupid != nullptr) {
+    
+  } else {
+    
+  }
+  backupid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), backupid,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:backup.SimpleAuthenticationRequestData.backupID)
+}
+
+// string userID = 2;
+inline void SimpleAuthenticationRequestData::clear_userid() {
+  userid_.ClearToEmpty();
+}
+inline const std::string& SimpleAuthenticationRequestData::userid() const {
+  // @@protoc_insertion_point(field_get:backup.SimpleAuthenticationRequestData.userID)
+  return _internal_userid();
+}
+inline void SimpleAuthenticationRequestData::set_userid(const std::string& value) {
+  _internal_set_userid(value);
+  // @@protoc_insertion_point(field_set:backup.SimpleAuthenticationRequestData.userID)
+}
+inline std::string* SimpleAuthenticationRequestData::mutable_userid() {
+  // @@protoc_insertion_point(field_mutable:backup.SimpleAuthenticationRequestData.userID)
+  return _internal_mutable_userid();
+}
+inline const std::string& SimpleAuthenticationRequestData::_internal_userid() const {
+  return userid_.Get();
+}
+inline void SimpleAuthenticationRequestData::_internal_set_userid(const std::string& value) {
   
   userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void ResetKeyRequest::set_userid(std::string&& value) {
+inline void SimpleAuthenticationRequestData::set_userid(std::string&& value) {
   
   userid_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.userId)
+  // @@protoc_insertion_point(field_set_rvalue:backup.SimpleAuthenticationRequestData.userID)
 }
-inline void ResetKeyRequest::set_userid(const char* value) {
+inline void SimpleAuthenticationRequestData::set_userid(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
   userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.userId)
+  // @@protoc_insertion_point(field_set_char:backup.SimpleAuthenticationRequestData.userID)
 }
-inline void ResetKeyRequest::set_userid(const char* value,
+inline void SimpleAuthenticationRequestData::set_userid(const char* value,
     size_t size) {
   
   userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.userId)
+  // @@protoc_insertion_point(field_set_pointer:backup.SimpleAuthenticationRequestData.userID)
 }
-inline std::string* ResetKeyRequest::_internal_mutable_userid() {
+inline std::string* SimpleAuthenticationRequestData::_internal_mutable_userid() {
   
   return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* ResetKeyRequest::release_userid() {
-  // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.userId)
+inline std::string* SimpleAuthenticationRequestData::release_userid() {
+  // @@protoc_insertion_point(field_release:backup.SimpleAuthenticationRequestData.userID)
   return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void ResetKeyRequest::set_allocated_userid(std::string* userid) {
+inline void SimpleAuthenticationRequestData::set_allocated_userid(std::string* userid) {
   if (userid != nullptr) {
     
   } else {
@@ -1180,720 +3618,1337 @@
   }
   userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.userId)
+  // @@protoc_insertion_point(field_set_allocated:backup.SimpleAuthenticationRequestData.userID)
 }
 
-// bytes newKey = 2;
-inline bool ResetKeyRequest::_internal_has_newkey() const {
-  return data_case() == kNewKey;
+// -------------------------------------------------------------------
+
+// AuthenticationInformationData
+
+// bytes nonce = 1;
+inline bool AuthenticationInformationData::_internal_has_nonce() const {
+  return data_case() == kNonce;
 }
-inline bool ResetKeyRequest::has_newkey() const {
-  return _internal_has_newkey();
+inline bool AuthenticationInformationData::has_nonce() const {
+  return _internal_has_nonce();
 }
-inline void ResetKeyRequest::set_has_newkey() {
-  _oneof_case_[0] = kNewKey;
+inline void AuthenticationInformationData::set_has_nonce() {
+  _oneof_case_[0] = kNonce;
 }
-inline void ResetKeyRequest::clear_newkey() {
-  if (_internal_has_newkey()) {
-    data_.newkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline void AuthenticationInformationData::clear_nonce() {
+  if (_internal_has_nonce()) {
+    data_.nonce_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
     clear_has_data();
   }
 }
-inline const std::string& ResetKeyRequest::newkey() const {
-  // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.newKey)
-  return _internal_newkey();
+inline const std::string& AuthenticationInformationData::nonce() const {
+  // @@protoc_insertion_point(field_get:backup.AuthenticationInformationData.nonce)
+  return _internal_nonce();
 }
-inline void ResetKeyRequest::set_newkey(const std::string& value) {
-  _internal_set_newkey(value);
-  // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.newKey)
+inline void AuthenticationInformationData::set_nonce(const std::string& value) {
+  _internal_set_nonce(value);
+  // @@protoc_insertion_point(field_set:backup.AuthenticationInformationData.nonce)
 }
-inline std::string* ResetKeyRequest::mutable_newkey() {
-  // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.newKey)
-  return _internal_mutable_newkey();
+inline std::string* AuthenticationInformationData::mutable_nonce() {
+  // @@protoc_insertion_point(field_mutable:backup.AuthenticationInformationData.nonce)
+  return _internal_mutable_nonce();
 }
-inline const std::string& ResetKeyRequest::_internal_newkey() const {
-  if (_internal_has_newkey()) {
-    return data_.newkey_.Get();
+inline const std::string& AuthenticationInformationData::_internal_nonce() const {
+  if (_internal_has_nonce()) {
+    return data_.nonce_.Get();
   }
   return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
 }
-inline void ResetKeyRequest::_internal_set_newkey(const std::string& value) {
-  if (!_internal_has_newkey()) {
+inline void AuthenticationInformationData::_internal_set_nonce(const std::string& value) {
+  if (!_internal_has_nonce()) {
     clear_data();
-    set_has_newkey();
-    data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    set_has_nonce();
+    data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   }
-  data_.newkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  data_.nonce_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void ResetKeyRequest::set_newkey(std::string&& value) {
-  // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.newKey)
-  if (!_internal_has_newkey()) {
+inline void AuthenticationInformationData::set_nonce(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.AuthenticationInformationData.nonce)
+  if (!_internal_has_nonce()) {
     clear_data();
-    set_has_newkey();
-    data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    set_has_nonce();
+    data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   }
-  data_.newkey_.Set(
+  data_.nonce_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.newKey)
+  // @@protoc_insertion_point(field_set_rvalue:backup.AuthenticationInformationData.nonce)
 }
-inline void ResetKeyRequest::set_newkey(const char* value) {
+inline void AuthenticationInformationData::set_nonce(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
-  if (!_internal_has_newkey()) {
+  if (!_internal_has_nonce()) {
     clear_data();
-    set_has_newkey();
-    data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    set_has_nonce();
+    data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   }
-  data_.newkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+  data_.nonce_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
       ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.newKey)
+  // @@protoc_insertion_point(field_set_char:backup.AuthenticationInformationData.nonce)
 }
-inline void ResetKeyRequest::set_newkey(const void* value,
+inline void AuthenticationInformationData::set_nonce(const void* value,
                              size_t size) {
-  if (!_internal_has_newkey()) {
+  if (!_internal_has_nonce()) {
     clear_data();
-    set_has_newkey();
-    data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    set_has_nonce();
+    data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   }
-  data_.newkey_.Set(
+  data_.nonce_.Set(
       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size),
       GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.newKey)
+  // @@protoc_insertion_point(field_set_pointer:backup.AuthenticationInformationData.nonce)
 }
-inline std::string* ResetKeyRequest::_internal_mutable_newkey() {
-  if (!_internal_has_newkey()) {
+inline std::string* AuthenticationInformationData::_internal_mutable_nonce() {
+  if (!_internal_has_nonce()) {
     clear_data();
-    set_has_newkey();
-    data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    set_has_nonce();
+    data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   }
-  return data_.newkey_.Mutable(
+  return data_.nonce_.Mutable(
       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* ResetKeyRequest::release_newkey() {
-  // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.newKey)
-  if (_internal_has_newkey()) {
+inline std::string* AuthenticationInformationData::release_nonce() {
+  // @@protoc_insertion_point(field_release:backup.AuthenticationInformationData.nonce)
+  if (_internal_has_nonce()) {
     clear_has_data();
-    return data_.newkey_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+    return data_.nonce_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
   } else {
     return nullptr;
   }
 }
-inline void ResetKeyRequest::set_allocated_newkey(std::string* newkey) {
+inline void AuthenticationInformationData::set_allocated_nonce(std::string* nonce) {
   if (has_data()) {
     clear_data();
   }
-  if (newkey != nullptr) {
-    set_has_newkey();
-    data_.newkey_.UnsafeSetDefault(newkey);
+  if (nonce != nullptr) {
+    set_has_nonce();
+    data_.nonce_.UnsafeSetDefault(nonce);
     ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
     if (arena != nullptr) {
-      arena->Own(newkey);
+      arena->Own(nonce);
     }
   }
-  // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.newKey)
+  // @@protoc_insertion_point(field_set_allocated:backup.AuthenticationInformationData.nonce)
 }
 
-// bytes compactionChunk = 3;
-inline bool ResetKeyRequest::_internal_has_compactionchunk() const {
-  return data_case() == kCompactionChunk;
+// bytes rawMessage = 2;
+inline bool AuthenticationInformationData::_internal_has_rawmessage() const {
+  return data_case() == kRawMessage;
 }
-inline bool ResetKeyRequest::has_compactionchunk() const {
-  return _internal_has_compactionchunk();
+inline bool AuthenticationInformationData::has_rawmessage() const {
+  return _internal_has_rawmessage();
+}
+inline void AuthenticationInformationData::set_has_rawmessage() {
+  _oneof_case_[0] = kRawMessage;
+}
+inline void AuthenticationInformationData::clear_rawmessage() {
+  if (_internal_has_rawmessage()) {
+    data_.rawmessage_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_data();
+  }
+}
+inline const std::string& AuthenticationInformationData::rawmessage() const {
+  // @@protoc_insertion_point(field_get:backup.AuthenticationInformationData.rawMessage)
+  return _internal_rawmessage();
+}
+inline void AuthenticationInformationData::set_rawmessage(const std::string& value) {
+  _internal_set_rawmessage(value);
+  // @@protoc_insertion_point(field_set:backup.AuthenticationInformationData.rawMessage)
+}
+inline std::string* AuthenticationInformationData::mutable_rawmessage() {
+  // @@protoc_insertion_point(field_mutable:backup.AuthenticationInformationData.rawMessage)
+  return _internal_mutable_rawmessage();
+}
+inline const std::string& AuthenticationInformationData::_internal_rawmessage() const {
+  if (_internal_has_rawmessage()) {
+    return data_.rawmessage_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void AuthenticationInformationData::_internal_set_rawmessage(const std::string& value) {
+  if (!_internal_has_rawmessage()) {
+    clear_data();
+    set_has_rawmessage();
+    data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.rawmessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void AuthenticationInformationData::set_rawmessage(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.AuthenticationInformationData.rawMessage)
+  if (!_internal_has_rawmessage()) {
+    clear_data();
+    set_has_rawmessage();
+    data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.rawmessage_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.AuthenticationInformationData.rawMessage)
+}
+inline void AuthenticationInformationData::set_rawmessage(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_rawmessage()) {
+    clear_data();
+    set_has_rawmessage();
+    data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.rawmessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.AuthenticationInformationData.rawMessage)
+}
+inline void AuthenticationInformationData::set_rawmessage(const void* value,
+                             size_t size) {
+  if (!_internal_has_rawmessage()) {
+    clear_data();
+    set_has_rawmessage();
+    data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.rawmessage_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.AuthenticationInformationData.rawMessage)
+}
+inline std::string* AuthenticationInformationData::_internal_mutable_rawmessage() {
+  if (!_internal_has_rawmessage()) {
+    clear_data();
+    set_has_rawmessage();
+    data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return data_.rawmessage_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* AuthenticationInformationData::release_rawmessage() {
+  // @@protoc_insertion_point(field_release:backup.AuthenticationInformationData.rawMessage)
+  if (_internal_has_rawmessage()) {
+    clear_has_data();
+    return data_.rawmessage_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void AuthenticationInformationData::set_allocated_rawmessage(std::string* rawmessage) {
+  if (has_data()) {
+    clear_data();
+  }
+  if (rawmessage != nullptr) {
+    set_has_rawmessage();
+    data_.rawmessage_.UnsafeSetDefault(rawmessage);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(rawmessage);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.AuthenticationInformationData.rawMessage)
+}
+
+inline bool AuthenticationInformationData::has_data() const {
+  return data_case() != DATA_NOT_SET;
+}
+inline void AuthenticationInformationData::clear_has_data() {
+  _oneof_case_[0] = DATA_NOT_SET;
+}
+inline AuthenticationInformationData::DataCase AuthenticationInformationData::data_case() const {
+  return AuthenticationInformationData::DataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// CreateNewBackupRequest
+
+// .backup.FullAuthenticationRequestData authenticationRequestData = 1;
+inline bool CreateNewBackupRequest::_internal_has_authenticationrequestdata() const {
+  return data_case() == kAuthenticationRequestData;
+}
+inline bool CreateNewBackupRequest::has_authenticationrequestdata() const {
+  return _internal_has_authenticationrequestdata();
+}
+inline void CreateNewBackupRequest::set_has_authenticationrequestdata() {
+  _oneof_case_[0] = kAuthenticationRequestData;
+}
+inline void CreateNewBackupRequest::clear_authenticationrequestdata() {
+  if (_internal_has_authenticationrequestdata()) {
+    if (GetArena() == nullptr) {
+      delete data_.authenticationrequestdata_;
+    }
+    clear_has_data();
+  }
+}
+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::release_authenticationrequestdata() {
+  // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.authenticationRequestData)
+  if (_internal_has_authenticationrequestdata()) {
+    clear_has_data();
+      ::backup::FullAuthenticationRequestData* temp = data_.authenticationrequestdata_;
+    if (GetArena() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    data_.authenticationrequestdata_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::backup::FullAuthenticationRequestData& CreateNewBackupRequest::_internal_authenticationrequestdata() const {
+  return _internal_has_authenticationrequestdata()
+      ? *data_.authenticationrequestdata_
+      : reinterpret_cast< ::backup::FullAuthenticationRequestData&>(::backup::_FullAuthenticationRequestData_default_instance_);
+}
+inline const ::backup::FullAuthenticationRequestData& CreateNewBackupRequest::authenticationrequestdata() const {
+  // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.authenticationRequestData)
+  return _internal_authenticationrequestdata();
+}
+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::unsafe_arena_release_authenticationrequestdata() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:backup.CreateNewBackupRequest.authenticationRequestData)
+  if (_internal_has_authenticationrequestdata()) {
+    clear_has_data();
+    ::backup::FullAuthenticationRequestData* temp = data_.authenticationrequestdata_;
+    data_.authenticationrequestdata_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void CreateNewBackupRequest::unsafe_arena_set_allocated_authenticationrequestdata(::backup::FullAuthenticationRequestData* authenticationrequestdata) {
+  clear_data();
+  if (authenticationrequestdata) {
+    set_has_authenticationrequestdata();
+    data_.authenticationrequestdata_ = authenticationrequestdata;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.CreateNewBackupRequest.authenticationRequestData)
+}
+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::_internal_mutable_authenticationrequestdata() {
+  if (!_internal_has_authenticationrequestdata()) {
+    clear_data();
+    set_has_authenticationrequestdata();
+    data_.authenticationrequestdata_ = CreateMaybeMessage< ::backup::FullAuthenticationRequestData >(GetArena());
+  }
+  return data_.authenticationrequestdata_;
+}
+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::mutable_authenticationrequestdata() {
+  // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.authenticationRequestData)
+  return _internal_mutable_authenticationrequestdata();
+}
+
+// .backup.AuthenticationInformationData authenticationInformationData = 2;
+inline bool CreateNewBackupRequest::_internal_has_authenticationinformationdata() const {
+  return data_case() == kAuthenticationInformationData;
+}
+inline bool CreateNewBackupRequest::has_authenticationinformationdata() const {
+  return _internal_has_authenticationinformationdata();
+}
+inline void CreateNewBackupRequest::set_has_authenticationinformationdata() {
+  _oneof_case_[0] = kAuthenticationInformationData;
+}
+inline void CreateNewBackupRequest::clear_authenticationinformationdata() {
+  if (_internal_has_authenticationinformationdata()) {
+    if (GetArena() == nullptr) {
+      delete data_.authenticationinformationdata_;
+    }
+    clear_has_data();
+  }
+}
+inline ::backup::AuthenticationInformationData* CreateNewBackupRequest::release_authenticationinformationdata() {
+  // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.authenticationInformationData)
+  if (_internal_has_authenticationinformationdata()) {
+    clear_has_data();
+      ::backup::AuthenticationInformationData* temp = data_.authenticationinformationdata_;
+    if (GetArena() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    data_.authenticationinformationdata_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::backup::AuthenticationInformationData& CreateNewBackupRequest::_internal_authenticationinformationdata() const {
+  return _internal_has_authenticationinformationdata()
+      ? *data_.authenticationinformationdata_
+      : reinterpret_cast< ::backup::AuthenticationInformationData&>(::backup::_AuthenticationInformationData_default_instance_);
+}
+inline const ::backup::AuthenticationInformationData& CreateNewBackupRequest::authenticationinformationdata() const {
+  // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.authenticationInformationData)
+  return _internal_authenticationinformationdata();
+}
+inline ::backup::AuthenticationInformationData* CreateNewBackupRequest::unsafe_arena_release_authenticationinformationdata() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:backup.CreateNewBackupRequest.authenticationInformationData)
+  if (_internal_has_authenticationinformationdata()) {
+    clear_has_data();
+    ::backup::AuthenticationInformationData* temp = data_.authenticationinformationdata_;
+    data_.authenticationinformationdata_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void CreateNewBackupRequest::unsafe_arena_set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata) {
+  clear_data();
+  if (authenticationinformationdata) {
+    set_has_authenticationinformationdata();
+    data_.authenticationinformationdata_ = authenticationinformationdata;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.CreateNewBackupRequest.authenticationInformationData)
+}
+inline ::backup::AuthenticationInformationData* CreateNewBackupRequest::_internal_mutable_authenticationinformationdata() {
+  if (!_internal_has_authenticationinformationdata()) {
+    clear_data();
+    set_has_authenticationinformationdata();
+    data_.authenticationinformationdata_ = CreateMaybeMessage< ::backup::AuthenticationInformationData >(GetArena());
+  }
+  return data_.authenticationinformationdata_;
+}
+inline ::backup::AuthenticationInformationData* CreateNewBackupRequest::mutable_authenticationinformationdata() {
+  // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.authenticationInformationData)
+  return _internal_mutable_authenticationinformationdata();
+}
+
+// bytes newCompactionChunk = 3;
+inline bool CreateNewBackupRequest::_internal_has_newcompactionchunk() const {
+  return data_case() == kNewCompactionChunk;
+}
+inline bool CreateNewBackupRequest::has_newcompactionchunk() const {
+  return _internal_has_newcompactionchunk();
+}
+inline void CreateNewBackupRequest::set_has_newcompactionchunk() {
+  _oneof_case_[0] = kNewCompactionChunk;
+}
+inline void CreateNewBackupRequest::clear_newcompactionchunk() {
+  if (_internal_has_newcompactionchunk()) {
+    data_.newcompactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_data();
+  }
+}
+inline const std::string& CreateNewBackupRequest::newcompactionchunk() const {
+  // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.newCompactionChunk)
+  return _internal_newcompactionchunk();
+}
+inline void CreateNewBackupRequest::set_newcompactionchunk(const std::string& value) {
+  _internal_set_newcompactionchunk(value);
+  // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.newCompactionChunk)
+}
+inline std::string* CreateNewBackupRequest::mutable_newcompactionchunk() {
+  // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.newCompactionChunk)
+  return _internal_mutable_newcompactionchunk();
+}
+inline const std::string& CreateNewBackupRequest::_internal_newcompactionchunk() const {
+  if (_internal_has_newcompactionchunk()) {
+    return data_.newcompactionchunk_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void CreateNewBackupRequest::_internal_set_newcompactionchunk(const std::string& value) {
+  if (!_internal_has_newcompactionchunk()) {
+    clear_data();
+    set_has_newcompactionchunk();
+    data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.newcompactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void CreateNewBackupRequest::set_newcompactionchunk(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.newCompactionChunk)
+  if (!_internal_has_newcompactionchunk()) {
+    clear_data();
+    set_has_newcompactionchunk();
+    data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.newcompactionchunk_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupRequest.newCompactionChunk)
+}
+inline void CreateNewBackupRequest::set_newcompactionchunk(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  if (!_internal_has_newcompactionchunk()) {
+    clear_data();
+    set_has_newcompactionchunk();
+    data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.newcompactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupRequest.newCompactionChunk)
+}
+inline void CreateNewBackupRequest::set_newcompactionchunk(const void* value,
+                             size_t size) {
+  if (!_internal_has_newcompactionchunk()) {
+    clear_data();
+    set_has_newcompactionchunk();
+    data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.newcompactionchunk_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupRequest.newCompactionChunk)
+}
+inline std::string* CreateNewBackupRequest::_internal_mutable_newcompactionchunk() {
+  if (!_internal_has_newcompactionchunk()) {
+    clear_data();
+    set_has_newcompactionchunk();
+    data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return data_.newcompactionchunk_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* CreateNewBackupRequest::release_newcompactionchunk() {
+  // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.newCompactionChunk)
+  if (_internal_has_newcompactionchunk()) {
+    clear_has_data();
+    return data_.newcompactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  } else {
+    return nullptr;
+  }
+}
+inline void CreateNewBackupRequest::set_allocated_newcompactionchunk(std::string* newcompactionchunk) {
+  if (has_data()) {
+    clear_data();
+  }
+  if (newcompactionchunk != nullptr) {
+    set_has_newcompactionchunk();
+    data_.newcompactionchunk_.UnsafeSetDefault(newcompactionchunk);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(newcompactionchunk);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.newCompactionChunk)
+}
+
+inline bool CreateNewBackupRequest::has_data() const {
+  return data_case() != DATA_NOT_SET;
+}
+inline void CreateNewBackupRequest::clear_has_data() {
+  _oneof_case_[0] = DATA_NOT_SET;
+}
+inline CreateNewBackupRequest::DataCase CreateNewBackupRequest::data_case() const {
+  return CreateNewBackupRequest::DataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// CreateNewBackupResponse
+
+// .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+inline bool CreateNewBackupResponse::_internal_has_authenticationresponsedata() const {
+  return data_case() == kAuthenticationResponseData;
+}
+inline bool CreateNewBackupResponse::has_authenticationresponsedata() const {
+  return _internal_has_authenticationresponsedata();
+}
+inline void CreateNewBackupResponse::set_has_authenticationresponsedata() {
+  _oneof_case_[0] = kAuthenticationResponseData;
+}
+inline void CreateNewBackupResponse::clear_authenticationresponsedata() {
+  if (_internal_has_authenticationresponsedata()) {
+    if (GetArena() == nullptr) {
+      delete data_.authenticationresponsedata_;
+    }
+    clear_has_data();
+  }
+}
+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::release_authenticationresponsedata() {
+  // @@protoc_insertion_point(field_release:backup.CreateNewBackupResponse.authenticationResponseData)
+  if (_internal_has_authenticationresponsedata()) {
+    clear_has_data();
+      ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
+    if (GetArena() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    data_.authenticationresponsedata_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::backup::FullAuthenticationResponseData& CreateNewBackupResponse::_internal_authenticationresponsedata() const {
+  return _internal_has_authenticationresponsedata()
+      ? *data_.authenticationresponsedata_
+      : reinterpret_cast< ::backup::FullAuthenticationResponseData&>(::backup::_FullAuthenticationResponseData_default_instance_);
+}
+inline const ::backup::FullAuthenticationResponseData& CreateNewBackupResponse::authenticationresponsedata() const {
+  // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.authenticationResponseData)
+  return _internal_authenticationresponsedata();
+}
+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::unsafe_arena_release_authenticationresponsedata() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:backup.CreateNewBackupResponse.authenticationResponseData)
+  if (_internal_has_authenticationresponsedata()) {
+    clear_has_data();
+    ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
+    data_.authenticationresponsedata_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void CreateNewBackupResponse::unsafe_arena_set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
+  clear_data();
+  if (authenticationresponsedata) {
+    set_has_authenticationresponsedata();
+    data_.authenticationresponsedata_ = authenticationresponsedata;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.CreateNewBackupResponse.authenticationResponseData)
+}
+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::_internal_mutable_authenticationresponsedata() {
+  if (!_internal_has_authenticationresponsedata()) {
+    clear_data();
+    set_has_authenticationresponsedata();
+    data_.authenticationresponsedata_ = CreateMaybeMessage< ::backup::FullAuthenticationResponseData >(GetArena());
+  }
+  return data_.authenticationresponsedata_;
+}
+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::mutable_authenticationresponsedata() {
+  // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupResponse.authenticationResponseData)
+  return _internal_mutable_authenticationresponsedata();
+}
+
+// string backupID = 2;
+inline bool CreateNewBackupResponse::_internal_has_backupid() const {
+  return data_case() == kBackupID;
+}
+inline bool CreateNewBackupResponse::has_backupid() const {
+  return _internal_has_backupid();
 }
-inline void ResetKeyRequest::set_has_compactionchunk() {
-  _oneof_case_[0] = kCompactionChunk;
+inline void CreateNewBackupResponse::set_has_backupid() {
+  _oneof_case_[0] = kBackupID;
 }
-inline void ResetKeyRequest::clear_compactionchunk() {
-  if (_internal_has_compactionchunk()) {
-    data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline void CreateNewBackupResponse::clear_backupid() {
+  if (_internal_has_backupid()) {
+    data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
     clear_has_data();
   }
 }
-inline const std::string& ResetKeyRequest::compactionchunk() const {
-  // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.compactionChunk)
-  return _internal_compactionchunk();
+inline const std::string& CreateNewBackupResponse::backupid() const {
+  // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.backupID)
+  return _internal_backupid();
 }
-inline void ResetKeyRequest::set_compactionchunk(const std::string& value) {
-  _internal_set_compactionchunk(value);
-  // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.compactionChunk)
+inline void CreateNewBackupResponse::set_backupid(const std::string& value) {
+  _internal_set_backupid(value);
+  // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.backupID)
 }
-inline std::string* ResetKeyRequest::mutable_compactionchunk() {
-  // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.compactionChunk)
-  return _internal_mutable_compactionchunk();
+inline std::string* CreateNewBackupResponse::mutable_backupid() {
+  // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupResponse.backupID)
+  return _internal_mutable_backupid();
 }
-inline const std::string& ResetKeyRequest::_internal_compactionchunk() const {
-  if (_internal_has_compactionchunk()) {
-    return data_.compactionchunk_.Get();
+inline const std::string& CreateNewBackupResponse::_internal_backupid() const {
+  if (_internal_has_backupid()) {
+    return data_.backupid_.Get();
   }
   return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
 }
-inline void ResetKeyRequest::_internal_set_compactionchunk(const std::string& value) {
-  if (!_internal_has_compactionchunk()) {
+inline void CreateNewBackupResponse::_internal_set_backupid(const std::string& value) {
+  if (!_internal_has_backupid()) {
     clear_data();
-    set_has_compactionchunk();
-    data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   }
-  data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void ResetKeyRequest::set_compactionchunk(std::string&& value) {
-  // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.compactionChunk)
-  if (!_internal_has_compactionchunk()) {
+inline void CreateNewBackupResponse::set_backupid(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.backupID)
+  if (!_internal_has_backupid()) {
     clear_data();
-    set_has_compactionchunk();
-    data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   }
-  data_.compactionchunk_.Set(
+  data_.backupid_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.compactionChunk)
+  // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupResponse.backupID)
 }
-inline void ResetKeyRequest::set_compactionchunk(const char* value) {
+inline void CreateNewBackupResponse::set_backupid(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
-  if (!_internal_has_compactionchunk()) {
+  if (!_internal_has_backupid()) {
     clear_data();
-    set_has_compactionchunk();
-    data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   }
-  data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+  data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
       ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.compactionChunk)
+  // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupResponse.backupID)
 }
-inline void ResetKeyRequest::set_compactionchunk(const void* value,
+inline void CreateNewBackupResponse::set_backupid(const char* value,
                              size_t size) {
-  if (!_internal_has_compactionchunk()) {
+  if (!_internal_has_backupid()) {
     clear_data();
-    set_has_compactionchunk();
-    data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   }
-  data_.compactionchunk_.Set(
+  data_.backupid_.Set(
       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size),
       GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.compactionChunk)
+  // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupResponse.backupID)
 }
-inline std::string* ResetKeyRequest::_internal_mutable_compactionchunk() {
-  if (!_internal_has_compactionchunk()) {
+inline std::string* CreateNewBackupResponse::_internal_mutable_backupid() {
+  if (!_internal_has_backupid()) {
     clear_data();
-    set_has_compactionchunk();
-    data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   }
-  return data_.compactionchunk_.Mutable(
+  return data_.backupid_.Mutable(
       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* ResetKeyRequest::release_compactionchunk() {
-  // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.compactionChunk)
-  if (_internal_has_compactionchunk()) {
+inline std::string* CreateNewBackupResponse::release_backupid() {
+  // @@protoc_insertion_point(field_release:backup.CreateNewBackupResponse.backupID)
+  if (_internal_has_backupid()) {
     clear_has_data();
-    return data_.compactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+    return data_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
   } else {
     return nullptr;
   }
 }
-inline void ResetKeyRequest::set_allocated_compactionchunk(std::string* compactionchunk) {
+inline void CreateNewBackupResponse::set_allocated_backupid(std::string* backupid) {
   if (has_data()) {
     clear_data();
   }
-  if (compactionchunk != nullptr) {
-    set_has_compactionchunk();
-    data_.compactionchunk_.UnsafeSetDefault(compactionchunk);
+  if (backupid != nullptr) {
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(backupid);
     ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
     if (arena != nullptr) {
-      arena->Own(compactionchunk);
+      arena->Own(backupid);
     }
   }
-  // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.compactionChunk)
+  // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupResponse.backupID)
 }
 
-inline bool ResetKeyRequest::has_data() const {
+inline bool CreateNewBackupResponse::has_data() const {
   return data_case() != DATA_NOT_SET;
 }
-inline void ResetKeyRequest::clear_has_data() {
+inline void CreateNewBackupResponse::clear_has_data() {
   _oneof_case_[0] = DATA_NOT_SET;
 }
-inline ResetKeyRequest::DataCase ResetKeyRequest::data_case() const {
-  return ResetKeyRequest::DataCase(_oneof_case_[0]);
+inline CreateNewBackupResponse::DataCase CreateNewBackupResponse::data_case() const {
+  return CreateNewBackupResponse::DataCase(_oneof_case_[0]);
 }
 // -------------------------------------------------------------------
 
 // SendLogRequest
 
-// string userId = 1;
-inline void SendLogRequest::clear_userid() {
-  userid_.ClearToEmpty();
-}
-inline const std::string& SendLogRequest::userid() const {
-  // @@protoc_insertion_point(field_get:backup.SendLogRequest.userId)
-  return _internal_userid();
+// .backup.SimpleAuthenticationRequestData authenticationData = 1;
+inline bool SendLogRequest::_internal_has_authenticationdata() const {
+  return this != internal_default_instance() && authenticationdata_ != nullptr;
 }
-inline void SendLogRequest::set_userid(const std::string& value) {
-  _internal_set_userid(value);
-  // @@protoc_insertion_point(field_set:backup.SendLogRequest.userId)
+inline bool SendLogRequest::has_authenticationdata() const {
+  return _internal_has_authenticationdata();
 }
-inline std::string* SendLogRequest::mutable_userid() {
-  // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.userId)
-  return _internal_mutable_userid();
+inline void SendLogRequest::clear_authenticationdata() {
+  if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+    delete authenticationdata_;
+  }
+  authenticationdata_ = nullptr;
 }
-inline const std::string& SendLogRequest::_internal_userid() const {
-  return userid_.Get();
+inline const ::backup::SimpleAuthenticationRequestData& SendLogRequest::_internal_authenticationdata() const {
+  const ::backup::SimpleAuthenticationRequestData* p = authenticationdata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::backup::SimpleAuthenticationRequestData&>(
+      ::backup::_SimpleAuthenticationRequestData_default_instance_);
 }
-inline void SendLogRequest::_internal_set_userid(const std::string& value) {
-  
-  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline const ::backup::SimpleAuthenticationRequestData& SendLogRequest::authenticationdata() const {
+  // @@protoc_insertion_point(field_get:backup.SendLogRequest.authenticationData)
+  return _internal_authenticationdata();
 }
-inline void SendLogRequest::set_userid(std::string&& value) {
-  
-  userid_.Set(
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.userId)
+inline void SendLogRequest::unsafe_arena_set_allocated_authenticationdata(
+    ::backup::SimpleAuthenticationRequestData* authenticationdata) {
+  if (GetArena() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_);
+  }
+  authenticationdata_ = authenticationdata;
+  if (authenticationdata) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.SendLogRequest.authenticationData)
 }
-inline void SendLogRequest::set_userid(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::release_authenticationdata() {
   
-  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.userId)
+  ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
+  authenticationdata_ = nullptr;
+  if (GetArena() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+  return temp;
 }
-inline void SendLogRequest::set_userid(const char* value,
-    size_t size) {
+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::unsafe_arena_release_authenticationdata() {
+  // @@protoc_insertion_point(field_release:backup.SendLogRequest.authenticationData)
   
-  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.userId)
+  ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
+  authenticationdata_ = nullptr;
+  return temp;
 }
-inline std::string* SendLogRequest::_internal_mutable_userid() {
+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::_internal_mutable_authenticationdata() {
   
-  return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* SendLogRequest::release_userid() {
-  // @@protoc_insertion_point(field_release:backup.SendLogRequest.userId)
-  return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void SendLogRequest::set_allocated_userid(std::string* userid) {
-  if (userid != nullptr) {
+  if (authenticationdata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(GetArena());
+    authenticationdata_ = p;
+  }
+  return authenticationdata_;
+}
+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::mutable_authenticationdata() {
+  // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.authenticationData)
+  return _internal_mutable_authenticationdata();
+}
+inline void SendLogRequest::set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  if (message_arena == nullptr) {
+    delete authenticationdata_;
+  }
+  if (authenticationdata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata);
+    if (message_arena != submessage_arena) {
+      authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, authenticationdata, submessage_arena);
+    }
     
   } else {
     
   }
-  userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.userId)
+  authenticationdata_ = authenticationdata;
+  // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.authenticationData)
 }
 
-// bytes data = 2;
-inline void SendLogRequest::clear_data() {
-  data_.ClearToEmpty();
+// bytes logData = 2;
+inline void SendLogRequest::clear_logdata() {
+  logdata_.ClearToEmpty();
 }
-inline const std::string& SendLogRequest::data() const {
-  // @@protoc_insertion_point(field_get:backup.SendLogRequest.data)
-  return _internal_data();
+inline const std::string& SendLogRequest::logdata() const {
+  // @@protoc_insertion_point(field_get:backup.SendLogRequest.logData)
+  return _internal_logdata();
 }
-inline void SendLogRequest::set_data(const std::string& value) {
-  _internal_set_data(value);
-  // @@protoc_insertion_point(field_set:backup.SendLogRequest.data)
+inline void SendLogRequest::set_logdata(const std::string& value) {
+  _internal_set_logdata(value);
+  // @@protoc_insertion_point(field_set:backup.SendLogRequest.logData)
 }
-inline std::string* SendLogRequest::mutable_data() {
-  // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.data)
-  return _internal_mutable_data();
+inline std::string* SendLogRequest::mutable_logdata() {
+  // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.logData)
+  return _internal_mutable_logdata();
 }
-inline const std::string& SendLogRequest::_internal_data() const {
-  return data_.Get();
+inline const std::string& SendLogRequest::_internal_logdata() const {
+  return logdata_.Get();
 }
-inline void SendLogRequest::_internal_set_data(const std::string& value) {
+inline void SendLogRequest::_internal_set_logdata(const std::string& value) {
   
-  data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void SendLogRequest::set_data(std::string&& value) {
+inline void SendLogRequest::set_logdata(std::string&& value) {
   
-  data_.Set(
+  logdata_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.data)
+  // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.logData)
 }
-inline void SendLogRequest::set_data(const char* value) {
+inline void SendLogRequest::set_logdata(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.data)
+  logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.logData)
 }
-inline void SendLogRequest::set_data(const void* value,
+inline void SendLogRequest::set_logdata(const void* value,
     size_t size) {
   
-  data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+  logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.data)
+  // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.logData)
 }
-inline std::string* SendLogRequest::_internal_mutable_data() {
+inline std::string* SendLogRequest::_internal_mutable_logdata() {
   
-  return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  return logdata_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* SendLogRequest::release_data() {
-  // @@protoc_insertion_point(field_release:backup.SendLogRequest.data)
-  return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* SendLogRequest::release_logdata() {
+  // @@protoc_insertion_point(field_release:backup.SendLogRequest.logData)
+  return logdata_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void SendLogRequest::set_allocated_data(std::string* data) {
-  if (data != nullptr) {
+inline void SendLogRequest::set_allocated_logdata(std::string* logdata) {
+  if (logdata != nullptr) {
     
   } else {
     
   }
-  data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
+  logdata_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), logdata,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.data)
+  // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.logData)
 }
 
 // -------------------------------------------------------------------
 
-// PullBackupKeyRequest
+// RecoverBackupKeyRequest
 
-// string userId = 1;
-inline void PullBackupKeyRequest::clear_userid() {
-  userid_.ClearToEmpty();
-}
-inline const std::string& PullBackupKeyRequest::userid() const {
-  // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.userId)
-  return _internal_userid();
+// .backup.FullAuthenticationRequestData authenticationData = 1;
+inline bool RecoverBackupKeyRequest::_internal_has_authenticationdata() const {
+  return this != internal_default_instance() && authenticationdata_ != nullptr;
 }
-inline void PullBackupKeyRequest::set_userid(const std::string& value) {
-  _internal_set_userid(value);
-  // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.userId)
+inline bool RecoverBackupKeyRequest::has_authenticationdata() const {
+  return _internal_has_authenticationdata();
 }
-inline std::string* PullBackupKeyRequest::mutable_userid() {
-  // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.userId)
-  return _internal_mutable_userid();
+inline void RecoverBackupKeyRequest::clear_authenticationdata() {
+  if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+    delete authenticationdata_;
+  }
+  authenticationdata_ = nullptr;
 }
-inline const std::string& PullBackupKeyRequest::_internal_userid() const {
-  return userid_.Get();
+inline const ::backup::FullAuthenticationRequestData& RecoverBackupKeyRequest::_internal_authenticationdata() const {
+  const ::backup::FullAuthenticationRequestData* p = authenticationdata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::backup::FullAuthenticationRequestData&>(
+      ::backup::_FullAuthenticationRequestData_default_instance_);
 }
-inline void PullBackupKeyRequest::_internal_set_userid(const std::string& value) {
-  
-  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline const ::backup::FullAuthenticationRequestData& RecoverBackupKeyRequest::authenticationdata() const {
+  // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyRequest.authenticationData)
+  return _internal_authenticationdata();
 }
-inline void PullBackupKeyRequest::set_userid(std::string&& value) {
-  
-  userid_.Set(
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.userId)
+inline void RecoverBackupKeyRequest::unsafe_arena_set_allocated_authenticationdata(
+    ::backup::FullAuthenticationRequestData* authenticationdata) {
+  if (GetArena() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_);
+  }
+  authenticationdata_ = authenticationdata;
+  if (authenticationdata) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.RecoverBackupKeyRequest.authenticationData)
 }
-inline void PullBackupKeyRequest::set_userid(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::release_authenticationdata() {
   
-  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.userId)
+  ::backup::FullAuthenticationRequestData* temp = authenticationdata_;
+  authenticationdata_ = nullptr;
+  if (GetArena() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+  return temp;
 }
-inline void PullBackupKeyRequest::set_userid(const char* value,
-    size_t size) {
+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::unsafe_arena_release_authenticationdata() {
+  // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyRequest.authenticationData)
   
-  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyRequest.userId)
+  ::backup::FullAuthenticationRequestData* temp = authenticationdata_;
+  authenticationdata_ = nullptr;
+  return temp;
 }
-inline std::string* PullBackupKeyRequest::_internal_mutable_userid() {
+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::_internal_mutable_authenticationdata() {
   
-  return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PullBackupKeyRequest::release_userid() {
-  // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.userId)
-  return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PullBackupKeyRequest::set_allocated_userid(std::string* userid) {
-  if (userid != nullptr) {
+  if (authenticationdata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::backup::FullAuthenticationRequestData>(GetArena());
+    authenticationdata_ = p;
+  }
+  return authenticationdata_;
+}
+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::mutable_authenticationdata() {
+  // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyRequest.authenticationData)
+  return _internal_mutable_authenticationdata();
+}
+inline void RecoverBackupKeyRequest::set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  if (message_arena == nullptr) {
+    delete authenticationdata_;
+  }
+  if (authenticationdata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata);
+    if (message_arena != submessage_arena) {
+      authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, authenticationdata, submessage_arena);
+    }
     
   } else {
     
   }
-  userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.userId)
+  authenticationdata_ = authenticationdata;
+  // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyRequest.authenticationData)
 }
 
-// bytes pakeKey = 2;
-inline void PullBackupKeyRequest::clear_pakekey() {
-  pakekey_.ClearToEmpty();
-}
-inline const std::string& PullBackupKeyRequest::pakekey() const {
-  // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.pakeKey)
-  return _internal_pakekey();
-}
-inline void PullBackupKeyRequest::set_pakekey(const std::string& value) {
-  _internal_set_pakekey(value);
-  // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.pakeKey)
-}
-inline std::string* PullBackupKeyRequest::mutable_pakekey() {
-  // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.pakeKey)
-  return _internal_mutable_pakekey();
-}
-inline const std::string& PullBackupKeyRequest::_internal_pakekey() const {
-  return pakekey_.Get();
+// -------------------------------------------------------------------
+
+// RecoverBackupKeyResponse
+
+// .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+inline bool RecoverBackupKeyResponse::_internal_has_authenticationresponsedata() const {
+  return data_case() == kAuthenticationResponseData;
 }
-inline void PullBackupKeyRequest::_internal_set_pakekey(const std::string& value) {
-  
-  pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline bool RecoverBackupKeyResponse::has_authenticationresponsedata() const {
+  return _internal_has_authenticationresponsedata();
 }
-inline void PullBackupKeyRequest::set_pakekey(std::string&& value) {
-  
-  pakekey_.Set(
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.pakeKey)
+inline void RecoverBackupKeyResponse::set_has_authenticationresponsedata() {
+  _oneof_case_[0] = kAuthenticationResponseData;
 }
-inline void PullBackupKeyRequest::set_pakekey(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.pakeKey)
+inline void RecoverBackupKeyResponse::clear_authenticationresponsedata() {
+  if (_internal_has_authenticationresponsedata()) {
+    if (GetArena() == nullptr) {
+      delete data_.authenticationresponsedata_;
+    }
+    clear_has_data();
+  }
 }
-inline void PullBackupKeyRequest::set_pakekey(const void* value,
-    size_t size) {
-  
-  pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyRequest.pakeKey)
+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::release_authenticationresponsedata() {
+  // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyResponse.authenticationResponseData)
+  if (_internal_has_authenticationresponsedata()) {
+    clear_has_data();
+      ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
+    if (GetArena() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    data_.authenticationresponsedata_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
 }
-inline std::string* PullBackupKeyRequest::_internal_mutable_pakekey() {
-  
-  return pakekey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline const ::backup::FullAuthenticationResponseData& RecoverBackupKeyResponse::_internal_authenticationresponsedata() const {
+  return _internal_has_authenticationresponsedata()
+      ? *data_.authenticationresponsedata_
+      : reinterpret_cast< ::backup::FullAuthenticationResponseData&>(::backup::_FullAuthenticationResponseData_default_instance_);
 }
-inline std::string* PullBackupKeyRequest::release_pakekey() {
-  // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.pakeKey)
-  return pakekey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline const ::backup::FullAuthenticationResponseData& RecoverBackupKeyResponse::authenticationresponsedata() const {
+  // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyResponse.authenticationResponseData)
+  return _internal_authenticationresponsedata();
 }
-inline void PullBackupKeyRequest::set_allocated_pakekey(std::string* pakekey) {
-  if (pakekey != nullptr) {
-    
+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::unsafe_arena_release_authenticationresponsedata() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:backup.RecoverBackupKeyResponse.authenticationResponseData)
+  if (_internal_has_authenticationresponsedata()) {
+    clear_has_data();
+    ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
+    data_.authenticationresponsedata_ = nullptr;
+    return temp;
   } else {
-    
+    return nullptr;
   }
-  pakekey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakekey,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.pakeKey)
-}
-
-// -------------------------------------------------------------------
-
-// PullBackupKeyResponse
-
-// bytes encryptedBackupKey = 1;
-inline void PullBackupKeyResponse::clear_encryptedbackupkey() {
-  encryptedbackupkey_.ClearToEmpty();
 }
-inline const std::string& PullBackupKeyResponse::encryptedbackupkey() const {
-  // @@protoc_insertion_point(field_get:backup.PullBackupKeyResponse.encryptedBackupKey)
-  return _internal_encryptedbackupkey();
+inline void RecoverBackupKeyResponse::unsafe_arena_set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
+  clear_data();
+  if (authenticationresponsedata) {
+    set_has_authenticationresponsedata();
+    data_.authenticationresponsedata_ = authenticationresponsedata;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.RecoverBackupKeyResponse.authenticationResponseData)
 }
-inline void PullBackupKeyResponse::set_encryptedbackupkey(const std::string& value) {
-  _internal_set_encryptedbackupkey(value);
-  // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.encryptedBackupKey)
+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::_internal_mutable_authenticationresponsedata() {
+  if (!_internal_has_authenticationresponsedata()) {
+    clear_data();
+    set_has_authenticationresponsedata();
+    data_.authenticationresponsedata_ = CreateMaybeMessage< ::backup::FullAuthenticationResponseData >(GetArena());
+  }
+  return data_.authenticationresponsedata_;
 }
-inline std::string* PullBackupKeyResponse::mutable_encryptedbackupkey() {
-  // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyResponse.encryptedBackupKey)
-  return _internal_mutable_encryptedbackupkey();
+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::mutable_authenticationresponsedata() {
+  // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyResponse.authenticationResponseData)
+  return _internal_mutable_authenticationresponsedata();
 }
-inline const std::string& PullBackupKeyResponse::_internal_encryptedbackupkey() const {
-  return encryptedbackupkey_.Get();
+
+// .backup.AuthenticationInformationData authenticationInformationData = 2;
+inline bool RecoverBackupKeyResponse::_internal_has_authenticationinformationdata() const {
+  return data_case() == kAuthenticationInformationData;
 }
-inline void PullBackupKeyResponse::_internal_set_encryptedbackupkey(const std::string& value) {
-  
-  encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline bool RecoverBackupKeyResponse::has_authenticationinformationdata() const {
+  return _internal_has_authenticationinformationdata();
 }
-inline void PullBackupKeyResponse::set_encryptedbackupkey(std::string&& value) {
-  
-  encryptedbackupkey_.Set(
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyResponse.encryptedBackupKey)
+inline void RecoverBackupKeyResponse::set_has_authenticationinformationdata() {
+  _oneof_case_[0] = kAuthenticationInformationData;
 }
-inline void PullBackupKeyResponse::set_encryptedbackupkey(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyResponse.encryptedBackupKey)
+inline void RecoverBackupKeyResponse::clear_authenticationinformationdata() {
+  if (_internal_has_authenticationinformationdata()) {
+    if (GetArena() == nullptr) {
+      delete data_.authenticationinformationdata_;
+    }
+    clear_has_data();
+  }
 }
-inline void PullBackupKeyResponse::set_encryptedbackupkey(const void* value,
-    size_t size) {
-  
-  encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyResponse.encryptedBackupKey)
+inline ::backup::AuthenticationInformationData* RecoverBackupKeyResponse::release_authenticationinformationdata() {
+  // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyResponse.authenticationInformationData)
+  if (_internal_has_authenticationinformationdata()) {
+    clear_has_data();
+      ::backup::AuthenticationInformationData* temp = data_.authenticationinformationdata_;
+    if (GetArena() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    data_.authenticationinformationdata_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
 }
-inline std::string* PullBackupKeyResponse::_internal_mutable_encryptedbackupkey() {
-  
-  return encryptedbackupkey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline const ::backup::AuthenticationInformationData& RecoverBackupKeyResponse::_internal_authenticationinformationdata() const {
+  return _internal_has_authenticationinformationdata()
+      ? *data_.authenticationinformationdata_
+      : reinterpret_cast< ::backup::AuthenticationInformationData&>(::backup::_AuthenticationInformationData_default_instance_);
 }
-inline std::string* PullBackupKeyResponse::release_encryptedbackupkey() {
-  // @@protoc_insertion_point(field_release:backup.PullBackupKeyResponse.encryptedBackupKey)
-  return encryptedbackupkey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline const ::backup::AuthenticationInformationData& RecoverBackupKeyResponse::authenticationinformationdata() const {
+  // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyResponse.authenticationInformationData)
+  return _internal_authenticationinformationdata();
 }
-inline void PullBackupKeyResponse::set_allocated_encryptedbackupkey(std::string* encryptedbackupkey) {
-  if (encryptedbackupkey != nullptr) {
-    
+inline ::backup::AuthenticationInformationData* RecoverBackupKeyResponse::unsafe_arena_release_authenticationinformationdata() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:backup.RecoverBackupKeyResponse.authenticationInformationData)
+  if (_internal_has_authenticationinformationdata()) {
+    clear_has_data();
+    ::backup::AuthenticationInformationData* temp = data_.authenticationinformationdata_;
+    data_.authenticationinformationdata_ = nullptr;
+    return temp;
   } else {
-    
+    return nullptr;
   }
-  encryptedbackupkey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryptedbackupkey,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyResponse.encryptedBackupKey)
+}
+inline void RecoverBackupKeyResponse::unsafe_arena_set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata) {
+  clear_data();
+  if (authenticationinformationdata) {
+    set_has_authenticationinformationdata();
+    data_.authenticationinformationdata_ = authenticationinformationdata;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.RecoverBackupKeyResponse.authenticationInformationData)
+}
+inline ::backup::AuthenticationInformationData* RecoverBackupKeyResponse::_internal_mutable_authenticationinformationdata() {
+  if (!_internal_has_authenticationinformationdata()) {
+    clear_data();
+    set_has_authenticationinformationdata();
+    data_.authenticationinformationdata_ = CreateMaybeMessage< ::backup::AuthenticationInformationData >(GetArena());
+  }
+  return data_.authenticationinformationdata_;
+}
+inline ::backup::AuthenticationInformationData* RecoverBackupKeyResponse::mutable_authenticationinformationdata() {
+  // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyResponse.authenticationInformationData)
+  return _internal_mutable_authenticationinformationdata();
 }
 
-// -------------------------------------------------------------------
-
-// PullCompactionRequest
-
-// string userId = 1;
-inline void PullCompactionRequest::clear_userid() {
-  userid_.ClearToEmpty();
+// string backupID = 3;
+inline bool RecoverBackupKeyResponse::_internal_has_backupid() const {
+  return data_case() == kBackupID;
 }
-inline const std::string& PullCompactionRequest::userid() const {
-  // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.userId)
-  return _internal_userid();
+inline bool RecoverBackupKeyResponse::has_backupid() const {
+  return _internal_has_backupid();
 }
-inline void PullCompactionRequest::set_userid(const std::string& value) {
-  _internal_set_userid(value);
-  // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.userId)
+inline void RecoverBackupKeyResponse::set_has_backupid() {
+  _oneof_case_[0] = kBackupID;
 }
-inline std::string* PullCompactionRequest::mutable_userid() {
-  // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.userId)
-  return _internal_mutable_userid();
+inline void RecoverBackupKeyResponse::clear_backupid() {
+  if (_internal_has_backupid()) {
+    data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    clear_has_data();
+  }
 }
-inline const std::string& PullCompactionRequest::_internal_userid() const {
-  return userid_.Get();
+inline const std::string& RecoverBackupKeyResponse::backupid() const {
+  // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyResponse.backupID)
+  return _internal_backupid();
 }
-inline void PullCompactionRequest::_internal_set_userid(const std::string& value) {
-  
-  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline void RecoverBackupKeyResponse::set_backupid(const std::string& value) {
+  _internal_set_backupid(value);
+  // @@protoc_insertion_point(field_set:backup.RecoverBackupKeyResponse.backupID)
 }
-inline void PullCompactionRequest::set_userid(std::string&& value) {
-  
-  userid_.Set(
+inline std::string* RecoverBackupKeyResponse::mutable_backupid() {
+  // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyResponse.backupID)
+  return _internal_mutable_backupid();
+}
+inline const std::string& RecoverBackupKeyResponse::_internal_backupid() const {
+  if (_internal_has_backupid()) {
+    return data_.backupid_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void RecoverBackupKeyResponse::_internal_set_backupid(const std::string& value) {
+  if (!_internal_has_backupid()) {
+    clear_data();
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void RecoverBackupKeyResponse::set_backupid(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.RecoverBackupKeyResponse.backupID)
+  if (!_internal_has_backupid()) {
+    clear_data();
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.backupid_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionRequest.userId)
+  // @@protoc_insertion_point(field_set_rvalue:backup.RecoverBackupKeyResponse.backupID)
 }
-inline void PullCompactionRequest::set_userid(const char* value) {
+inline void RecoverBackupKeyResponse::set_backupid(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
-  
-  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.PullCompactionRequest.userId)
-}
-inline void PullCompactionRequest::set_userid(const char* value,
-    size_t size) {
-  
-  userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionRequest.userId)
+  if (!_internal_has_backupid()) {
+    clear_data();
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+      ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:backup.RecoverBackupKeyResponse.backupID)
 }
-inline std::string* PullCompactionRequest::_internal_mutable_userid() {
-  
-  return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline void RecoverBackupKeyResponse::set_backupid(const char* value,
+                             size_t size) {
+  if (!_internal_has_backupid()) {
+    clear_data();
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  data_.backupid_.Set(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArena());
+  // @@protoc_insertion_point(field_set_pointer:backup.RecoverBackupKeyResponse.backupID)
 }
-inline std::string* PullCompactionRequest::release_userid() {
-  // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.userId)
-  return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* RecoverBackupKeyResponse::_internal_mutable_backupid() {
+  if (!_internal_has_backupid()) {
+    clear_data();
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return data_.backupid_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline void PullCompactionRequest::set_allocated_userid(std::string* userid) {
-  if (userid != nullptr) {
-    
+inline std::string* RecoverBackupKeyResponse::release_backupid() {
+  // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyResponse.backupID)
+  if (_internal_has_backupid()) {
+    clear_has_data();
+    return data_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
   } else {
-    
+    return nullptr;
   }
-  userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.userId)
+}
+inline void RecoverBackupKeyResponse::set_allocated_backupid(std::string* backupid) {
+  if (has_data()) {
+    clear_data();
+  }
+  if (backupid != nullptr) {
+    set_has_backupid();
+    data_.backupid_.UnsafeSetDefault(backupid);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+    if (arena != nullptr) {
+      arena->Own(backupid);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyResponse.backupID)
 }
 
-// bytes message = 2;
-inline void PullCompactionRequest::clear_message() {
-  message_.ClearToEmpty();
+inline bool RecoverBackupKeyResponse::has_data() const {
+  return data_case() != DATA_NOT_SET;
+}
+inline void RecoverBackupKeyResponse::clear_has_data() {
+  _oneof_case_[0] = DATA_NOT_SET;
 }
-inline const std::string& PullCompactionRequest::message() const {
-  // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.message)
-  return _internal_message();
+inline RecoverBackupKeyResponse::DataCase RecoverBackupKeyResponse::data_case() const {
+  return RecoverBackupKeyResponse::DataCase(_oneof_case_[0]);
 }
-inline void PullCompactionRequest::set_message(const std::string& value) {
-  _internal_set_message(value);
-  // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.message)
+// -------------------------------------------------------------------
+
+// PullBackupRequest
+
+// .backup.SimpleAuthenticationRequestData authenticationData = 1;
+inline bool PullBackupRequest::_internal_has_authenticationdata() const {
+  return this != internal_default_instance() && authenticationdata_ != nullptr;
 }
-inline std::string* PullCompactionRequest::mutable_message() {
-  // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.message)
-  return _internal_mutable_message();
+inline bool PullBackupRequest::has_authenticationdata() const {
+  return _internal_has_authenticationdata();
 }
-inline const std::string& PullCompactionRequest::_internal_message() const {
-  return message_.Get();
+inline void PullBackupRequest::clear_authenticationdata() {
+  if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+    delete authenticationdata_;
+  }
+  authenticationdata_ = nullptr;
 }
-inline void PullCompactionRequest::_internal_set_message(const std::string& value) {
-  
-  message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline const ::backup::SimpleAuthenticationRequestData& PullBackupRequest::_internal_authenticationdata() const {
+  const ::backup::SimpleAuthenticationRequestData* p = authenticationdata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::backup::SimpleAuthenticationRequestData&>(
+      ::backup::_SimpleAuthenticationRequestData_default_instance_);
 }
-inline void PullCompactionRequest::set_message(std::string&& value) {
-  
-  message_.Set(
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionRequest.message)
+inline const ::backup::SimpleAuthenticationRequestData& PullBackupRequest::authenticationdata() const {
+  // @@protoc_insertion_point(field_get:backup.PullBackupRequest.authenticationData)
+  return _internal_authenticationdata();
 }
-inline void PullCompactionRequest::set_message(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.PullCompactionRequest.message)
+inline void PullBackupRequest::unsafe_arena_set_allocated_authenticationdata(
+    ::backup::SimpleAuthenticationRequestData* authenticationdata) {
+  if (GetArena() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_);
+  }
+  authenticationdata_ = authenticationdata;
+  if (authenticationdata) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.PullBackupRequest.authenticationData)
 }
-inline void PullCompactionRequest::set_message(const void* value,
-    size_t size) {
+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::release_authenticationdata() {
   
-  message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionRequest.message)
+  ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
+  authenticationdata_ = nullptr;
+  if (GetArena() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+  return temp;
 }
-inline std::string* PullCompactionRequest::_internal_mutable_message() {
+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::unsafe_arena_release_authenticationdata() {
+  // @@protoc_insertion_point(field_release:backup.PullBackupRequest.authenticationData)
   
-  return message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
+  authenticationdata_ = nullptr;
+  return temp;
 }
-inline std::string* PullCompactionRequest::release_message() {
-  // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.message)
-  return message_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PullCompactionRequest::set_allocated_message(std::string* message) {
-  if (message != nullptr) {
+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::_internal_mutable_authenticationdata() {
+  
+  if (authenticationdata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(GetArena());
+    authenticationdata_ = p;
+  }
+  return authenticationdata_;
+}
+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::mutable_authenticationdata() {
+  // @@protoc_insertion_point(field_mutable:backup.PullBackupRequest.authenticationData)
+  return _internal_mutable_authenticationdata();
+}
+inline void PullBackupRequest::set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  if (message_arena == nullptr) {
+    delete authenticationdata_;
+  }
+  if (authenticationdata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata);
+    if (message_arena != submessage_arena) {
+      authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, authenticationdata, submessage_arena);
+    }
     
   } else {
     
   }
-  message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.message)
+  authenticationdata_ = authenticationdata;
+  // @@protoc_insertion_point(field_set_allocated:backup.PullBackupRequest.authenticationData)
 }
 
 // -------------------------------------------------------------------
 
-// PullCompactionResponse
+// PullBackupResponse
 
 // bytes compactionChunk = 1;
-inline bool PullCompactionResponse::_internal_has_compactionchunk() const {
+inline bool PullBackupResponse::_internal_has_compactionchunk() const {
   return data_case() == kCompactionChunk;
 }
-inline bool PullCompactionResponse::has_compactionchunk() const {
+inline bool PullBackupResponse::has_compactionchunk() const {
   return _internal_has_compactionchunk();
 }
-inline void PullCompactionResponse::set_has_compactionchunk() {
+inline void PullBackupResponse::set_has_compactionchunk() {
   _oneof_case_[0] = kCompactionChunk;
 }
-inline void PullCompactionResponse::clear_compactionchunk() {
+inline void PullBackupResponse::clear_compactionchunk() {
   if (_internal_has_compactionchunk()) {
     data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
     clear_has_data();
   }
 }
-inline const std::string& PullCompactionResponse::compactionchunk() const {
-  // @@protoc_insertion_point(field_get:backup.PullCompactionResponse.compactionChunk)
+inline const std::string& PullBackupResponse::compactionchunk() const {
+  // @@protoc_insertion_point(field_get:backup.PullBackupResponse.compactionChunk)
   return _internal_compactionchunk();
 }
-inline void PullCompactionResponse::set_compactionchunk(const std::string& value) {
+inline void PullBackupResponse::set_compactionchunk(const std::string& value) {
   _internal_set_compactionchunk(value);
-  // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.compactionChunk)
+  // @@protoc_insertion_point(field_set:backup.PullBackupResponse.compactionChunk)
 }
-inline std::string* PullCompactionResponse::mutable_compactionchunk() {
-  // @@protoc_insertion_point(field_mutable:backup.PullCompactionResponse.compactionChunk)
+inline std::string* PullBackupResponse::mutable_compactionchunk() {
+  // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.compactionChunk)
   return _internal_mutable_compactionchunk();
 }
-inline const std::string& PullCompactionResponse::_internal_compactionchunk() const {
+inline const std::string& PullBackupResponse::_internal_compactionchunk() const {
   if (_internal_has_compactionchunk()) {
     return data_.compactionchunk_.Get();
   }
   return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
 }
-inline void PullCompactionResponse::_internal_set_compactionchunk(const std::string& value) {
+inline void PullBackupResponse::_internal_set_compactionchunk(const std::string& value) {
   if (!_internal_has_compactionchunk()) {
     clear_data();
     set_has_compactionchunk();
@@ -1901,8 +4956,8 @@
   }
   data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void PullCompactionResponse::set_compactionchunk(std::string&& value) {
-  // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.compactionChunk)
+inline void PullBackupResponse::set_compactionchunk(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.PullBackupResponse.compactionChunk)
   if (!_internal_has_compactionchunk()) {
     clear_data();
     set_has_compactionchunk();
@@ -1910,9 +4965,9 @@
   }
   data_.compactionchunk_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionResponse.compactionChunk)
+  // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.compactionChunk)
 }
-inline void PullCompactionResponse::set_compactionchunk(const char* value) {
+inline void PullBackupResponse::set_compactionchunk(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   if (!_internal_has_compactionchunk()) {
     clear_data();
@@ -1921,9 +4976,9 @@
   }
   data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
       ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.PullCompactionResponse.compactionChunk)
+  // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.compactionChunk)
 }
-inline void PullCompactionResponse::set_compactionchunk(const void* value,
+inline void PullBackupResponse::set_compactionchunk(const void* value,
                              size_t size) {
   if (!_internal_has_compactionchunk()) {
     clear_data();
@@ -1934,9 +4989,9 @@
       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size),
       GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionResponse.compactionChunk)
+  // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.compactionChunk)
 }
-inline std::string* PullCompactionResponse::_internal_mutable_compactionchunk() {
+inline std::string* PullBackupResponse::_internal_mutable_compactionchunk() {
   if (!_internal_has_compactionchunk()) {
     clear_data();
     set_has_compactionchunk();
@@ -1945,8 +5000,8 @@
   return data_.compactionchunk_.Mutable(
       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* PullCompactionResponse::release_compactionchunk() {
-  // @@protoc_insertion_point(field_release:backup.PullCompactionResponse.compactionChunk)
+inline std::string* PullBackupResponse::release_compactionchunk() {
+  // @@protoc_insertion_point(field_release:backup.PullBackupResponse.compactionChunk)
   if (_internal_has_compactionchunk()) {
     clear_has_data();
     return data_.compactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
@@ -1954,7 +5009,7 @@
     return nullptr;
   }
 }
-inline void PullCompactionResponse::set_allocated_compactionchunk(std::string* compactionchunk) {
+inline void PullBackupResponse::set_allocated_compactionchunk(std::string* compactionchunk) {
   if (has_data()) {
     clear_data();
   }
@@ -1966,44 +5021,44 @@
       arena->Own(compactionchunk);
     }
   }
-  // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionResponse.compactionChunk)
+  // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.compactionChunk)
 }
 
 // bytes logChunk = 2;
-inline bool PullCompactionResponse::_internal_has_logchunk() const {
+inline bool PullBackupResponse::_internal_has_logchunk() const {
   return data_case() == kLogChunk;
 }
-inline bool PullCompactionResponse::has_logchunk() const {
+inline bool PullBackupResponse::has_logchunk() const {
   return _internal_has_logchunk();
 }
-inline void PullCompactionResponse::set_has_logchunk() {
+inline void PullBackupResponse::set_has_logchunk() {
   _oneof_case_[0] = kLogChunk;
 }
-inline void PullCompactionResponse::clear_logchunk() {
+inline void PullBackupResponse::clear_logchunk() {
   if (_internal_has_logchunk()) {
     data_.logchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
     clear_has_data();
   }
 }
-inline const std::string& PullCompactionResponse::logchunk() const {
-  // @@protoc_insertion_point(field_get:backup.PullCompactionResponse.logChunk)
+inline const std::string& PullBackupResponse::logchunk() const {
+  // @@protoc_insertion_point(field_get:backup.PullBackupResponse.logChunk)
   return _internal_logchunk();
 }
-inline void PullCompactionResponse::set_logchunk(const std::string& value) {
+inline void PullBackupResponse::set_logchunk(const std::string& value) {
   _internal_set_logchunk(value);
-  // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.logChunk)
+  // @@protoc_insertion_point(field_set:backup.PullBackupResponse.logChunk)
 }
-inline std::string* PullCompactionResponse::mutable_logchunk() {
-  // @@protoc_insertion_point(field_mutable:backup.PullCompactionResponse.logChunk)
+inline std::string* PullBackupResponse::mutable_logchunk() {
+  // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.logChunk)
   return _internal_mutable_logchunk();
 }
-inline const std::string& PullCompactionResponse::_internal_logchunk() const {
+inline const std::string& PullBackupResponse::_internal_logchunk() const {
   if (_internal_has_logchunk()) {
     return data_.logchunk_.Get();
   }
   return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
 }
-inline void PullCompactionResponse::_internal_set_logchunk(const std::string& value) {
+inline void PullBackupResponse::_internal_set_logchunk(const std::string& value) {
   if (!_internal_has_logchunk()) {
     clear_data();
     set_has_logchunk();
@@ -2011,8 +5066,8 @@
   }
   data_.logchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void PullCompactionResponse::set_logchunk(std::string&& value) {
-  // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.logChunk)
+inline void PullBackupResponse::set_logchunk(std::string&& value) {
+  // @@protoc_insertion_point(field_set:backup.PullBackupResponse.logChunk)
   if (!_internal_has_logchunk()) {
     clear_data();
     set_has_logchunk();
@@ -2020,9 +5075,9 @@
   }
   data_.logchunk_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionResponse.logChunk)
+  // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.logChunk)
 }
-inline void PullCompactionResponse::set_logchunk(const char* value) {
+inline void PullBackupResponse::set_logchunk(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   if (!_internal_has_logchunk()) {
     clear_data();
@@ -2031,9 +5086,9 @@
   }
   data_.logchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
       ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:backup.PullCompactionResponse.logChunk)
+  // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.logChunk)
 }
-inline void PullCompactionResponse::set_logchunk(const void* value,
+inline void PullBackupResponse::set_logchunk(const void* value,
                              size_t size) {
   if (!_internal_has_logchunk()) {
     clear_data();
@@ -2044,9 +5099,9 @@
       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size),
       GetArena());
-  // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionResponse.logChunk)
+  // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.logChunk)
 }
-inline std::string* PullCompactionResponse::_internal_mutable_logchunk() {
+inline std::string* PullBackupResponse::_internal_mutable_logchunk() {
   if (!_internal_has_logchunk()) {
     clear_data();
     set_has_logchunk();
@@ -2055,8 +5110,8 @@
   return data_.logchunk_.Mutable(
       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* PullCompactionResponse::release_logchunk() {
-  // @@protoc_insertion_point(field_release:backup.PullCompactionResponse.logChunk)
+inline std::string* PullBackupResponse::release_logchunk() {
+  // @@protoc_insertion_point(field_release:backup.PullBackupResponse.logChunk)
   if (_internal_has_logchunk()) {
     clear_has_data();
     return data_.logchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
@@ -2064,7 +5119,7 @@
     return nullptr;
   }
 }
-inline void PullCompactionResponse::set_allocated_logchunk(std::string* logchunk) {
+inline void PullBackupResponse::set_allocated_logchunk(std::string* logchunk) {
   if (has_data()) {
     clear_data();
   }
@@ -2076,17 +5131,17 @@
       arena->Own(logchunk);
     }
   }
-  // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionResponse.logChunk)
+  // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.logChunk)
 }
 
-inline bool PullCompactionResponse::has_data() const {
+inline bool PullBackupResponse::has_data() const {
   return data_case() != DATA_NOT_SET;
 }
-inline void PullCompactionResponse::clear_has_data() {
+inline void PullBackupResponse::clear_has_data() {
   _oneof_case_[0] = DATA_NOT_SET;
 }
-inline PullCompactionResponse::DataCase PullCompactionResponse::data_case() const {
-  return PullCompactionResponse::DataCase(_oneof_case_[0]);
+inline PullBackupResponse::DataCase PullBackupResponse::data_case() const {
+  return PullBackupResponse::DataCase(_oneof_case_[0]);
 }
 #ifdef __GNUC__
   #pragma GCC diagnostic pop
@@ -2101,6 +5156,16 @@
 
 // -------------------------------------------------------------------
 
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc
--- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc
+++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc
@@ -17,23 +17,84 @@
 
 PROTOBUF_PRAGMA_INIT_SEG
 namespace backup {
-constexpr ResetKeyRequest::ResetKeyRequest(
+constexpr FullAuthenticationRequestData::FullAuthenticationRequestData(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
   : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
   , _oneof_case_{}{}
-struct ResetKeyRequestDefaultTypeInternal {
-  constexpr ResetKeyRequestDefaultTypeInternal()
+struct FullAuthenticationRequestDataDefaultTypeInternal {
+  constexpr FullAuthenticationRequestDataDefaultTypeInternal()
     : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
-  ~ResetKeyRequestDefaultTypeInternal() {}
+  ~FullAuthenticationRequestDataDefaultTypeInternal() {}
   union {
-    ResetKeyRequest _instance;
+    FullAuthenticationRequestData _instance;
   };
 };
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResetKeyRequestDefaultTypeInternal _ResetKeyRequest_default_instance_;
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FullAuthenticationRequestDataDefaultTypeInternal _FullAuthenticationRequestData_default_instance_;
+constexpr FullAuthenticationResponseData::FullAuthenticationResponseData(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct FullAuthenticationResponseDataDefaultTypeInternal {
+  constexpr FullAuthenticationResponseDataDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FullAuthenticationResponseDataDefaultTypeInternal() {}
+  union {
+    FullAuthenticationResponseData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FullAuthenticationResponseDataDefaultTypeInternal _FullAuthenticationResponseData_default_instance_;
+constexpr SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : backupid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct SimpleAuthenticationRequestDataDefaultTypeInternal {
+  constexpr SimpleAuthenticationRequestDataDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~SimpleAuthenticationRequestDataDefaultTypeInternal() {}
+  union {
+    SimpleAuthenticationRequestData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleAuthenticationRequestDataDefaultTypeInternal _SimpleAuthenticationRequestData_default_instance_;
+constexpr AuthenticationInformationData::AuthenticationInformationData(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct AuthenticationInformationDataDefaultTypeInternal {
+  constexpr AuthenticationInformationDataDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~AuthenticationInformationDataDefaultTypeInternal() {}
+  union {
+    AuthenticationInformationData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AuthenticationInformationDataDefaultTypeInternal _AuthenticationInformationData_default_instance_;
+constexpr CreateNewBackupRequest::CreateNewBackupRequest(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct CreateNewBackupRequestDefaultTypeInternal {
+  constexpr CreateNewBackupRequestDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~CreateNewBackupRequestDefaultTypeInternal() {}
+  union {
+    CreateNewBackupRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CreateNewBackupRequestDefaultTypeInternal _CreateNewBackupRequest_default_instance_;
+constexpr CreateNewBackupResponse::CreateNewBackupResponse(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct CreateNewBackupResponseDefaultTypeInternal {
+  constexpr CreateNewBackupResponseDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~CreateNewBackupResponseDefaultTypeInternal() {}
+  union {
+    CreateNewBackupResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CreateNewBackupResponseDefaultTypeInternal _CreateNewBackupResponse_default_instance_;
 constexpr SendLogRequest::SendLogRequest(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
-  : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
-  , data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+  : logdata_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , authenticationdata_(nullptr){}
 struct SendLogRequestDefaultTypeInternal {
   constexpr SendLogRequestDefaultTypeInternal()
     : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
@@ -43,153 +104,240 @@
   };
 };
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SendLogRequestDefaultTypeInternal _SendLogRequest_default_instance_;
-constexpr PullBackupKeyRequest::PullBackupKeyRequest(
+constexpr RecoverBackupKeyRequest::RecoverBackupKeyRequest(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
-  : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
-  , pakekey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct PullBackupKeyRequestDefaultTypeInternal {
-  constexpr PullBackupKeyRequestDefaultTypeInternal()
+  : authenticationdata_(nullptr){}
+struct RecoverBackupKeyRequestDefaultTypeInternal {
+  constexpr RecoverBackupKeyRequestDefaultTypeInternal()
     : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
-  ~PullBackupKeyRequestDefaultTypeInternal() {}
+  ~RecoverBackupKeyRequestDefaultTypeInternal() {}
   union {
-    PullBackupKeyRequest _instance;
+    RecoverBackupKeyRequest _instance;
   };
 };
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupKeyRequestDefaultTypeInternal _PullBackupKeyRequest_default_instance_;
-constexpr PullBackupKeyResponse::PullBackupKeyResponse(
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecoverBackupKeyRequestDefaultTypeInternal _RecoverBackupKeyRequest_default_instance_;
+constexpr RecoverBackupKeyResponse::RecoverBackupKeyResponse(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
-  : encryptedbackupkey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct PullBackupKeyResponseDefaultTypeInternal {
-  constexpr PullBackupKeyResponseDefaultTypeInternal()
+  : _oneof_case_{}{}
+struct RecoverBackupKeyResponseDefaultTypeInternal {
+  constexpr RecoverBackupKeyResponseDefaultTypeInternal()
     : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
-  ~PullBackupKeyResponseDefaultTypeInternal() {}
+  ~RecoverBackupKeyResponseDefaultTypeInternal() {}
   union {
-    PullBackupKeyResponse _instance;
+    RecoverBackupKeyResponse _instance;
   };
 };
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupKeyResponseDefaultTypeInternal _PullBackupKeyResponse_default_instance_;
-constexpr PullCompactionRequest::PullCompactionRequest(
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecoverBackupKeyResponseDefaultTypeInternal _RecoverBackupKeyResponse_default_instance_;
+constexpr PullBackupRequest::PullBackupRequest(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
-  : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
-  , message_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct PullCompactionRequestDefaultTypeInternal {
-  constexpr PullCompactionRequestDefaultTypeInternal()
+  : authenticationdata_(nullptr){}
+struct PullBackupRequestDefaultTypeInternal {
+  constexpr PullBackupRequestDefaultTypeInternal()
     : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
-  ~PullCompactionRequestDefaultTypeInternal() {}
+  ~PullBackupRequestDefaultTypeInternal() {}
   union {
-    PullCompactionRequest _instance;
+    PullBackupRequest _instance;
   };
 };
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullCompactionRequestDefaultTypeInternal _PullCompactionRequest_default_instance_;
-constexpr PullCompactionResponse::PullCompactionResponse(
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupRequestDefaultTypeInternal _PullBackupRequest_default_instance_;
+constexpr PullBackupResponse::PullBackupResponse(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
   : _oneof_case_{}{}
-struct PullCompactionResponseDefaultTypeInternal {
-  constexpr PullCompactionResponseDefaultTypeInternal()
+struct PullBackupResponseDefaultTypeInternal {
+  constexpr PullBackupResponseDefaultTypeInternal()
     : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
-  ~PullCompactionResponseDefaultTypeInternal() {}
+  ~PullBackupResponseDefaultTypeInternal() {}
   union {
-    PullCompactionResponse _instance;
+    PullBackupResponse _instance;
   };
 };
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullCompactionResponseDefaultTypeInternal _PullCompactionResponse_default_instance_;
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupResponseDefaultTypeInternal _PullBackupResponse_default_instance_;
 }  // namespace backup
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_backup_2eproto[6];
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_backup_2eproto[11];
 static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_backup_2eproto = nullptr;
 static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_backup_2eproto = nullptr;
 
 const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_backup_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, _internal_metadata_),
   ~0u,  // no _extensions_
-  PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, _oneof_case_[0]),
+  PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, _oneof_case_[0]),
   ~0u,  // no _weak_field_map_
-  PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, userid_),
   ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
   ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
-  PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, data_),
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, userid_),
+  PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, requestBytes_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationResponseData, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationResponseData, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationResponseData, responseData_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
-  PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, userid_),
-  PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, data_),
+  PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, backupid_),
+  PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, userid_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::backup::AuthenticationInformationData, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::backup::AuthenticationInformationData, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::backup::AuthenticationInformationData, data_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, data_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, data_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
-  PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, userid_),
-  PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, pakekey_),
+  PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, authenticationdata_),
+  PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, logdata_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyResponse, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
-  PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyResponse, encryptedbackupkey_),
+  PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyRequest, authenticationdata_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyResponse, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyResponse, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyResponse, data_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::backup::PullBackupRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
-  PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, userid_),
-  PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, message_),
+  PROTOBUF_FIELD_OFFSET(::backup::PullBackupRequest, authenticationdata_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, _internal_metadata_),
   ~0u,  // no _extensions_
-  PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, _oneof_case_[0]),
+  PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, _oneof_case_[0]),
   ~0u,  // no _weak_field_map_
   ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
   ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
-  PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, data_),
+  PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, data_),
 };
 static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
-  { 0, -1, sizeof(::backup::ResetKeyRequest)},
-  { 9, -1, sizeof(::backup::SendLogRequest)},
-  { 16, -1, sizeof(::backup::PullBackupKeyRequest)},
-  { 23, -1, sizeof(::backup::PullBackupKeyResponse)},
-  { 29, -1, sizeof(::backup::PullCompactionRequest)},
-  { 36, -1, sizeof(::backup::PullCompactionResponse)},
+  { 0, -1, sizeof(::backup::FullAuthenticationRequestData)},
+  { 13, -1, sizeof(::backup::FullAuthenticationResponseData)},
+  { 24, -1, sizeof(::backup::SimpleAuthenticationRequestData)},
+  { 31, -1, sizeof(::backup::AuthenticationInformationData)},
+  { 39, -1, sizeof(::backup::CreateNewBackupRequest)},
+  { 48, -1, sizeof(::backup::CreateNewBackupResponse)},
+  { 56, -1, sizeof(::backup::SendLogRequest)},
+  { 63, -1, sizeof(::backup::RecoverBackupKeyRequest)},
+  { 69, -1, sizeof(::backup::RecoverBackupKeyResponse)},
+  { 78, -1, sizeof(::backup::PullBackupRequest)},
+  { 84, -1, sizeof(::backup::PullBackupResponse)},
 };
 
 static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_ResetKeyRequest_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_FullAuthenticationRequestData_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_FullAuthenticationResponseData_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_SimpleAuthenticationRequestData_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_AuthenticationInformationData_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_CreateNewBackupRequest_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_CreateNewBackupResponse_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_SendLogRequest_default_instance_),
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupKeyRequest_default_instance_),
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupKeyResponse_default_instance_),
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullCompactionRequest_default_instance_),
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullCompactionResponse_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_RecoverBackupKeyRequest_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_RecoverBackupKeyResponse_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupRequest_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupResponse_default_instance_),
 };
 
 const char descriptor_table_protodef_backup_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
   "\n\014backup.proto\022\006backup\032\033google/protobuf/"
-  "empty.proto\"V\n\017ResetKeyRequest\022\016\n\006userId"
-  "\030\001 \001(\t\022\020\n\006newKey\030\002 \001(\014H\000\022\031\n\017compactionCh"
-  "unk\030\003 \001(\014H\000B\006\n\004data\".\n\016SendLogRequest\022\016\n"
-  "\006userId\030\001 \001(\t\022\014\n\004data\030\002 \001(\014\"7\n\024PullBacku"
-  "pKeyRequest\022\016\n\006userId\030\001 \001(\t\022\017\n\007pakeKey\030\002"
-  " \001(\014\"3\n\025PullBackupKeyResponse\022\032\n\022encrypt"
-  "edBackupKey\030\001 \001(\014\"8\n\025PullCompactionReque"
-  "st\022\016\n\006userId\030\001 \001(\t\022\017\n\007message\030\002 \001(\014\"O\n\026P"
-  "ullCompactionResponse\022\031\n\017compactionChunk"
-  "\030\001 \001(\014H\000\022\022\n\010logChunk\030\002 \001(\014H\000B\006\n\004data2\262\002\n"
-  "\rBackupService\022\?\n\010ResetKey\022\027.backup.Rese"
-  "tKeyRequest\032\026.google.protobuf.Empty\"\000(\001\022"
-  ";\n\007SendLog\022\026.backup.SendLogRequest\032\026.goo"
-  "gle.protobuf.Empty\"\000\022N\n\rPullBackupKey\022\034."
-  "backup.PullBackupKeyRequest\032\035.backup.Pul"
-  "lBackupKeyResponse\"\000\022S\n\016PullCompaction\022\035"
-  ".backup.PullCompactionRequest\032\036.backup.P"
-  "ullCompactionResponse\"\0000\001b\006proto3"
+  "empty.proto\"\223\002\n\035FullAuthenticationReques"
+  "tData\022!\n\027pakeRegistrationRequest\030\001 \001(\014H\000"
+  "\022 \n\026pakeRegistrationUpload\030\002 \001(\014H\000\022\037\n\025pa"
+  "keCredentialRequest\030\003 \001(\014H\000\022$\n\032pakeCrede"
+  "ntialFinalization\030\004 \001(\014H\000\022\037\n\025pakeChallen"
+  "geResponse\030\005 \001(\014H\000\022%\n\033walletAuthenticati"
+  "onRequest\030\006 \001(\014H\000\022\016\n\006userID\030\007 \001(\tB\016\n\014req"
+  "uestBytes\"\341\001\n\036FullAuthenticationResponse"
+  "Data\022\"\n\030pakeRegistrationResponse\030\001 \001(\014H\000"
+  "\022!\n\027pakeRegistrationSuccess\030\002 \001(\010H\000\022 \n\026p"
+  "akeCredentialResponse\030\003 \001(\014H\000\022\036\n\024pakeCha"
+  "llengeMessage\030\004 \001(\014H\000\022&\n\034walletAuthentic"
+  "ationResponse\030\005 \001(\014H\000B\016\n\014responseData\"C\n"
+  "\037SimpleAuthenticationRequestData\022\020\n\010back"
+  "upID\030\001 \001(\t\022\016\n\006userID\030\002 \001(\t\"N\n\035Authentica"
+  "tionInformationData\022\017\n\005nonce\030\001 \001(\014H\000\022\024\n\n"
+  "rawMessage\030\002 \001(\014H\000B\006\n\004data\"\332\001\n\026CreateNew"
+  "BackupRequest\022J\n\031authenticationRequestDa"
+  "ta\030\001 \001(\0132%.backup.FullAuthenticationRequ"
+  "estDataH\000\022N\n\035authenticationInformationDa"
+  "ta\030\002 \001(\0132%.backup.AuthenticationInformat"
+  "ionDataH\000\022\034\n\022newCompactionChunk\030\003 \001(\014H\000B"
+  "\006\n\004data\"\203\001\n\027CreateNewBackupResponse\022L\n\032a"
+  "uthenticationResponseData\030\001 \001(\0132&.backup"
+  ".FullAuthenticationResponseDataH\000\022\022\n\010bac"
+  "kupID\030\002 \001(\tH\000B\006\n\004data\"f\n\016SendLogRequest\022"
+  "C\n\022authenticationData\030\001 \001(\0132\'.backup.Sim"
+  "pleAuthenticationRequestData\022\017\n\007logData\030"
+  "\002 \001(\014\"\\\n\027RecoverBackupKeyRequest\022A\n\022auth"
+  "enticationData\030\001 \001(\0132%.backup.FullAuthen"
+  "ticationRequestData\"\324\001\n\030RecoverBackupKey"
+  "Response\022L\n\032authenticationResponseData\030\001"
+  " \001(\0132&.backup.FullAuthenticationResponse"
+  "DataH\000\022N\n\035authenticationInformationData\030"
+  "\002 \001(\0132%.backup.AuthenticationInformation"
+  "DataH\000\022\022\n\010backupID\030\003 \001(\tH\000B\006\n\004data\"X\n\021Pu"
+  "llBackupRequest\022C\n\022authenticationData\030\001 "
+  "\001(\0132\'.backup.SimpleAuthenticationRequest"
+  "Data\"K\n\022PullBackupResponse\022\031\n\017compaction"
+  "Chunk\030\001 \001(\014H\000\022\022\n\010logChunk\030\002 \001(\014H\000B\006\n\004dat"
+  "a2\320\002\n\rBackupService\022X\n\017CreateNewBackup\022\036"
+  ".backup.CreateNewBackupRequest\032\037.backup."
+  "CreateNewBackupResponse\"\000(\0010\001\022=\n\007SendLog"
+  "\022\026.backup.SendLogRequest\032\026.google.protob"
+  "uf.Empty\"\000(\001\022[\n\020RecoverBackupKey\022\037.backu"
+  "p.RecoverBackupKeyRequest\032 .backup.Recov"
+  "erBackupKeyResponse\"\000(\0010\001\022I\n\nPullBackup\022"
+  "\031.backup.PullBackupRequest\032\032.backup.Pull"
+  "BackupResponse\"\000(\0010\001b\006proto3"
   ;
 static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_backup_2eproto_deps[1] = {
   &::descriptor_table_google_2fprotobuf_2fempty_2eproto,
 };
 static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_backup_2eproto_once;
 const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_backup_2eproto = {
-  false, false, 753, descriptor_table_protodef_backup_2eproto, "backup.proto", 
-  &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 6,
+  false, false, 1988, descriptor_table_protodef_backup_2eproto, "backup.proto", 
+  &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 11,
   schemas, file_default_instances, TableStruct_backup_2eproto::offsets,
   file_level_metadata_backup_2eproto, file_level_enum_descriptors_backup_2eproto, file_level_service_descriptors_backup_2eproto,
 };
@@ -199,85 +347,1731 @@
   return descriptor_table_backup_2eproto.file_level_metadata[index];
 }
 
-// Force running AddDescriptors() at dynamic initialization time.
-PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_backup_2eproto(&descriptor_table_backup_2eproto);
-namespace backup {
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_backup_2eproto(&descriptor_table_backup_2eproto);
+namespace backup {
+
+// ===================================================================
+
+class FullAuthenticationRequestData::_Internal {
+ public:
+};
+
+FullAuthenticationRequestData::FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:backup.FullAuthenticationRequestData)
+}
+FullAuthenticationRequestData::FullAuthenticationRequestData(const FullAuthenticationRequestData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from._internal_userid().empty()) {
+    userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), 
+      GetArena());
+  }
+  clear_has_requestBytes();
+  switch (from.requestBytes_case()) {
+    case kPakeRegistrationRequest: {
+      _internal_set_pakeregistrationrequest(from._internal_pakeregistrationrequest());
+      break;
+    }
+    case kPakeRegistrationUpload: {
+      _internal_set_pakeregistrationupload(from._internal_pakeregistrationupload());
+      break;
+    }
+    case kPakeCredentialRequest: {
+      _internal_set_pakecredentialrequest(from._internal_pakecredentialrequest());
+      break;
+    }
+    case kPakeCredentialFinalization: {
+      _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
+      break;
+    }
+    case kPakeChallengeResponse: {
+      _internal_set_pakechallengeresponse(from._internal_pakechallengeresponse());
+      break;
+    }
+    case kWalletAuthenticationRequest: {
+      _internal_set_walletauthenticationrequest(from._internal_walletauthenticationrequest());
+      break;
+    }
+    case REQUESTBYTES_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:backup.FullAuthenticationRequestData)
+}
+
+void FullAuthenticationRequestData::SharedCtor() {
+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+clear_has_requestBytes();
+}
+
+FullAuthenticationRequestData::~FullAuthenticationRequestData() {
+  // @@protoc_insertion_point(destructor:backup.FullAuthenticationRequestData)
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void FullAuthenticationRequestData::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (has_requestBytes()) {
+    clear_requestBytes();
+  }
+}
+
+void FullAuthenticationRequestData::ArenaDtor(void* object) {
+  FullAuthenticationRequestData* _this = reinterpret_cast< FullAuthenticationRequestData* >(object);
+  (void)_this;
+}
+void FullAuthenticationRequestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FullAuthenticationRequestData::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FullAuthenticationRequestData::clear_requestBytes() {
+// @@protoc_insertion_point(one_of_clear_start:backup.FullAuthenticationRequestData)
+  switch (requestBytes_case()) {
+    case kPakeRegistrationRequest: {
+      requestBytes_.pakeregistrationrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case kPakeRegistrationUpload: {
+      requestBytes_.pakeregistrationupload_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case kPakeCredentialRequest: {
+      requestBytes_.pakecredentialrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case kPakeCredentialFinalization: {
+      requestBytes_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case kPakeChallengeResponse: {
+      requestBytes_.pakechallengeresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case kWalletAuthenticationRequest: {
+      requestBytes_.walletauthenticationrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case REQUESTBYTES_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = REQUESTBYTES_NOT_SET;
+}
+
+
+void FullAuthenticationRequestData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.FullAuthenticationRequestData)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  userid_.ClearToEmpty();
+  clear_requestBytes();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FullAuthenticationRequestData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // bytes pakeRegistrationRequest = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          auto str = _internal_mutable_pakeregistrationrequest();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bytes pakeRegistrationUpload = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          auto str = _internal_mutable_pakeregistrationupload();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bytes pakeCredentialRequest = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+          auto str = _internal_mutable_pakecredentialrequest();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bytes pakeCredentialFinalization = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+          auto str = _internal_mutable_pakecredentialfinalization();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bytes pakeChallengeResponse = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
+          auto str = _internal_mutable_pakechallengeresponse();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bytes walletAuthenticationRequest = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
+          auto str = _internal_mutable_walletauthenticationrequest();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string userID = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
+          auto str = _internal_mutable_userid();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.FullAuthenticationRequestData.userID"));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* FullAuthenticationRequestData::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:backup.FullAuthenticationRequestData)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes pakeRegistrationRequest = 1;
+  if (_internal_has_pakeregistrationrequest()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_pakeregistrationrequest(), target);
+  }
+
+  // bytes pakeRegistrationUpload = 2;
+  if (_internal_has_pakeregistrationupload()) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_pakeregistrationupload(), target);
+  }
+
+  // bytes pakeCredentialRequest = 3;
+  if (_internal_has_pakecredentialrequest()) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_pakecredentialrequest(), target);
+  }
+
+  // bytes pakeCredentialFinalization = 4;
+  if (_internal_has_pakecredentialfinalization()) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_pakecredentialfinalization(), target);
+  }
+
+  // bytes pakeChallengeResponse = 5;
+  if (_internal_has_pakechallengeresponse()) {
+    target = stream->WriteBytesMaybeAliased(
+        5, this->_internal_pakechallengeresponse(), target);
+  }
+
+  // bytes walletAuthenticationRequest = 6;
+  if (_internal_has_walletauthenticationrequest()) {
+    target = stream->WriteBytesMaybeAliased(
+        6, this->_internal_walletauthenticationrequest(), target);
+  }
+
+  // string userID = 7;
+  if (this->userid().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "backup.FullAuthenticationRequestData.userID");
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_userid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:backup.FullAuthenticationRequestData)
+  return target;
+}
+
+size_t FullAuthenticationRequestData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.FullAuthenticationRequestData)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string userID = 7;
+  if (this->userid().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_userid());
+  }
+
+  switch (requestBytes_case()) {
+    // bytes pakeRegistrationRequest = 1;
+    case kPakeRegistrationRequest: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_pakeregistrationrequest());
+      break;
+    }
+    // bytes pakeRegistrationUpload = 2;
+    case kPakeRegistrationUpload: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_pakeregistrationupload());
+      break;
+    }
+    // bytes pakeCredentialRequest = 3;
+    case kPakeCredentialRequest: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_pakecredentialrequest());
+      break;
+    }
+    // bytes pakeCredentialFinalization = 4;
+    case kPakeCredentialFinalization: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_pakecredentialfinalization());
+      break;
+    }
+    // bytes pakeChallengeResponse = 5;
+    case kPakeChallengeResponse: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_pakechallengeresponse());
+      break;
+    }
+    // bytes walletAuthenticationRequest = 6;
+    case kWalletAuthenticationRequest: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_walletauthenticationrequest());
+      break;
+    }
+    case REQUESTBYTES_NOT_SET: {
+      break;
+    }
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void FullAuthenticationRequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.FullAuthenticationRequestData)
+  GOOGLE_DCHECK_NE(&from, this);
+  const FullAuthenticationRequestData* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<FullAuthenticationRequestData>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.FullAuthenticationRequestData)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.FullAuthenticationRequestData)
+    MergeFrom(*source);
+  }
+}
+
+void FullAuthenticationRequestData::MergeFrom(const FullAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.FullAuthenticationRequestData)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.userid().size() > 0) {
+    _internal_set_userid(from._internal_userid());
+  }
+  switch (from.requestBytes_case()) {
+    case kPakeRegistrationRequest: {
+      _internal_set_pakeregistrationrequest(from._internal_pakeregistrationrequest());
+      break;
+    }
+    case kPakeRegistrationUpload: {
+      _internal_set_pakeregistrationupload(from._internal_pakeregistrationupload());
+      break;
+    }
+    case kPakeCredentialRequest: {
+      _internal_set_pakecredentialrequest(from._internal_pakecredentialrequest());
+      break;
+    }
+    case kPakeCredentialFinalization: {
+      _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
+      break;
+    }
+    case kPakeChallengeResponse: {
+      _internal_set_pakechallengeresponse(from._internal_pakechallengeresponse());
+      break;
+    }
+    case kWalletAuthenticationRequest: {
+      _internal_set_walletauthenticationrequest(from._internal_walletauthenticationrequest());
+      break;
+    }
+    case REQUESTBYTES_NOT_SET: {
+      break;
+    }
+  }
+}
+
+void FullAuthenticationRequestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.FullAuthenticationRequestData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void FullAuthenticationRequestData::CopyFrom(const FullAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.FullAuthenticationRequestData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FullAuthenticationRequestData::IsInitialized() const {
+  return true;
+}
+
+void FullAuthenticationRequestData::InternalSwap(FullAuthenticationRequestData* other) {
+  using std::swap;
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+  userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  swap(requestBytes_, other->requestBytes_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FullAuthenticationRequestData::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class FullAuthenticationResponseData::_Internal {
+ public:
+};
+
+FullAuthenticationResponseData::FullAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:backup.FullAuthenticationResponseData)
+}
+FullAuthenticationResponseData::FullAuthenticationResponseData(const FullAuthenticationResponseData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_responseData();
+  switch (from.responseData_case()) {
+    case kPakeRegistrationResponse: {
+      _internal_set_pakeregistrationresponse(from._internal_pakeregistrationresponse());
+      break;
+    }
+    case kPakeRegistrationSuccess: {
+      _internal_set_pakeregistrationsuccess(from._internal_pakeregistrationsuccess());
+      break;
+    }
+    case kPakeCredentialResponse: {
+      _internal_set_pakecredentialresponse(from._internal_pakecredentialresponse());
+      break;
+    }
+    case kPakeChallengeMessage: {
+      _internal_set_pakechallengemessage(from._internal_pakechallengemessage());
+      break;
+    }
+    case kWalletAuthenticationResponse: {
+      _internal_set_walletauthenticationresponse(from._internal_walletauthenticationresponse());
+      break;
+    }
+    case RESPONSEDATA_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:backup.FullAuthenticationResponseData)
+}
+
+void FullAuthenticationResponseData::SharedCtor() {
+clear_has_responseData();
+}
+
+FullAuthenticationResponseData::~FullAuthenticationResponseData() {
+  // @@protoc_insertion_point(destructor:backup.FullAuthenticationResponseData)
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void FullAuthenticationResponseData::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  if (has_responseData()) {
+    clear_responseData();
+  }
+}
+
+void FullAuthenticationResponseData::ArenaDtor(void* object) {
+  FullAuthenticationResponseData* _this = reinterpret_cast< FullAuthenticationResponseData* >(object);
+  (void)_this;
+}
+void FullAuthenticationResponseData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FullAuthenticationResponseData::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FullAuthenticationResponseData::clear_responseData() {
+// @@protoc_insertion_point(one_of_clear_start:backup.FullAuthenticationResponseData)
+  switch (responseData_case()) {
+    case kPakeRegistrationResponse: {
+      responseData_.pakeregistrationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case kPakeRegistrationSuccess: {
+      // No need to clear
+      break;
+    }
+    case kPakeCredentialResponse: {
+      responseData_.pakecredentialresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case kPakeChallengeMessage: {
+      responseData_.pakechallengemessage_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case kWalletAuthenticationResponse: {
+      responseData_.walletauthenticationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case RESPONSEDATA_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = RESPONSEDATA_NOT_SET;
+}
+
+
+void FullAuthenticationResponseData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.FullAuthenticationResponseData)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_responseData();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FullAuthenticationResponseData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // bytes pakeRegistrationResponse = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          auto str = _internal_mutable_pakeregistrationresponse();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bool pakeRegistrationSuccess = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+          _internal_set_pakeregistrationsuccess(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bytes pakeCredentialResponse = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+          auto str = _internal_mutable_pakecredentialresponse();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bytes pakeChallengeMessage = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+          auto str = _internal_mutable_pakechallengemessage();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bytes walletAuthenticationResponse = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
+          auto str = _internal_mutable_walletauthenticationresponse();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* FullAuthenticationResponseData::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:backup.FullAuthenticationResponseData)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes pakeRegistrationResponse = 1;
+  if (_internal_has_pakeregistrationresponse()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_pakeregistrationresponse(), target);
+  }
+
+  // bool pakeRegistrationSuccess = 2;
+  if (_internal_has_pakeregistrationsuccess()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_pakeregistrationsuccess(), target);
+  }
+
+  // bytes pakeCredentialResponse = 3;
+  if (_internal_has_pakecredentialresponse()) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_pakecredentialresponse(), target);
+  }
+
+  // bytes pakeChallengeMessage = 4;
+  if (_internal_has_pakechallengemessage()) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_pakechallengemessage(), target);
+  }
+
+  // bytes walletAuthenticationResponse = 5;
+  if (_internal_has_walletauthenticationresponse()) {
+    target = stream->WriteBytesMaybeAliased(
+        5, this->_internal_walletauthenticationresponse(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:backup.FullAuthenticationResponseData)
+  return target;
+}
+
+size_t FullAuthenticationResponseData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.FullAuthenticationResponseData)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (responseData_case()) {
+    // bytes pakeRegistrationResponse = 1;
+    case kPakeRegistrationResponse: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_pakeregistrationresponse());
+      break;
+    }
+    // bool pakeRegistrationSuccess = 2;
+    case kPakeRegistrationSuccess: {
+      total_size += 1 + 1;
+      break;
+    }
+    // bytes pakeCredentialResponse = 3;
+    case kPakeCredentialResponse: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_pakecredentialresponse());
+      break;
+    }
+    // bytes pakeChallengeMessage = 4;
+    case kPakeChallengeMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_pakechallengemessage());
+      break;
+    }
+    // bytes walletAuthenticationResponse = 5;
+    case kWalletAuthenticationResponse: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_walletauthenticationresponse());
+      break;
+    }
+    case RESPONSEDATA_NOT_SET: {
+      break;
+    }
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void FullAuthenticationResponseData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.FullAuthenticationResponseData)
+  GOOGLE_DCHECK_NE(&from, this);
+  const FullAuthenticationResponseData* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<FullAuthenticationResponseData>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.FullAuthenticationResponseData)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.FullAuthenticationResponseData)
+    MergeFrom(*source);
+  }
+}
+
+void FullAuthenticationResponseData::MergeFrom(const FullAuthenticationResponseData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.FullAuthenticationResponseData)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.responseData_case()) {
+    case kPakeRegistrationResponse: {
+      _internal_set_pakeregistrationresponse(from._internal_pakeregistrationresponse());
+      break;
+    }
+    case kPakeRegistrationSuccess: {
+      _internal_set_pakeregistrationsuccess(from._internal_pakeregistrationsuccess());
+      break;
+    }
+    case kPakeCredentialResponse: {
+      _internal_set_pakecredentialresponse(from._internal_pakecredentialresponse());
+      break;
+    }
+    case kPakeChallengeMessage: {
+      _internal_set_pakechallengemessage(from._internal_pakechallengemessage());
+      break;
+    }
+    case kWalletAuthenticationResponse: {
+      _internal_set_walletauthenticationresponse(from._internal_walletauthenticationresponse());
+      break;
+    }
+    case RESPONSEDATA_NOT_SET: {
+      break;
+    }
+  }
+}
+
+void FullAuthenticationResponseData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.FullAuthenticationResponseData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void FullAuthenticationResponseData::CopyFrom(const FullAuthenticationResponseData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.FullAuthenticationResponseData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FullAuthenticationResponseData::IsInitialized() const {
+  return true;
+}
+
+void FullAuthenticationResponseData::InternalSwap(FullAuthenticationResponseData* other) {
+  using std::swap;
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+  swap(responseData_, other->responseData_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FullAuthenticationResponseData::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class SimpleAuthenticationRequestData::_Internal {
+ public:
+};
+
+SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:backup.SimpleAuthenticationRequestData)
+}
+SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(const SimpleAuthenticationRequestData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from._internal_backupid().empty()) {
+    backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_backupid(), 
+      GetArena());
+  }
+  userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from._internal_userid().empty()) {
+    userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), 
+      GetArena());
+  }
+  // @@protoc_insertion_point(copy_constructor:backup.SimpleAuthenticationRequestData)
+}
+
+void SimpleAuthenticationRequestData::SharedCtor() {
+backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+SimpleAuthenticationRequestData::~SimpleAuthenticationRequestData() {
+  // @@protoc_insertion_point(destructor:backup.SimpleAuthenticationRequestData)
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void SimpleAuthenticationRequestData::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  backupid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void SimpleAuthenticationRequestData::ArenaDtor(void* object) {
+  SimpleAuthenticationRequestData* _this = reinterpret_cast< SimpleAuthenticationRequestData* >(object);
+  (void)_this;
+}
+void SimpleAuthenticationRequestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void SimpleAuthenticationRequestData::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void SimpleAuthenticationRequestData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.SimpleAuthenticationRequestData)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  backupid_.ClearToEmpty();
+  userid_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SimpleAuthenticationRequestData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // string backupID = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          auto str = _internal_mutable_backupid();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SimpleAuthenticationRequestData.backupID"));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string userID = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          auto str = _internal_mutable_userid();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SimpleAuthenticationRequestData.userID"));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* SimpleAuthenticationRequestData::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:backup.SimpleAuthenticationRequestData)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string backupID = 1;
+  if (this->backupid().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_backupid().data(), static_cast<int>(this->_internal_backupid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "backup.SimpleAuthenticationRequestData.backupID");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_backupid(), target);
+  }
+
+  // string userID = 2;
+  if (this->userid().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "backup.SimpleAuthenticationRequestData.userID");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_userid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:backup.SimpleAuthenticationRequestData)
+  return target;
+}
+
+size_t SimpleAuthenticationRequestData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.SimpleAuthenticationRequestData)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string backupID = 1;
+  if (this->backupid().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_backupid());
+  }
+
+  // string userID = 2;
+  if (this->userid().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_userid());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleAuthenticationRequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.SimpleAuthenticationRequestData)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleAuthenticationRequestData* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SimpleAuthenticationRequestData>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.SimpleAuthenticationRequestData)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.SimpleAuthenticationRequestData)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleAuthenticationRequestData::MergeFrom(const SimpleAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.SimpleAuthenticationRequestData)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.backupid().size() > 0) {
+    _internal_set_backupid(from._internal_backupid());
+  }
+  if (from.userid().size() > 0) {
+    _internal_set_userid(from._internal_userid());
+  }
+}
+
+void SimpleAuthenticationRequestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.SimpleAuthenticationRequestData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleAuthenticationRequestData::CopyFrom(const SimpleAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.SimpleAuthenticationRequestData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleAuthenticationRequestData::IsInitialized() const {
+  return true;
+}
+
+void SimpleAuthenticationRequestData::InternalSwap(SimpleAuthenticationRequestData* other) {
+  using std::swap;
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+  backupid_.Swap(&other->backupid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SimpleAuthenticationRequestData::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class AuthenticationInformationData::_Internal {
+ public:
+};
+
+AuthenticationInformationData::AuthenticationInformationData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:backup.AuthenticationInformationData)
+}
+AuthenticationInformationData::AuthenticationInformationData(const AuthenticationInformationData& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_data();
+  switch (from.data_case()) {
+    case kNonce: {
+      _internal_set_nonce(from._internal_nonce());
+      break;
+    }
+    case kRawMessage: {
+      _internal_set_rawmessage(from._internal_rawmessage());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:backup.AuthenticationInformationData)
+}
+
+void AuthenticationInformationData::SharedCtor() {
+clear_has_data();
+}
+
+AuthenticationInformationData::~AuthenticationInformationData() {
+  // @@protoc_insertion_point(destructor:backup.AuthenticationInformationData)
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void AuthenticationInformationData::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  if (has_data()) {
+    clear_data();
+  }
+}
+
+void AuthenticationInformationData::ArenaDtor(void* object) {
+  AuthenticationInformationData* _this = reinterpret_cast< AuthenticationInformationData* >(object);
+  (void)_this;
+}
+void AuthenticationInformationData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void AuthenticationInformationData::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void AuthenticationInformationData::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.AuthenticationInformationData)
+  switch (data_case()) {
+    case kNonce: {
+      data_.nonce_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case kRawMessage: {
+      data_.rawmessage_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void AuthenticationInformationData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.AuthenticationInformationData)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_data();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* AuthenticationInformationData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // bytes nonce = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          auto str = _internal_mutable_nonce();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bytes rawMessage = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          auto str = _internal_mutable_rawmessage();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* AuthenticationInformationData::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:backup.AuthenticationInformationData)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes nonce = 1;
+  if (_internal_has_nonce()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_nonce(), target);
+  }
+
+  // bytes rawMessage = 2;
+  if (_internal_has_rawmessage()) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_rawmessage(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:backup.AuthenticationInformationData)
+  return target;
+}
+
+size_t AuthenticationInformationData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.AuthenticationInformationData)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (data_case()) {
+    // bytes nonce = 1;
+    case kNonce: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_nonce());
+      break;
+    }
+    // bytes rawMessage = 2;
+    case kRawMessage: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_rawmessage());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void AuthenticationInformationData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.AuthenticationInformationData)
+  GOOGLE_DCHECK_NE(&from, this);
+  const AuthenticationInformationData* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<AuthenticationInformationData>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.AuthenticationInformationData)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.AuthenticationInformationData)
+    MergeFrom(*source);
+  }
+}
+
+void AuthenticationInformationData::MergeFrom(const AuthenticationInformationData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.AuthenticationInformationData)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.data_case()) {
+    case kNonce: {
+      _internal_set_nonce(from._internal_nonce());
+      break;
+    }
+    case kRawMessage: {
+      _internal_set_rawmessage(from._internal_rawmessage());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
+  }
+}
+
+void AuthenticationInformationData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.AuthenticationInformationData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AuthenticationInformationData::CopyFrom(const AuthenticationInformationData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.AuthenticationInformationData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AuthenticationInformationData::IsInitialized() const {
+  return true;
+}
+
+void AuthenticationInformationData::InternalSwap(AuthenticationInformationData* other) {
+  using std::swap;
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+  swap(data_, other->data_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata AuthenticationInformationData::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class CreateNewBackupRequest::_Internal {
+ public:
+  static const ::backup::FullAuthenticationRequestData& authenticationrequestdata(const CreateNewBackupRequest* msg);
+  static const ::backup::AuthenticationInformationData& authenticationinformationdata(const CreateNewBackupRequest* msg);
+};
+
+const ::backup::FullAuthenticationRequestData&
+CreateNewBackupRequest::_Internal::authenticationrequestdata(const CreateNewBackupRequest* msg) {
+  return *msg->data_.authenticationrequestdata_;
+}
+const ::backup::AuthenticationInformationData&
+CreateNewBackupRequest::_Internal::authenticationinformationdata(const CreateNewBackupRequest* msg) {
+  return *msg->data_.authenticationinformationdata_;
+}
+void CreateNewBackupRequest::set_allocated_authenticationrequestdata(::backup::FullAuthenticationRequestData* authenticationrequestdata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  clear_data();
+  if (authenticationrequestdata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationrequestdata);
+    if (message_arena != submessage_arena) {
+      authenticationrequestdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, authenticationrequestdata, submessage_arena);
+    }
+    set_has_authenticationrequestdata();
+    data_.authenticationrequestdata_ = authenticationrequestdata;
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.authenticationRequestData)
+}
+void CreateNewBackupRequest::set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  clear_data();
+  if (authenticationinformationdata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationinformationdata);
+    if (message_arena != submessage_arena) {
+      authenticationinformationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, authenticationinformationdata, submessage_arena);
+    }
+    set_has_authenticationinformationdata();
+    data_.authenticationinformationdata_ = authenticationinformationdata;
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.authenticationInformationData)
+}
+CreateNewBackupRequest::CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:backup.CreateNewBackupRequest)
+}
+CreateNewBackupRequest::CreateNewBackupRequest(const CreateNewBackupRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_data();
+  switch (from.data_case()) {
+    case kAuthenticationRequestData: {
+      _internal_mutable_authenticationrequestdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationrequestdata());
+      break;
+    }
+    case kAuthenticationInformationData: {
+      _internal_mutable_authenticationinformationdata()->::backup::AuthenticationInformationData::MergeFrom(from._internal_authenticationinformationdata());
+      break;
+    }
+    case kNewCompactionChunk: {
+      _internal_set_newcompactionchunk(from._internal_newcompactionchunk());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:backup.CreateNewBackupRequest)
+}
+
+void CreateNewBackupRequest::SharedCtor() {
+clear_has_data();
+}
+
+CreateNewBackupRequest::~CreateNewBackupRequest() {
+  // @@protoc_insertion_point(destructor:backup.CreateNewBackupRequest)
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void CreateNewBackupRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  if (has_data()) {
+    clear_data();
+  }
+}
+
+void CreateNewBackupRequest::ArenaDtor(void* object) {
+  CreateNewBackupRequest* _this = reinterpret_cast< CreateNewBackupRequest* >(object);
+  (void)_this;
+}
+void CreateNewBackupRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void CreateNewBackupRequest::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void CreateNewBackupRequest::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.CreateNewBackupRequest)
+  switch (data_case()) {
+    case kAuthenticationRequestData: {
+      if (GetArena() == nullptr) {
+        delete data_.authenticationrequestdata_;
+      }
+      break;
+    }
+    case kAuthenticationInformationData: {
+      if (GetArena() == nullptr) {
+        delete data_.authenticationinformationdata_;
+      }
+      break;
+    }
+    case kNewCompactionChunk: {
+      data_.newcompactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void CreateNewBackupRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.CreateNewBackupRequest)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_data();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CreateNewBackupRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_authenticationrequestdata(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // .backup.AuthenticationInformationData authenticationInformationData = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_authenticationinformationdata(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bytes newCompactionChunk = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+          auto str = _internal_mutable_newcompactionchunk();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* CreateNewBackupRequest::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:backup.CreateNewBackupRequest)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
+  if (_internal_has_authenticationrequestdata()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::authenticationrequestdata(this), target, stream);
+  }
+
+  // .backup.AuthenticationInformationData authenticationInformationData = 2;
+  if (_internal_has_authenticationinformationdata()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::authenticationinformationdata(this), target, stream);
+  }
+
+  // bytes newCompactionChunk = 3;
+  if (_internal_has_newcompactionchunk()) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_newcompactionchunk(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:backup.CreateNewBackupRequest)
+  return target;
+}
+
+size_t CreateNewBackupRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.CreateNewBackupRequest)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (data_case()) {
+    // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
+    case kAuthenticationRequestData: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *data_.authenticationrequestdata_);
+      break;
+    }
+    // .backup.AuthenticationInformationData authenticationInformationData = 2;
+    case kAuthenticationInformationData: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *data_.authenticationinformationdata_);
+      break;
+    }
+    // bytes newCompactionChunk = 3;
+    case kNewCompactionChunk: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_newcompactionchunk());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void CreateNewBackupRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.CreateNewBackupRequest)
+  GOOGLE_DCHECK_NE(&from, this);
+  const CreateNewBackupRequest* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CreateNewBackupRequest>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.CreateNewBackupRequest)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.CreateNewBackupRequest)
+    MergeFrom(*source);
+  }
+}
+
+void CreateNewBackupRequest::MergeFrom(const CreateNewBackupRequest& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.CreateNewBackupRequest)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.data_case()) {
+    case kAuthenticationRequestData: {
+      _internal_mutable_authenticationrequestdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationrequestdata());
+      break;
+    }
+    case kAuthenticationInformationData: {
+      _internal_mutable_authenticationinformationdata()->::backup::AuthenticationInformationData::MergeFrom(from._internal_authenticationinformationdata());
+      break;
+    }
+    case kNewCompactionChunk: {
+      _internal_set_newcompactionchunk(from._internal_newcompactionchunk());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
+  }
+}
+
+void CreateNewBackupRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.CreateNewBackupRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateNewBackupRequest::CopyFrom(const CreateNewBackupRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.CreateNewBackupRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateNewBackupRequest::IsInitialized() const {
+  return true;
+}
+
+void CreateNewBackupRequest::InternalSwap(CreateNewBackupRequest* other) {
+  using std::swap;
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+  swap(data_, other->data_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CreateNewBackupRequest::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
 
 // ===================================================================
 
-class ResetKeyRequest::_Internal {
+class CreateNewBackupResponse::_Internal {
  public:
+  static const ::backup::FullAuthenticationResponseData& authenticationresponsedata(const CreateNewBackupResponse* msg);
 };
 
-ResetKeyRequest::ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+const ::backup::FullAuthenticationResponseData&
+CreateNewBackupResponse::_Internal::authenticationresponsedata(const CreateNewBackupResponse* msg) {
+  return *msg->data_.authenticationresponsedata_;
+}
+void CreateNewBackupResponse::set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  clear_data();
+  if (authenticationresponsedata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationresponsedata);
+    if (message_arena != submessage_arena) {
+      authenticationresponsedata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, authenticationresponsedata, submessage_arena);
+    }
+    set_has_authenticationresponsedata();
+    data_.authenticationresponsedata_ = authenticationresponsedata;
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupResponse.authenticationResponseData)
+}
+CreateNewBackupResponse::CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
   SharedCtor();
   RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:backup.ResetKeyRequest)
+  // @@protoc_insertion_point(arena_constructor:backup.CreateNewBackupResponse)
 }
-ResetKeyRequest::ResetKeyRequest(const ResetKeyRequest& from)
+CreateNewBackupResponse::CreateNewBackupResponse(const CreateNewBackupResponse& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_userid().empty()) {
-    userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), 
-      GetArena());
-  }
   clear_has_data();
   switch (from.data_case()) {
-    case kNewKey: {
-      _internal_set_newkey(from._internal_newkey());
+    case kAuthenticationResponseData: {
+      _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
       break;
     }
-    case kCompactionChunk: {
-      _internal_set_compactionchunk(from._internal_compactionchunk());
+    case kBackupID: {
+      _internal_set_backupid(from._internal_backupid());
       break;
     }
     case DATA_NOT_SET: {
       break;
     }
   }
-  // @@protoc_insertion_point(copy_constructor:backup.ResetKeyRequest)
+  // @@protoc_insertion_point(copy_constructor:backup.CreateNewBackupResponse)
 }
 
-void ResetKeyRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+void CreateNewBackupResponse::SharedCtor() {
 clear_has_data();
 }
 
-ResetKeyRequest::~ResetKeyRequest() {
-  // @@protoc_insertion_point(destructor:backup.ResetKeyRequest)
+CreateNewBackupResponse::~CreateNewBackupResponse() {
+  // @@protoc_insertion_point(destructor:backup.CreateNewBackupResponse)
   SharedDtor();
   _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-void ResetKeyRequest::SharedDtor() {
+void CreateNewBackupResponse::SharedDtor() {
   GOOGLE_DCHECK(GetArena() == nullptr);
-  userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   if (has_data()) {
     clear_data();
   }
 }
 
-void ResetKeyRequest::ArenaDtor(void* object) {
-  ResetKeyRequest* _this = reinterpret_cast< ResetKeyRequest* >(object);
+void CreateNewBackupResponse::ArenaDtor(void* object) {
+  CreateNewBackupResponse* _this = reinterpret_cast< CreateNewBackupResponse* >(object);
   (void)_this;
 }
-void ResetKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+void CreateNewBackupResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 }
-void ResetKeyRequest::SetCachedSize(int size) const {
+void CreateNewBackupResponse::SetCachedSize(int size) const {
   _cached_size_.Set(size);
 }
 
-void ResetKeyRequest::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.CreateNewBackupResponse)
   switch (data_case()) {
-    case kNewKey: {
-      data_.newkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    case kAuthenticationResponseData: {
+      if (GetArena() == nullptr) {
+        delete data_.authenticationresponsedata_;
+      }
       break;
     }
-    case kCompactionChunk: {
-      data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+    case kBackupID: {
+      data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
       break;
     }
     case DATA_NOT_SET: {
@@ -288,46 +2082,36 @@
 }
 
 
-void ResetKeyRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.CreateNewBackupResponse)
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  userid_.ClearToEmpty();
   clear_data();
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* ResetKeyRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* CreateNewBackupResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
   while (!ctx->Done(&ptr)) {
     ::PROTOBUF_NAMESPACE_ID::uint32 tag;
     ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
     CHK_(ptr);
     switch (tag >> 3) {
-      // string userId = 1;
+      // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_userid();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.ResetKeyRequest.userId"));
+          ptr = ctx->ParseMessage(_internal_mutable_authenticationresponsedata(), ptr);
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
-      // bytes newKey = 2;
+      // string backupID = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_newkey();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // bytes compactionChunk = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          auto str = _internal_mutable_compactionchunk();
+          auto str = _internal_mutable_backupid();
           ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.CreateNewBackupResponse.backupID"));
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
@@ -353,70 +2137,59 @@
 #undef CHK_
 }
 
-::PROTOBUF_NAMESPACE_ID::uint8* ResetKeyRequest::_InternalSerialize(
+::PROTOBUF_NAMESPACE_ID::uint8* CreateNewBackupResponse::_InternalSerialize(
     ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:backup.ResetKeyRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:backup.CreateNewBackupResponse)
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // string userId = 1;
-  if (this->userid().size() > 0) {
+  // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+  if (_internal_has_authenticationresponsedata()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::authenticationresponsedata(this), target, stream);
+  }
+
+  // string backupID = 2;
+  if (_internal_has_backupid()) {
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
+      this->_internal_backupid().data(), static_cast<int>(this->_internal_backupid().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "backup.ResetKeyRequest.userId");
+      "backup.CreateNewBackupResponse.backupID");
     target = stream->WriteStringMaybeAliased(
-        1, this->_internal_userid(), target);
-  }
-
-  // bytes newKey = 2;
-  if (_internal_has_newkey()) {
-    target = stream->WriteBytesMaybeAliased(
-        2, this->_internal_newkey(), target);
-  }
-
-  // bytes compactionChunk = 3;
-  if (_internal_has_compactionchunk()) {
-    target = stream->WriteBytesMaybeAliased(
-        3, this->_internal_compactionchunk(), target);
+        2, this->_internal_backupid(), target);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:backup.ResetKeyRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:backup.CreateNewBackupResponse)
   return target;
 }
 
-size_t ResetKeyRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:backup.ResetKeyRequest)
+size_t CreateNewBackupResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.CreateNewBackupResponse)
   size_t total_size = 0;
 
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // string userId = 1;
-  if (this->userid().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_userid());
-  }
-
   switch (data_case()) {
-    // bytes newKey = 2;
-    case kNewKey: {
+    // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+    case kAuthenticationResponseData: {
       total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-          this->_internal_newkey());
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *data_.authenticationresponsedata_);
       break;
     }
-    // bytes compactionChunk = 3;
-    case kCompactionChunk: {
+    // string backupID = 2;
+    case kBackupID: {
       total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-          this->_internal_compactionchunk());
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_backupid());
       break;
     }
     case DATA_NOT_SET: {
@@ -432,38 +2205,35 @@
   return total_size;
 }
 
-void ResetKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.CreateNewBackupResponse)
   GOOGLE_DCHECK_NE(&from, this);
-  const ResetKeyRequest* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResetKeyRequest>(
+  const CreateNewBackupResponse* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CreateNewBackupResponse>(
           &from);
   if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.ResetKeyRequest)
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.CreateNewBackupResponse)
     ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
   } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.ResetKeyRequest)
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.CreateNewBackupResponse)
     MergeFrom(*source);
   }
 }
 
-void ResetKeyRequest::MergeFrom(const ResetKeyRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::MergeFrom(const CreateNewBackupResponse& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.CreateNewBackupResponse)
   GOOGLE_DCHECK_NE(&from, this);
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from.userid().size() > 0) {
-    _internal_set_userid(from._internal_userid());
-  }
   switch (from.data_case()) {
-    case kNewKey: {
-      _internal_set_newkey(from._internal_newkey());
+    case kAuthenticationResponseData: {
+      _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
       break;
     }
-    case kCompactionChunk: {
-      _internal_set_compactionchunk(from._internal_compactionchunk());
+    case kBackupID: {
+      _internal_set_backupid(from._internal_backupid());
       break;
     }
     case DATA_NOT_SET: {
@@ -472,33 +2242,32 @@
   }
 }
 
-void ResetKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.CreateNewBackupResponse)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void ResetKeyRequest::CopyFrom(const ResetKeyRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::CopyFrom(const CreateNewBackupResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.CreateNewBackupResponse)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool ResetKeyRequest::IsInitialized() const {
+bool CreateNewBackupResponse::IsInitialized() const {
   return true;
 }
 
-void ResetKeyRequest::InternalSwap(ResetKeyRequest* other) {
+void CreateNewBackupResponse::InternalSwap(CreateNewBackupResponse* other) {
   using std::swap;
   _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
-  userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
   swap(data_, other->data_);
   swap(_oneof_case_[0], other->_oneof_case_[0]);
 }
 
-::PROTOBUF_NAMESPACE_ID::Metadata ResetKeyRequest::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata CreateNewBackupResponse::GetMetadata() const {
   return GetMetadataStatic();
 }
 
@@ -507,8 +2276,13 @@
 
 class SendLogRequest::_Internal {
  public:
+  static const ::backup::SimpleAuthenticationRequestData& authenticationdata(const SendLogRequest* msg);
 };
 
+const ::backup::SimpleAuthenticationRequestData&
+SendLogRequest::_Internal::authenticationdata(const SendLogRequest* msg) {
+  return *msg->authenticationdata_;
+}
 SendLogRequest::SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
   SharedCtor();
@@ -518,22 +2292,22 @@
 SendLogRequest::SendLogRequest(const SendLogRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_userid().empty()) {
-    userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), 
+  logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from._internal_logdata().empty()) {
+    logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_logdata(), 
       GetArena());
   }
-  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_data().empty()) {
-    data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), 
-      GetArena());
+  if (from._internal_has_authenticationdata()) {
+    authenticationdata_ = new ::backup::SimpleAuthenticationRequestData(*from.authenticationdata_);
+  } else {
+    authenticationdata_ = nullptr;
   }
   // @@protoc_insertion_point(copy_constructor:backup.SendLogRequest)
 }
 
 void SendLogRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+authenticationdata_ = nullptr;
 }
 
 SendLogRequest::~SendLogRequest() {
@@ -544,8 +2318,8 @@
 
 void SendLogRequest::SharedDtor() {
   GOOGLE_DCHECK(GetArena() == nullptr);
-  userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  logdata_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete authenticationdata_;
 }
 
 void SendLogRequest::ArenaDtor(void* object) {
@@ -564,8 +2338,11 @@
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  userid_.ClearToEmpty();
-  data_.ClearToEmpty();
+  logdata_.ClearToEmpty();
+  if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+    delete authenticationdata_;
+  }
+  authenticationdata_ = nullptr;
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
@@ -576,19 +2353,17 @@
     ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
     CHK_(ptr);
     switch (tag >> 3) {
-      // string userId = 1;
+      // .backup.SimpleAuthenticationRequestData authenticationData = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_userid();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SendLogRequest.userId"));
+          ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr);
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
-      // bytes data = 2;
+      // bytes logData = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_data();
+          auto str = _internal_mutable_logdata();
           ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
         } else goto handle_unusual;
@@ -621,20 +2396,18 @@
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // string userId = 1;
-  if (this->userid().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "backup.SendLogRequest.userId");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_userid(), target);
+  // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+  if (this->has_authenticationdata()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::authenticationdata(this), target, stream);
   }
 
-  // bytes data = 2;
-  if (this->data().size() > 0) {
+  // bytes logData = 2;
+  if (this->logdata().size() > 0) {
     target = stream->WriteBytesMaybeAliased(
-        2, this->_internal_data(), target);
+        2, this->_internal_logdata(), target);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -653,18 +2426,18 @@
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // string userId = 1;
-  if (this->userid().size() > 0) {
+  // bytes logData = 2;
+  if (this->logdata().size() > 0) {
     total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_userid());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_logdata());
   }
 
-  // bytes data = 2;
-  if (this->data().size() > 0) {
+  // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+  if (this->has_authenticationdata()) {
     total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_data());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *authenticationdata_);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -698,11 +2471,11 @@
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from.userid().size() > 0) {
-    _internal_set_userid(from._internal_userid());
+  if (from.logdata().size() > 0) {
+    _internal_set_logdata(from._internal_logdata());
   }
-  if (from.data().size() > 0) {
-    _internal_set_data(from._internal_data());
+  if (from.has_authenticationdata()) {
+    _internal_mutable_authenticationdata()->::backup::SimpleAuthenticationRequestData::MergeFrom(from._internal_authenticationdata());
   }
 }
 
@@ -727,8 +2500,8 @@
 void SendLogRequest::InternalSwap(SendLogRequest* other) {
   using std::swap;
   _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
-  userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  logdata_.Swap(&other->logdata_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  swap(authenticationdata_, other->authenticationdata_);
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata SendLogRequest::GetMetadata() const {
@@ -738,91 +2511,81 @@
 
 // ===================================================================
 
-class PullBackupKeyRequest::_Internal {
+class RecoverBackupKeyRequest::_Internal {
  public:
+  static const ::backup::FullAuthenticationRequestData& authenticationdata(const RecoverBackupKeyRequest* msg);
 };
 
-PullBackupKeyRequest::PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+const ::backup::FullAuthenticationRequestData&
+RecoverBackupKeyRequest::_Internal::authenticationdata(const RecoverBackupKeyRequest* msg) {
+  return *msg->authenticationdata_;
+}
+RecoverBackupKeyRequest::RecoverBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
   SharedCtor();
   RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:backup.PullBackupKeyRequest)
+  // @@protoc_insertion_point(arena_constructor:backup.RecoverBackupKeyRequest)
 }
-PullBackupKeyRequest::PullBackupKeyRequest(const PullBackupKeyRequest& from)
+RecoverBackupKeyRequest::RecoverBackupKeyRequest(const RecoverBackupKeyRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_userid().empty()) {
-    userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), 
-      GetArena());
-  }
-  pakekey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_pakekey().empty()) {
-    pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakekey(), 
-      GetArena());
+  if (from._internal_has_authenticationdata()) {
+    authenticationdata_ = new ::backup::FullAuthenticationRequestData(*from.authenticationdata_);
+  } else {
+    authenticationdata_ = nullptr;
   }
-  // @@protoc_insertion_point(copy_constructor:backup.PullBackupKeyRequest)
+  // @@protoc_insertion_point(copy_constructor:backup.RecoverBackupKeyRequest)
 }
 
-void PullBackupKeyRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-pakekey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+void RecoverBackupKeyRequest::SharedCtor() {
+authenticationdata_ = nullptr;
 }
 
-PullBackupKeyRequest::~PullBackupKeyRequest() {
-  // @@protoc_insertion_point(destructor:backup.PullBackupKeyRequest)
+RecoverBackupKeyRequest::~RecoverBackupKeyRequest() {
+  // @@protoc_insertion_point(destructor:backup.RecoverBackupKeyRequest)
   SharedDtor();
   _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-void PullBackupKeyRequest::SharedDtor() {
+void RecoverBackupKeyRequest::SharedDtor() {
   GOOGLE_DCHECK(GetArena() == nullptr);
-  userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  pakekey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete authenticationdata_;
 }
 
-void PullBackupKeyRequest::ArenaDtor(void* object) {
-  PullBackupKeyRequest* _this = reinterpret_cast< PullBackupKeyRequest* >(object);
+void RecoverBackupKeyRequest::ArenaDtor(void* object) {
+  RecoverBackupKeyRequest* _this = reinterpret_cast< RecoverBackupKeyRequest* >(object);
   (void)_this;
 }
-void PullBackupKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+void RecoverBackupKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 }
-void PullBackupKeyRequest::SetCachedSize(int size) const {
+void RecoverBackupKeyRequest::SetCachedSize(int size) const {
   _cached_size_.Set(size);
 }
 
-void PullBackupKeyRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:backup.PullBackupKeyRequest)
+void RecoverBackupKeyRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.RecoverBackupKeyRequest)
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  userid_.ClearToEmpty();
-  pakekey_.ClearToEmpty();
+  if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+    delete authenticationdata_;
+  }
+  authenticationdata_ = nullptr;
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* PullBackupKeyRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* RecoverBackupKeyRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
   while (!ctx->Done(&ptr)) {
     ::PROTOBUF_NAMESPACE_ID::uint32 tag;
     ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
     CHK_(ptr);
     switch (tag >> 3) {
-      // string userId = 1;
+      // .backup.FullAuthenticationRequestData authenticationData = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_userid();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupKeyRequest.userId"));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // bytes pakeKey = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_pakekey();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr);
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
@@ -848,56 +2611,41 @@
 #undef CHK_
 }
 
-::PROTOBUF_NAMESPACE_ID::uint8* PullBackupKeyRequest::_InternalSerialize(
+::PROTOBUF_NAMESPACE_ID::uint8* RecoverBackupKeyRequest::_InternalSerialize(
     ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupKeyRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:backup.RecoverBackupKeyRequest)
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // string userId = 1;
-  if (this->userid().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "backup.PullBackupKeyRequest.userId");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_userid(), target);
-  }
-
-  // bytes pakeKey = 2;
-  if (this->pakekey().size() > 0) {
-    target = stream->WriteBytesMaybeAliased(
-        2, this->_internal_pakekey(), target);
+  // .backup.FullAuthenticationRequestData authenticationData = 1;
+  if (this->has_authenticationdata()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::authenticationdata(this), target, stream);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupKeyRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:backup.RecoverBackupKeyRequest)
   return target;
 }
 
-size_t PullBackupKeyRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupKeyRequest)
+size_t RecoverBackupKeyRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.RecoverBackupKeyRequest)
   size_t total_size = 0;
 
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // string userId = 1;
-  if (this->userid().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_userid());
-  }
-
-  // bytes pakeKey = 2;
-  if (this->pakekey().size() > 0) {
+  // .backup.FullAuthenticationRequestData authenticationData = 1;
+  if (this->has_authenticationdata()) {
     total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_pakekey());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *authenticationdata_);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -909,136 +2657,229 @@
   return total_size;
 }
 
-void PullBackupKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupKeyRequest)
+void RecoverBackupKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.RecoverBackupKeyRequest)
   GOOGLE_DCHECK_NE(&from, this);
-  const PullBackupKeyRequest* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupKeyRequest>(
+  const RecoverBackupKeyRequest* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RecoverBackupKeyRequest>(
           &from);
   if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupKeyRequest)
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.RecoverBackupKeyRequest)
     ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
   } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupKeyRequest)
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.RecoverBackupKeyRequest)
     MergeFrom(*source);
   }
 }
 
-void PullBackupKeyRequest::MergeFrom(const PullBackupKeyRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupKeyRequest)
+void RecoverBackupKeyRequest::MergeFrom(const RecoverBackupKeyRequest& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.RecoverBackupKeyRequest)
   GOOGLE_DCHECK_NE(&from, this);
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from.userid().size() > 0) {
-    _internal_set_userid(from._internal_userid());
-  }
-  if (from.pakekey().size() > 0) {
-    _internal_set_pakekey(from._internal_pakekey());
+  if (from.has_authenticationdata()) {
+    _internal_mutable_authenticationdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationdata());
   }
 }
 
-void PullBackupKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupKeyRequest)
+void RecoverBackupKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.RecoverBackupKeyRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void PullBackupKeyRequest::CopyFrom(const PullBackupKeyRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupKeyRequest)
+void RecoverBackupKeyRequest::CopyFrom(const RecoverBackupKeyRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.RecoverBackupKeyRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool PullBackupKeyRequest::IsInitialized() const {
+bool RecoverBackupKeyRequest::IsInitialized() const {
   return true;
 }
 
-void PullBackupKeyRequest::InternalSwap(PullBackupKeyRequest* other) {
+void RecoverBackupKeyRequest::InternalSwap(RecoverBackupKeyRequest* other) {
   using std::swap;
   _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
-  userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  pakekey_.Swap(&other->pakekey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  swap(authenticationdata_, other->authenticationdata_);
 }
 
-::PROTOBUF_NAMESPACE_ID::Metadata PullBackupKeyRequest::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata RecoverBackupKeyRequest::GetMetadata() const {
   return GetMetadataStatic();
 }
 
 
 // ===================================================================
 
-class PullBackupKeyResponse::_Internal {
+class RecoverBackupKeyResponse::_Internal {
  public:
+  static const ::backup::FullAuthenticationResponseData& authenticationresponsedata(const RecoverBackupKeyResponse* msg);
+  static const ::backup::AuthenticationInformationData& authenticationinformationdata(const RecoverBackupKeyResponse* msg);
 };
 
-PullBackupKeyResponse::PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+const ::backup::FullAuthenticationResponseData&
+RecoverBackupKeyResponse::_Internal::authenticationresponsedata(const RecoverBackupKeyResponse* msg) {
+  return *msg->data_.authenticationresponsedata_;
+}
+const ::backup::AuthenticationInformationData&
+RecoverBackupKeyResponse::_Internal::authenticationinformationdata(const RecoverBackupKeyResponse* msg) {
+  return *msg->data_.authenticationinformationdata_;
+}
+void RecoverBackupKeyResponse::set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  clear_data();
+  if (authenticationresponsedata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationresponsedata);
+    if (message_arena != submessage_arena) {
+      authenticationresponsedata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, authenticationresponsedata, submessage_arena);
+    }
+    set_has_authenticationresponsedata();
+    data_.authenticationresponsedata_ = authenticationresponsedata;
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyResponse.authenticationResponseData)
+}
+void RecoverBackupKeyResponse::set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  clear_data();
+  if (authenticationinformationdata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationinformationdata);
+    if (message_arena != submessage_arena) {
+      authenticationinformationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, authenticationinformationdata, submessage_arena);
+    }
+    set_has_authenticationinformationdata();
+    data_.authenticationinformationdata_ = authenticationinformationdata;
+  }
+  // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyResponse.authenticationInformationData)
+}
+RecoverBackupKeyResponse::RecoverBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
   SharedCtor();
   RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:backup.PullBackupKeyResponse)
+  // @@protoc_insertion_point(arena_constructor:backup.RecoverBackupKeyResponse)
 }
-PullBackupKeyResponse::PullBackupKeyResponse(const PullBackupKeyResponse& from)
+RecoverBackupKeyResponse::RecoverBackupKeyResponse(const RecoverBackupKeyResponse& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  encryptedbackupkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_encryptedbackupkey().empty()) {
-    encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_encryptedbackupkey(), 
-      GetArena());
+  clear_has_data();
+  switch (from.data_case()) {
+    case kAuthenticationResponseData: {
+      _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
+      break;
+    }
+    case kAuthenticationInformationData: {
+      _internal_mutable_authenticationinformationdata()->::backup::AuthenticationInformationData::MergeFrom(from._internal_authenticationinformationdata());
+      break;
+    }
+    case kBackupID: {
+      _internal_set_backupid(from._internal_backupid());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
   }
-  // @@protoc_insertion_point(copy_constructor:backup.PullBackupKeyResponse)
+  // @@protoc_insertion_point(copy_constructor:backup.RecoverBackupKeyResponse)
 }
 
-void PullBackupKeyResponse::SharedCtor() {
-encryptedbackupkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+void RecoverBackupKeyResponse::SharedCtor() {
+clear_has_data();
 }
 
-PullBackupKeyResponse::~PullBackupKeyResponse() {
-  // @@protoc_insertion_point(destructor:backup.PullBackupKeyResponse)
+RecoverBackupKeyResponse::~RecoverBackupKeyResponse() {
+  // @@protoc_insertion_point(destructor:backup.RecoverBackupKeyResponse)
   SharedDtor();
   _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-void PullBackupKeyResponse::SharedDtor() {
+void RecoverBackupKeyResponse::SharedDtor() {
   GOOGLE_DCHECK(GetArena() == nullptr);
-  encryptedbackupkey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (has_data()) {
+    clear_data();
+  }
 }
 
-void PullBackupKeyResponse::ArenaDtor(void* object) {
-  PullBackupKeyResponse* _this = reinterpret_cast< PullBackupKeyResponse* >(object);
+void RecoverBackupKeyResponse::ArenaDtor(void* object) {
+  RecoverBackupKeyResponse* _this = reinterpret_cast< RecoverBackupKeyResponse* >(object);
   (void)_this;
 }
-void PullBackupKeyResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+void RecoverBackupKeyResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 }
-void PullBackupKeyResponse::SetCachedSize(int size) const {
+void RecoverBackupKeyResponse::SetCachedSize(int size) const {
   _cached_size_.Set(size);
 }
 
-void PullBackupKeyResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:backup.PullBackupKeyResponse)
+void RecoverBackupKeyResponse::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.RecoverBackupKeyResponse)
+  switch (data_case()) {
+    case kAuthenticationResponseData: {
+      if (GetArena() == nullptr) {
+        delete data_.authenticationresponsedata_;
+      }
+      break;
+    }
+    case kAuthenticationInformationData: {
+      if (GetArena() == nullptr) {
+        delete data_.authenticationinformationdata_;
+      }
+      break;
+    }
+    case kBackupID: {
+      data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void RecoverBackupKeyResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.RecoverBackupKeyResponse)
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  encryptedbackupkey_.ClearToEmpty();
+  clear_data();
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* PullBackupKeyResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* RecoverBackupKeyResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
   while (!ctx->Done(&ptr)) {
     ::PROTOBUF_NAMESPACE_ID::uint32 tag;
     ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
     CHK_(ptr);
     switch (tag >> 3) {
-      // bytes encryptedBackupKey = 1;
+      // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_encryptedbackupkey();
+          ptr = ctx->ParseMessage(_internal_mutable_authenticationresponsedata(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // .backup.AuthenticationInformationData authenticationInformationData = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_authenticationinformationdata(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string backupID = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+          auto str = _internal_mutable_backupid();
           ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.RecoverBackupKeyResponse.backupID"));
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
@@ -1064,41 +2905,80 @@
 #undef CHK_
 }
 
-::PROTOBUF_NAMESPACE_ID::uint8* PullBackupKeyResponse::_InternalSerialize(
+::PROTOBUF_NAMESPACE_ID::uint8* RecoverBackupKeyResponse::_InternalSerialize(
     ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupKeyResponse)
+  // @@protoc_insertion_point(serialize_to_array_start:backup.RecoverBackupKeyResponse)
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // bytes encryptedBackupKey = 1;
-  if (this->encryptedbackupkey().size() > 0) {
-    target = stream->WriteBytesMaybeAliased(
-        1, this->_internal_encryptedbackupkey(), target);
+  // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+  if (_internal_has_authenticationresponsedata()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::authenticationresponsedata(this), target, stream);
+  }
+
+  // .backup.AuthenticationInformationData authenticationInformationData = 2;
+  if (_internal_has_authenticationinformationdata()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::authenticationinformationdata(this), target, stream);
+  }
+
+  // string backupID = 3;
+  if (_internal_has_backupid()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_backupid().data(), static_cast<int>(this->_internal_backupid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "backup.RecoverBackupKeyResponse.backupID");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_backupid(), target);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupKeyResponse)
+  // @@protoc_insertion_point(serialize_to_array_end:backup.RecoverBackupKeyResponse)
   return target;
 }
 
-size_t PullBackupKeyResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupKeyResponse)
+size_t RecoverBackupKeyResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.RecoverBackupKeyResponse)
   size_t total_size = 0;
 
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // bytes encryptedBackupKey = 1;
-  if (this->encryptedbackupkey().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_encryptedbackupkey());
+  switch (data_case()) {
+    // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+    case kAuthenticationResponseData: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *data_.authenticationresponsedata_);
+      break;
+    }
+    // .backup.AuthenticationInformationData authenticationInformationData = 2;
+    case kAuthenticationInformationData: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *data_.authenticationinformationdata_);
+      break;
+    }
+    // string backupID = 3;
+    case kBackupID: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_backupid());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
   }
-
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
         _internal_metadata_, total_size, &_cached_size_);
@@ -1108,149 +2988,154 @@
   return total_size;
 }
 
-void PullBackupKeyResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupKeyResponse)
+void RecoverBackupKeyResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.RecoverBackupKeyResponse)
   GOOGLE_DCHECK_NE(&from, this);
-  const PullBackupKeyResponse* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupKeyResponse>(
+  const RecoverBackupKeyResponse* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RecoverBackupKeyResponse>(
           &from);
   if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupKeyResponse)
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.RecoverBackupKeyResponse)
     ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
   } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupKeyResponse)
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.RecoverBackupKeyResponse)
     MergeFrom(*source);
   }
 }
 
-void PullBackupKeyResponse::MergeFrom(const PullBackupKeyResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupKeyResponse)
+void RecoverBackupKeyResponse::MergeFrom(const RecoverBackupKeyResponse& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.RecoverBackupKeyResponse)
   GOOGLE_DCHECK_NE(&from, this);
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from.encryptedbackupkey().size() > 0) {
-    _internal_set_encryptedbackupkey(from._internal_encryptedbackupkey());
+  switch (from.data_case()) {
+    case kAuthenticationResponseData: {
+      _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
+      break;
+    }
+    case kAuthenticationInformationData: {
+      _internal_mutable_authenticationinformationdata()->::backup::AuthenticationInformationData::MergeFrom(from._internal_authenticationinformationdata());
+      break;
+    }
+    case kBackupID: {
+      _internal_set_backupid(from._internal_backupid());
+      break;
+    }
+    case DATA_NOT_SET: {
+      break;
+    }
   }
 }
 
-void PullBackupKeyResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupKeyResponse)
+void RecoverBackupKeyResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.RecoverBackupKeyResponse)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void PullBackupKeyResponse::CopyFrom(const PullBackupKeyResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupKeyResponse)
+void RecoverBackupKeyResponse::CopyFrom(const RecoverBackupKeyResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.RecoverBackupKeyResponse)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool PullBackupKeyResponse::IsInitialized() const {
+bool RecoverBackupKeyResponse::IsInitialized() const {
   return true;
 }
 
-void PullBackupKeyResponse::InternalSwap(PullBackupKeyResponse* other) {
+void RecoverBackupKeyResponse::InternalSwap(RecoverBackupKeyResponse* other) {
   using std::swap;
   _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
-  encryptedbackupkey_.Swap(&other->encryptedbackupkey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  swap(data_, other->data_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
 }
 
-::PROTOBUF_NAMESPACE_ID::Metadata PullBackupKeyResponse::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata RecoverBackupKeyResponse::GetMetadata() const {
   return GetMetadataStatic();
 }
 
 
 // ===================================================================
 
-class PullCompactionRequest::_Internal {
+class PullBackupRequest::_Internal {
  public:
+  static const ::backup::SimpleAuthenticationRequestData& authenticationdata(const PullBackupRequest* msg);
 };
 
-PullCompactionRequest::PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+const ::backup::SimpleAuthenticationRequestData&
+PullBackupRequest::_Internal::authenticationdata(const PullBackupRequest* msg) {
+  return *msg->authenticationdata_;
+}
+PullBackupRequest::PullBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
   SharedCtor();
   RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:backup.PullCompactionRequest)
+  // @@protoc_insertion_point(arena_constructor:backup.PullBackupRequest)
 }
-PullCompactionRequest::PullCompactionRequest(const PullCompactionRequest& from)
+PullBackupRequest::PullBackupRequest(const PullBackupRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_userid().empty()) {
-    userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), 
-      GetArena());
-  }
-  message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from._internal_message().empty()) {
-    message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_message(), 
-      GetArena());
+  if (from._internal_has_authenticationdata()) {
+    authenticationdata_ = new ::backup::SimpleAuthenticationRequestData(*from.authenticationdata_);
+  } else {
+    authenticationdata_ = nullptr;
   }
-  // @@protoc_insertion_point(copy_constructor:backup.PullCompactionRequest)
+  // @@protoc_insertion_point(copy_constructor:backup.PullBackupRequest)
 }
 
-void PullCompactionRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+void PullBackupRequest::SharedCtor() {
+authenticationdata_ = nullptr;
 }
 
-PullCompactionRequest::~PullCompactionRequest() {
-  // @@protoc_insertion_point(destructor:backup.PullCompactionRequest)
+PullBackupRequest::~PullBackupRequest() {
+  // @@protoc_insertion_point(destructor:backup.PullBackupRequest)
   SharedDtor();
   _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-void PullCompactionRequest::SharedDtor() {
+void PullBackupRequest::SharedDtor() {
   GOOGLE_DCHECK(GetArena() == nullptr);
-  userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete authenticationdata_;
 }
 
-void PullCompactionRequest::ArenaDtor(void* object) {
-  PullCompactionRequest* _this = reinterpret_cast< PullCompactionRequest* >(object);
+void PullBackupRequest::ArenaDtor(void* object) {
+  PullBackupRequest* _this = reinterpret_cast< PullBackupRequest* >(object);
   (void)_this;
 }
-void PullCompactionRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+void PullBackupRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 }
-void PullCompactionRequest::SetCachedSize(int size) const {
+void PullBackupRequest::SetCachedSize(int size) const {
   _cached_size_.Set(size);
 }
 
-void PullCompactionRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:backup.PullCompactionRequest)
+void PullBackupRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.PullBackupRequest)
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  userid_.ClearToEmpty();
-  message_.ClearToEmpty();
+  if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+    delete authenticationdata_;
+  }
+  authenticationdata_ = nullptr;
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* PullCompactionRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* PullBackupRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
   while (!ctx->Done(&ptr)) {
     ::PROTOBUF_NAMESPACE_ID::uint32 tag;
     ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
     CHK_(ptr);
     switch (tag >> 3) {
-      // string userId = 1;
+      // .backup.SimpleAuthenticationRequestData authenticationData = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
-          auto str = _internal_mutable_userid();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullCompactionRequest.userId"));
-          CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      // bytes message = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
-          auto str = _internal_mutable_message();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr);
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
@@ -1276,56 +3161,41 @@
 #undef CHK_
 }
 
-::PROTOBUF_NAMESPACE_ID::uint8* PullCompactionRequest::_InternalSerialize(
+::PROTOBUF_NAMESPACE_ID::uint8* PullBackupRequest::_InternalSerialize(
     ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:backup.PullCompactionRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupRequest)
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // string userId = 1;
-  if (this->userid().size() > 0) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "backup.PullCompactionRequest.userId");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_userid(), target);
-  }
-
-  // bytes message = 2;
-  if (this->message().size() > 0) {
-    target = stream->WriteBytesMaybeAliased(
-        2, this->_internal_message(), target);
+  // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+  if (this->has_authenticationdata()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::authenticationdata(this), target, stream);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:backup.PullCompactionRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupRequest)
   return target;
 }
 
-size_t PullCompactionRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:backup.PullCompactionRequest)
+size_t PullBackupRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupRequest)
   size_t total_size = 0;
 
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // string userId = 1;
-  if (this->userid().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_userid());
-  }
-
-  // bytes message = 2;
-  if (this->message().size() > 0) {
+  // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+  if (this->has_authenticationdata()) {
     total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_message());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *authenticationdata_);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -1337,79 +3207,75 @@
   return total_size;
 }
 
-void PullCompactionRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullCompactionRequest)
+void PullBackupRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupRequest)
   GOOGLE_DCHECK_NE(&from, this);
-  const PullCompactionRequest* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullCompactionRequest>(
+  const PullBackupRequest* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupRequest>(
           &from);
   if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullCompactionRequest)
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupRequest)
     ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
   } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullCompactionRequest)
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupRequest)
     MergeFrom(*source);
   }
 }
 
-void PullCompactionRequest::MergeFrom(const PullCompactionRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullCompactionRequest)
+void PullBackupRequest::MergeFrom(const PullBackupRequest& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupRequest)
   GOOGLE_DCHECK_NE(&from, this);
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from.userid().size() > 0) {
-    _internal_set_userid(from._internal_userid());
-  }
-  if (from.message().size() > 0) {
-    _internal_set_message(from._internal_message());
+  if (from.has_authenticationdata()) {
+    _internal_mutable_authenticationdata()->::backup::SimpleAuthenticationRequestData::MergeFrom(from._internal_authenticationdata());
   }
 }
 
-void PullCompactionRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullCompactionRequest)
+void PullBackupRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void PullCompactionRequest::CopyFrom(const PullCompactionRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullCompactionRequest)
+void PullBackupRequest::CopyFrom(const PullBackupRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool PullCompactionRequest::IsInitialized() const {
+bool PullBackupRequest::IsInitialized() const {
   return true;
 }
 
-void PullCompactionRequest::InternalSwap(PullCompactionRequest* other) {
+void PullBackupRequest::InternalSwap(PullBackupRequest* other) {
   using std::swap;
   _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
-  userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  message_.Swap(&other->message_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  swap(authenticationdata_, other->authenticationdata_);
 }
 
-::PROTOBUF_NAMESPACE_ID::Metadata PullCompactionRequest::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata PullBackupRequest::GetMetadata() const {
   return GetMetadataStatic();
 }
 
 
 // ===================================================================
 
-class PullCompactionResponse::_Internal {
+class PullBackupResponse::_Internal {
  public:
 };
 
-PullCompactionResponse::PullCompactionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+PullBackupResponse::PullBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
   SharedCtor();
   RegisterArenaDtor(arena);
-  // @@protoc_insertion_point(arena_constructor:backup.PullCompactionResponse)
+  // @@protoc_insertion_point(arena_constructor:backup.PullBackupResponse)
 }
-PullCompactionResponse::PullCompactionResponse(const PullCompactionResponse& from)
+PullBackupResponse::PullBackupResponse(const PullBackupResponse& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   clear_has_data();
@@ -1426,38 +3292,38 @@
       break;
     }
   }
-  // @@protoc_insertion_point(copy_constructor:backup.PullCompactionResponse)
+  // @@protoc_insertion_point(copy_constructor:backup.PullBackupResponse)
 }
 
-void PullCompactionResponse::SharedCtor() {
+void PullBackupResponse::SharedCtor() {
 clear_has_data();
 }
 
-PullCompactionResponse::~PullCompactionResponse() {
-  // @@protoc_insertion_point(destructor:backup.PullCompactionResponse)
+PullBackupResponse::~PullBackupResponse() {
+  // @@protoc_insertion_point(destructor:backup.PullBackupResponse)
   SharedDtor();
   _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-void PullCompactionResponse::SharedDtor() {
+void PullBackupResponse::SharedDtor() {
   GOOGLE_DCHECK(GetArena() == nullptr);
   if (has_data()) {
     clear_data();
   }
 }
 
-void PullCompactionResponse::ArenaDtor(void* object) {
-  PullCompactionResponse* _this = reinterpret_cast< PullCompactionResponse* >(object);
+void PullBackupResponse::ArenaDtor(void* object) {
+  PullBackupResponse* _this = reinterpret_cast< PullBackupResponse* >(object);
   (void)_this;
 }
-void PullCompactionResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+void PullBackupResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 }
-void PullCompactionResponse::SetCachedSize(int size) const {
+void PullBackupResponse::SetCachedSize(int size) const {
   _cached_size_.Set(size);
 }
 
-void PullCompactionResponse::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:backup.PullCompactionResponse)
+void PullBackupResponse::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.PullBackupResponse)
   switch (data_case()) {
     case kCompactionChunk: {
       data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
@@ -1475,8 +3341,8 @@
 }
 
 
-void PullCompactionResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:backup.PullCompactionResponse)
+void PullBackupResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.PullBackupResponse)
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -1485,7 +3351,7 @@
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* PullCompactionResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* PullBackupResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
   while (!ctx->Done(&ptr)) {
     ::PROTOBUF_NAMESPACE_ID::uint32 tag;
@@ -1530,9 +3396,9 @@
 #undef CHK_
 }
 
-::PROTOBUF_NAMESPACE_ID::uint8* PullCompactionResponse::_InternalSerialize(
+::PROTOBUF_NAMESPACE_ID::uint8* PullBackupResponse::_InternalSerialize(
     ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:backup.PullCompactionResponse)
+  // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupResponse)
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -1552,12 +3418,12 @@
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:backup.PullCompactionResponse)
+  // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupResponse)
   return target;
 }
 
-size_t PullCompactionResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:backup.PullCompactionResponse)
+size_t PullBackupResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupResponse)
   size_t total_size = 0;
 
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
@@ -1592,23 +3458,23 @@
   return total_size;
 }
 
-void PullCompactionResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullCompactionResponse)
+void PullBackupResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupResponse)
   GOOGLE_DCHECK_NE(&from, this);
-  const PullCompactionResponse* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullCompactionResponse>(
+  const PullBackupResponse* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupResponse>(
           &from);
   if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullCompactionResponse)
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupResponse)
     ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
   } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullCompactionResponse)
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupResponse)
     MergeFrom(*source);
   }
 }
 
-void PullCompactionResponse::MergeFrom(const PullCompactionResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullCompactionResponse)
+void PullBackupResponse::MergeFrom(const PullBackupResponse& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupResponse)
   GOOGLE_DCHECK_NE(&from, this);
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
@@ -1629,32 +3495,32 @@
   }
 }
 
-void PullCompactionResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullCompactionResponse)
+void PullBackupResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupResponse)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void PullCompactionResponse::CopyFrom(const PullCompactionResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullCompactionResponse)
+void PullBackupResponse::CopyFrom(const PullBackupResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupResponse)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool PullCompactionResponse::IsInitialized() const {
+bool PullBackupResponse::IsInitialized() const {
   return true;
 }
 
-void PullCompactionResponse::InternalSwap(PullCompactionResponse* other) {
+void PullBackupResponse::InternalSwap(PullBackupResponse* other) {
   using std::swap;
   _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
   swap(data_, other->data_);
   swap(_oneof_case_[0], other->_oneof_case_[0]);
 }
 
-::PROTOBUF_NAMESPACE_ID::Metadata PullCompactionResponse::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata PullBackupResponse::GetMetadata() const {
   return GetMetadataStatic();
 }
 
@@ -1662,23 +3528,38 @@
 // @@protoc_insertion_point(namespace_scope)
 }  // namespace backup
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_NOINLINE ::backup::ResetKeyRequest* Arena::CreateMaybeMessage< ::backup::ResetKeyRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::backup::ResetKeyRequest >(arena);
+template<> PROTOBUF_NOINLINE ::backup::FullAuthenticationRequestData* Arena::CreateMaybeMessage< ::backup::FullAuthenticationRequestData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::backup::FullAuthenticationRequestData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::FullAuthenticationResponseData* Arena::CreateMaybeMessage< ::backup::FullAuthenticationResponseData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::backup::FullAuthenticationResponseData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::SimpleAuthenticationRequestData* Arena::CreateMaybeMessage< ::backup::SimpleAuthenticationRequestData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::backup::SimpleAuthenticationRequestData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::AuthenticationInformationData* Arena::CreateMaybeMessage< ::backup::AuthenticationInformationData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::backup::AuthenticationInformationData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage< ::backup::CreateNewBackupRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::backup::CreateNewBackupRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage< ::backup::CreateNewBackupResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::backup::CreateNewBackupResponse >(arena);
 }
 template<> PROTOBUF_NOINLINE ::backup::SendLogRequest* Arena::CreateMaybeMessage< ::backup::SendLogRequest >(Arena* arena) {
   return Arena::CreateMessageInternal< ::backup::SendLogRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::backup::PullBackupKeyRequest* Arena::CreateMaybeMessage< ::backup::PullBackupKeyRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::backup::PullBackupKeyRequest >(arena);
+template<> PROTOBUF_NOINLINE ::backup::RecoverBackupKeyRequest* Arena::CreateMaybeMessage< ::backup::RecoverBackupKeyRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::backup::RecoverBackupKeyRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::backup::PullBackupKeyResponse* Arena::CreateMaybeMessage< ::backup::PullBackupKeyResponse >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::backup::PullBackupKeyResponse >(arena);
+template<> PROTOBUF_NOINLINE ::backup::RecoverBackupKeyResponse* Arena::CreateMaybeMessage< ::backup::RecoverBackupKeyResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::backup::RecoverBackupKeyResponse >(arena);
 }
-template<> PROTOBUF_NOINLINE ::backup::PullCompactionRequest* Arena::CreateMaybeMessage< ::backup::PullCompactionRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::backup::PullCompactionRequest >(arena);
+template<> PROTOBUF_NOINLINE ::backup::PullBackupRequest* Arena::CreateMaybeMessage< ::backup::PullBackupRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::backup::PullBackupRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::backup::PullCompactionResponse* Arena::CreateMaybeMessage< ::backup::PullCompactionResponse >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::backup::PullCompactionResponse >(arena);
+template<> PROTOBUF_NOINLINE ::backup::PullBackupResponse* Arena::CreateMaybeMessage< ::backup::PullBackupResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::backup::PullBackupResponse >(arena);
 }
 PROTOBUF_NAMESPACE_CLOSE
 
diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h
--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h
+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h
@@ -92,6 +92,16 @@
     std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) {
       return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>>(PrepareAsyncGetRaw(context, request, cq));
     }
+    // Replacing Send and Get with a single bidirectional streaming RPC
+    std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> OpenStream(::grpc::ClientContext* context) {
+      return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(OpenStreamRaw(context));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> AsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(AsyncOpenStreamRaw(context, cq, tag));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> PrepareAsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(PrepareAsyncOpenStreamRaw(context, cq));
+    }
     class async_interface {
      public:
       virtual ~async_interface() {}
@@ -114,6 +124,8 @@
       virtual void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) = 0;
       virtual void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0;
       virtual void Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ClientReadReactor< ::tunnelbroker::GetResponse>* reactor) = 0;
+      // Replacing Send and Get with a single bidirectional streaming RPC
+      virtual void OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) = 0;
     };
     typedef class async_interface experimental_async_interface;
     virtual class async_interface* async() { return nullptr; }
@@ -134,6 +146,9 @@
     virtual ::grpc::ClientReaderInterface< ::tunnelbroker::GetResponse>* GetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) = 0;
     virtual ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0;
     virtual ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStreamRaw(::grpc::ClientContext* context) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
   };
   class Stub final : public StubInterface {
    public:
@@ -189,6 +204,15 @@
     std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) {
       return std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>>(PrepareAsyncGetRaw(context, request, cq));
     }
+    std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> OpenStream(::grpc::ClientContext* context) {
+      return std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(OpenStreamRaw(context));
+    }
+    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> AsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(AsyncOpenStreamRaw(context, cq, tag));
+    }
+    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> PrepareAsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(PrepareAsyncOpenStreamRaw(context, cq));
+    }
     class async final :
       public StubInterface::async_interface {
      public:
@@ -205,6 +229,7 @@
       void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) override;
       void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override;
       void Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ClientReadReactor< ::tunnelbroker::GetResponse>* reactor) override;
+      void OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) override;
      private:
       friend class Stub;
       explicit async(Stub* stub): stub_(stub) { }
@@ -231,6 +256,9 @@
     ::grpc::ClientReader< ::tunnelbroker::GetResponse>* GetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) override;
     ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) override;
     ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStreamRaw(::grpc::ClientContext* context) override;
+    ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
+    ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
     const ::grpc::internal::RpcMethod rpcmethod_CheckIfPrimaryDeviceOnline_;
     const ::grpc::internal::RpcMethod rpcmethod_BecomeNewPrimaryDevice_;
     const ::grpc::internal::RpcMethod rpcmethod_SendPong_;
@@ -238,6 +266,7 @@
     const ::grpc::internal::RpcMethod rpcmethod_NewSession_;
     const ::grpc::internal::RpcMethod rpcmethod_Send_;
     const ::grpc::internal::RpcMethod rpcmethod_Get_;
+    const ::grpc::internal::RpcMethod rpcmethod_OpenStream_;
   };
   static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
 
@@ -258,6 +287,8 @@
     virtual ::grpc::Status NewSession(::grpc::ServerContext* context, const ::tunnelbroker::NewSessionRequest* request, ::tunnelbroker::NewSessionResponse* response);
     virtual ::grpc::Status Send(::grpc::ServerContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response);
     virtual ::grpc::Status Get(::grpc::ServerContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* writer);
+    // Replacing Send and Get with a single bidirectional streaming RPC
+    virtual ::grpc::Status OpenStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream);
   };
   template <class BaseClass>
   class WithAsyncMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
@@ -399,7 +430,27 @@
       ::grpc::Service::RequestAsyncServerStreaming(6, context, request, writer, new_call_cq, notification_cq, tag);
     }
   };
-  typedef WithAsyncMethod_CheckIfPrimaryDeviceOnline<WithAsyncMethod_BecomeNewPrimaryDevice<WithAsyncMethod_SendPong<WithAsyncMethod_SessionSignature<WithAsyncMethod_NewSession<WithAsyncMethod_Send<WithAsyncMethod_Get<Service > > > > > > > AsyncService;
+  template <class BaseClass>
+  class WithAsyncMethod_OpenStream : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_OpenStream() {
+      ::grpc::Service::MarkMethodAsync(7);
+    }
+    ~WithAsyncMethod_OpenStream() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/)  override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestOpenStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag);
+    }
+  };
+  typedef WithAsyncMethod_CheckIfPrimaryDeviceOnline<WithAsyncMethod_BecomeNewPrimaryDevice<WithAsyncMethod_SendPong<WithAsyncMethod_SessionSignature<WithAsyncMethod_NewSession<WithAsyncMethod_Send<WithAsyncMethod_Get<WithAsyncMethod_OpenStream<Service > > > > > > > > AsyncService;
   template <class BaseClass>
   class WithCallbackMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
    private:
@@ -584,7 +635,30 @@
     virtual ::grpc::ServerWriteReactor< ::tunnelbroker::GetResponse>* Get(
       ::grpc::CallbackServerContext* /*context*/, const ::tunnelbroker::GetRequest* /*request*/)  { return nullptr; }
   };
-  typedef WithCallbackMethod_CheckIfPrimaryDeviceOnline<WithCallbackMethod_BecomeNewPrimaryDevice<WithCallbackMethod_SendPong<WithCallbackMethod_SessionSignature<WithCallbackMethod_NewSession<WithCallbackMethod_Send<WithCallbackMethod_Get<Service > > > > > > > CallbackService;
+  template <class BaseClass>
+  class WithCallbackMethod_OpenStream : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithCallbackMethod_OpenStream() {
+      ::grpc::Service::MarkMethodCallback(7,
+          new ::grpc::internal::CallbackBidiHandler< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>(
+            [this](
+                   ::grpc::CallbackServerContext* context) { return this->OpenStream(context); }));
+    }
+    ~WithCallbackMethod_OpenStream() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/)  override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerBidiReactor< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStream(
+      ::grpc::CallbackServerContext* /*context*/)
+      { return nullptr; }
+  };
+  typedef WithCallbackMethod_CheckIfPrimaryDeviceOnline<WithCallbackMethod_BecomeNewPrimaryDevice<WithCallbackMethod_SendPong<WithCallbackMethod_SessionSignature<WithCallbackMethod_NewSession<WithCallbackMethod_Send<WithCallbackMethod_Get<WithCallbackMethod_OpenStream<Service > > > > > > > > CallbackService;
   typedef CallbackService ExperimentalCallbackService;
   template <class BaseClass>
   class WithGenericMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
@@ -706,6 +780,23 @@
     }
   };
   template <class BaseClass>
+  class WithGenericMethod_OpenStream : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_OpenStream() {
+      ::grpc::Service::MarkMethodGeneric(7);
+    }
+    ~WithGenericMethod_OpenStream() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/)  override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
   class WithRawMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
@@ -846,6 +937,26 @@
     }
   };
   template <class BaseClass>
+  class WithRawMethod_OpenStream : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_OpenStream() {
+      ::grpc::Service::MarkMethodRaw(7);
+    }
+    ~WithRawMethod_OpenStream() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/)  override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestOpenStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
   class WithRawCallbackMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
@@ -1000,6 +1111,29 @@
       ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/)  { return nullptr; }
   };
   template <class BaseClass>
+  class WithRawCallbackMethod_OpenStream : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawCallbackMethod_OpenStream() {
+      ::grpc::Service::MarkMethodRawCallback(7,
+          new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+                   ::grpc::CallbackServerContext* context) { return this->OpenStream(context); }));
+    }
+    ~WithRawCallbackMethod_OpenStream() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/)  override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* OpenStream(
+      ::grpc::CallbackServerContext* /*context*/)
+      { return nullptr; }
+  };
+  template <class BaseClass>
   class WithStreamedUnaryMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc
--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc
+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc
@@ -29,6 +29,7 @@
   "/tunnelbroker.TunnelbrokerService/NewSession",
   "/tunnelbroker.TunnelbrokerService/Send",
   "/tunnelbroker.TunnelbrokerService/Get",
+  "/tunnelbroker.TunnelbrokerService/OpenStream",
 };
 
 std::unique_ptr< TunnelbrokerService::Stub> TunnelbrokerService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
@@ -45,6 +46,7 @@
   , rpcmethod_NewSession_(TunnelbrokerService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
   , rpcmethod_Send_(TunnelbrokerService_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
   , rpcmethod_Get_(TunnelbrokerService_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
+  , rpcmethod_OpenStream_(TunnelbrokerService_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
   {}
 
 ::grpc::Status TunnelbrokerService::Stub::CheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::tunnelbroker::CheckResponse* response) {
@@ -201,6 +203,22 @@
   return ::grpc::internal::ClientAsyncReaderFactory< ::tunnelbroker::GetResponse>::Create(channel_.get(), cq, rpcmethod_Get_, context, request, false, nullptr);
 }
 
+::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::OpenStreamRaw(::grpc::ClientContext* context) {
+  return ::grpc::internal::ClientReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), rpcmethod_OpenStream_, context);
+}
+
+void TunnelbrokerService::Stub::async::OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) {
+  ::grpc::internal::ClientCallbackReaderWriterFactory< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>::Create(stub_->channel_.get(), stub_->rpcmethod_OpenStream_, context, reactor);
+}
+
+::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), cq, rpcmethod_OpenStream_, context, true, tag);
+}
+
+::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), cq, rpcmethod_OpenStream_, context, false, nullptr);
+}
+
 TunnelbrokerService::Service::Service() {
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       TunnelbrokerService_method_names[0],
@@ -272,6 +290,16 @@
              ::grpc::ServerWriter<::tunnelbroker::GetResponse>* writer) {
                return service->Get(ctx, req, writer);
              }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      TunnelbrokerService_method_names[7],
+      ::grpc::internal::RpcMethod::BIDI_STREAMING,
+      new ::grpc::internal::BidiStreamingHandler< TunnelbrokerService::Service, ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>(
+          [](TunnelbrokerService::Service* service,
+             ::grpc::ServerContext* ctx,
+             ::grpc::ServerReaderWriter<::tunnelbroker::InboundMessage,
+             ::tunnelbroker::OutboundMessage>* stream) {
+               return service->OpenStream(ctx, stream);
+             }, this)));
 }
 
 TunnelbrokerService::Service::~Service() {
@@ -326,6 +354,12 @@
   return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
 }
 
+::grpc::Status TunnelbrokerService::Service::OpenStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream) {
+  (void) context;
+  (void) stream;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
 
 }  // namespace tunnelbroker
 
diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h
--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h
+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h
@@ -48,7 +48,7 @@
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
   static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -69,6 +69,9 @@
 class GetResponse;
 struct GetResponseDefaultTypeInternal;
 extern GetResponseDefaultTypeInternal _GetResponse_default_instance_;
+class InboundMessage;
+struct InboundMessageDefaultTypeInternal;
+extern InboundMessageDefaultTypeInternal _InboundMessage_default_instance_;
 class NewPrimaryRequest;
 struct NewPrimaryRequestDefaultTypeInternal;
 extern NewPrimaryRequestDefaultTypeInternal _NewPrimaryRequest_default_instance_;
@@ -81,6 +84,9 @@
 class NewSessionResponse;
 struct NewSessionResponseDefaultTypeInternal;
 extern NewSessionResponseDefaultTypeInternal _NewSessionResponse_default_instance_;
+class OutboundMessage;
+struct OutboundMessageDefaultTypeInternal;
+extern OutboundMessageDefaultTypeInternal _OutboundMessage_default_instance_;
 class PongRequest;
 struct PongRequestDefaultTypeInternal;
 extern PongRequestDefaultTypeInternal _PongRequest_default_instance_;
@@ -99,10 +105,12 @@
 template<> ::tunnelbroker::CheckResponse* Arena::CreateMaybeMessage<::tunnelbroker::CheckResponse>(Arena*);
 template<> ::tunnelbroker::GetRequest* Arena::CreateMaybeMessage<::tunnelbroker::GetRequest>(Arena*);
 template<> ::tunnelbroker::GetResponse* Arena::CreateMaybeMessage<::tunnelbroker::GetResponse>(Arena*);
+template<> ::tunnelbroker::InboundMessage* Arena::CreateMaybeMessage<::tunnelbroker::InboundMessage>(Arena*);
 template<> ::tunnelbroker::NewPrimaryRequest* Arena::CreateMaybeMessage<::tunnelbroker::NewPrimaryRequest>(Arena*);
 template<> ::tunnelbroker::NewPrimaryResponse* Arena::CreateMaybeMessage<::tunnelbroker::NewPrimaryResponse>(Arena*);
 template<> ::tunnelbroker::NewSessionRequest* Arena::CreateMaybeMessage<::tunnelbroker::NewSessionRequest>(Arena*);
 template<> ::tunnelbroker::NewSessionResponse* Arena::CreateMaybeMessage<::tunnelbroker::NewSessionResponse>(Arena*);
+template<> ::tunnelbroker::OutboundMessage* Arena::CreateMaybeMessage<::tunnelbroker::OutboundMessage>(Arena*);
 template<> ::tunnelbroker::PongRequest* Arena::CreateMaybeMessage<::tunnelbroker::PongRequest>(Arena*);
 template<> ::tunnelbroker::SendRequest* Arena::CreateMaybeMessage<::tunnelbroker::SendRequest>(Arena*);
 template<> ::tunnelbroker::SessionSignatureRequest* Arena::CreateMaybeMessage<::tunnelbroker::SessionSignatureRequest>(Arena*);
@@ -622,13 +630,13 @@
   std::string* _internal_mutable_deviceid();
   public:
 
-  // bytes publicKey = 2;
+  // string publicKey = 2;
   void clear_publickey();
   const std::string& publickey() const;
   void set_publickey(const std::string& value);
   void set_publickey(std::string&& value);
   void set_publickey(const char* value);
-  void set_publickey(const void* value, size_t size);
+  void set_publickey(const char* value, size_t size);
   std::string* mutable_publickey();
   std::string* release_publickey();
   void set_allocated_publickey(std::string* publickey);
@@ -1417,24 +1425,24 @@
 };
 // -------------------------------------------------------------------
 
-class CheckRequest PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckRequest) */ {
+class OutboundMessage PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.OutboundMessage) */ {
  public:
-  inline CheckRequest() : CheckRequest(nullptr) {}
-  virtual ~CheckRequest();
-  explicit constexpr CheckRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline OutboundMessage() : OutboundMessage(nullptr) {}
+  virtual ~OutboundMessage();
+  explicit constexpr OutboundMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  CheckRequest(const CheckRequest& from);
-  CheckRequest(CheckRequest&& from) noexcept
-    : CheckRequest() {
+  OutboundMessage(const OutboundMessage& from);
+  OutboundMessage(OutboundMessage&& from) noexcept
+    : OutboundMessage() {
     *this = ::std::move(from);
   }
 
-  inline CheckRequest& operator=(const CheckRequest& from) {
+  inline OutboundMessage& operator=(const OutboundMessage& from) {
     CopyFrom(from);
     return *this;
   }
-  inline CheckRequest& operator=(CheckRequest&& from) noexcept {
+  inline OutboundMessage& operator=(OutboundMessage&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -1452,20 +1460,20 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const CheckRequest& default_instance() {
+  static const OutboundMessage& default_instance() {
     return *internal_default_instance();
   }
-  static inline const CheckRequest* internal_default_instance() {
-    return reinterpret_cast<const CheckRequest*>(
-               &_CheckRequest_default_instance_);
+  static inline const OutboundMessage* internal_default_instance() {
+    return reinterpret_cast<const OutboundMessage*>(
+               &_OutboundMessage_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     7;
 
-  friend void swap(CheckRequest& a, CheckRequest& b) {
+  friend void swap(OutboundMessage& a, OutboundMessage& b) {
     a.Swap(&b);
   }
-  inline void Swap(CheckRequest* other) {
+  inline void Swap(OutboundMessage* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -1473,7 +1481,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(CheckRequest* other) {
+  void UnsafeArenaSwap(OutboundMessage* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -1481,17 +1489,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline CheckRequest* New() const final {
-    return CreateMaybeMessage<CheckRequest>(nullptr);
+  inline OutboundMessage* New() const final {
+    return CreateMaybeMessage<OutboundMessage>(nullptr);
   }
 
-  CheckRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<CheckRequest>(arena);
+  OutboundMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<OutboundMessage>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const CheckRequest& from);
-  void MergeFrom(const CheckRequest& from);
+  void CopyFrom(const OutboundMessage& from);
+  void MergeFrom(const OutboundMessage& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -1505,13 +1513,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(CheckRequest* other);
+  void InternalSwap(OutboundMessage* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "tunnelbroker.CheckRequest";
+    return "tunnelbroker.OutboundMessage";
   }
   protected:
-  explicit CheckRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit OutboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -1530,73 +1538,99 @@
   // accessors -------------------------------------------------------
 
   enum : int {
-    kUserIdFieldNumber = 1,
-    kDeviceTokenFieldNumber = 2,
+    kBlobHashesFieldNumber = 3,
+    kToDeviceIDFieldNumber = 1,
+    kPayloadFieldNumber = 2,
   };
-  // string userId = 1;
-  void clear_userid();
-  const std::string& userid() const;
-  void set_userid(const std::string& value);
-  void set_userid(std::string&& value);
-  void set_userid(const char* value);
-  void set_userid(const char* value, size_t size);
-  std::string* mutable_userid();
-  std::string* release_userid();
-  void set_allocated_userid(std::string* userid);
+  // repeated string blobHashes = 3;
+  int blobhashes_size() const;
   private:
-  const std::string& _internal_userid() const;
-  void _internal_set_userid(const std::string& value);
-  std::string* _internal_mutable_userid();
+  int _internal_blobhashes_size() const;
+  public:
+  void clear_blobhashes();
+  const std::string& blobhashes(int index) const;
+  std::string* mutable_blobhashes(int index);
+  void set_blobhashes(int index, const std::string& value);
+  void set_blobhashes(int index, std::string&& value);
+  void set_blobhashes(int index, const char* value);
+  void set_blobhashes(int index, const char* value, size_t size);
+  std::string* add_blobhashes();
+  void add_blobhashes(const std::string& value);
+  void add_blobhashes(std::string&& value);
+  void add_blobhashes(const char* value);
+  void add_blobhashes(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& blobhashes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_blobhashes();
+  private:
+  const std::string& _internal_blobhashes(int index) const;
+  std::string* _internal_add_blobhashes();
   public:
 
-  // string deviceToken = 2;
-  void clear_devicetoken();
-  const std::string& devicetoken() const;
-  void set_devicetoken(const std::string& value);
-  void set_devicetoken(std::string&& value);
-  void set_devicetoken(const char* value);
-  void set_devicetoken(const char* value, size_t size);
-  std::string* mutable_devicetoken();
-  std::string* release_devicetoken();
-  void set_allocated_devicetoken(std::string* devicetoken);
+  // string toDeviceID = 1;
+  void clear_todeviceid();
+  const std::string& todeviceid() const;
+  void set_todeviceid(const std::string& value);
+  void set_todeviceid(std::string&& value);
+  void set_todeviceid(const char* value);
+  void set_todeviceid(const char* value, size_t size);
+  std::string* mutable_todeviceid();
+  std::string* release_todeviceid();
+  void set_allocated_todeviceid(std::string* todeviceid);
   private:
-  const std::string& _internal_devicetoken() const;
-  void _internal_set_devicetoken(const std::string& value);
-  std::string* _internal_mutable_devicetoken();
+  const std::string& _internal_todeviceid() const;
+  void _internal_set_todeviceid(const std::string& value);
+  std::string* _internal_mutable_todeviceid();
   public:
 
-  // @@protoc_insertion_point(class_scope:tunnelbroker.CheckRequest)
+  // string payload = 2;
+  void clear_payload();
+  const std::string& payload() const;
+  void set_payload(const std::string& value);
+  void set_payload(std::string&& value);
+  void set_payload(const char* value);
+  void set_payload(const char* value, size_t size);
+  std::string* mutable_payload();
+  std::string* release_payload();
+  void set_allocated_payload(std::string* payload);
+  private:
+  const std::string& _internal_payload() const;
+  void _internal_set_payload(const std::string& value);
+  std::string* _internal_mutable_payload();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tunnelbroker.OutboundMessage)
  private:
   class _Internal;
 
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicetoken_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> blobhashes_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr todeviceid_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   friend struct ::TableStruct_tunnelbroker_2eproto;
 };
 // -------------------------------------------------------------------
 
-class CheckResponse PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckResponse) */ {
+class InboundMessage PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.InboundMessage) */ {
  public:
-  inline CheckResponse() : CheckResponse(nullptr) {}
-  virtual ~CheckResponse();
-  explicit constexpr CheckResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline InboundMessage() : InboundMessage(nullptr) {}
+  virtual ~InboundMessage();
+  explicit constexpr InboundMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  CheckResponse(const CheckResponse& from);
-  CheckResponse(CheckResponse&& from) noexcept
-    : CheckResponse() {
+  InboundMessage(const InboundMessage& from);
+  InboundMessage(InboundMessage&& from) noexcept
+    : InboundMessage() {
     *this = ::std::move(from);
   }
 
-  inline CheckResponse& operator=(const CheckResponse& from) {
+  inline InboundMessage& operator=(const InboundMessage& from) {
     CopyFrom(from);
     return *this;
   }
-  inline CheckResponse& operator=(CheckResponse&& from) noexcept {
+  inline InboundMessage& operator=(InboundMessage&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -1614,20 +1648,20 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const CheckResponse& default_instance() {
+  static const InboundMessage& default_instance() {
     return *internal_default_instance();
   }
-  static inline const CheckResponse* internal_default_instance() {
-    return reinterpret_cast<const CheckResponse*>(
-               &_CheckResponse_default_instance_);
+  static inline const InboundMessage* internal_default_instance() {
+    return reinterpret_cast<const InboundMessage*>(
+               &_InboundMessage_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     8;
 
-  friend void swap(CheckResponse& a, CheckResponse& b) {
+  friend void swap(InboundMessage& a, InboundMessage& b) {
     a.Swap(&b);
   }
-  inline void Swap(CheckResponse* other) {
+  inline void Swap(InboundMessage* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -1635,7 +1669,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(CheckResponse* other) {
+  void UnsafeArenaSwap(InboundMessage* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -1643,17 +1677,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline CheckResponse* New() const final {
-    return CreateMaybeMessage<CheckResponse>(nullptr);
+  inline InboundMessage* New() const final {
+    return CreateMaybeMessage<InboundMessage>(nullptr);
   }
 
-  CheckResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<CheckResponse>(arena);
+  InboundMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<InboundMessage>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const CheckResponse& from);
-  void MergeFrom(const CheckResponse& from);
+  void CopyFrom(const InboundMessage& from);
+  void MergeFrom(const InboundMessage& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -1667,13 +1701,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(CheckResponse* other);
+  void InternalSwap(InboundMessage* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "tunnelbroker.CheckResponse";
+    return "tunnelbroker.InboundMessage";
   }
   protected:
-  explicit CheckResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit InboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -1692,48 +1726,117 @@
   // accessors -------------------------------------------------------
 
   enum : int {
-    kCheckResponseTypeFieldNumber = 1,
+    kBlobHashesFieldNumber = 4,
+    kFromDeviceIDFieldNumber = 1,
+    kFromConnectionIDFieldNumber = 2,
+    kPayloadFieldNumber = 3,
   };
-  // .tunnelbroker.CheckResponseType checkResponseType = 1;
-  void clear_checkresponsetype();
-  ::tunnelbroker::CheckResponseType checkresponsetype() const;
-  void set_checkresponsetype(::tunnelbroker::CheckResponseType value);
+  // repeated string blobHashes = 4;
+  int blobhashes_size() const;
   private:
-  ::tunnelbroker::CheckResponseType _internal_checkresponsetype() const;
-  void _internal_set_checkresponsetype(::tunnelbroker::CheckResponseType value);
+  int _internal_blobhashes_size() const;
+  public:
+  void clear_blobhashes();
+  const std::string& blobhashes(int index) const;
+  std::string* mutable_blobhashes(int index);
+  void set_blobhashes(int index, const std::string& value);
+  void set_blobhashes(int index, std::string&& value);
+  void set_blobhashes(int index, const char* value);
+  void set_blobhashes(int index, const char* value, size_t size);
+  std::string* add_blobhashes();
+  void add_blobhashes(const std::string& value);
+  void add_blobhashes(std::string&& value);
+  void add_blobhashes(const char* value);
+  void add_blobhashes(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& blobhashes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_blobhashes();
+  private:
+  const std::string& _internal_blobhashes(int index) const;
+  std::string* _internal_add_blobhashes();
   public:
 
-  // @@protoc_insertion_point(class_scope:tunnelbroker.CheckResponse)
+  // string fromDeviceID = 1;
+  void clear_fromdeviceid();
+  const std::string& fromdeviceid() const;
+  void set_fromdeviceid(const std::string& value);
+  void set_fromdeviceid(std::string&& value);
+  void set_fromdeviceid(const char* value);
+  void set_fromdeviceid(const char* value, size_t size);
+  std::string* mutable_fromdeviceid();
+  std::string* release_fromdeviceid();
+  void set_allocated_fromdeviceid(std::string* fromdeviceid);
+  private:
+  const std::string& _internal_fromdeviceid() const;
+  void _internal_set_fromdeviceid(const std::string& value);
+  std::string* _internal_mutable_fromdeviceid();
+  public:
+
+  // string fromConnectionID = 2;
+  void clear_fromconnectionid();
+  const std::string& fromconnectionid() const;
+  void set_fromconnectionid(const std::string& value);
+  void set_fromconnectionid(std::string&& value);
+  void set_fromconnectionid(const char* value);
+  void set_fromconnectionid(const char* value, size_t size);
+  std::string* mutable_fromconnectionid();
+  std::string* release_fromconnectionid();
+  void set_allocated_fromconnectionid(std::string* fromconnectionid);
+  private:
+  const std::string& _internal_fromconnectionid() const;
+  void _internal_set_fromconnectionid(const std::string& value);
+  std::string* _internal_mutable_fromconnectionid();
+  public:
+
+  // string payload = 3;
+  void clear_payload();
+  const std::string& payload() const;
+  void set_payload(const std::string& value);
+  void set_payload(std::string&& value);
+  void set_payload(const char* value);
+  void set_payload(const char* value, size_t size);
+  std::string* mutable_payload();
+  std::string* release_payload();
+  void set_allocated_payload(std::string* payload);
+  private:
+  const std::string& _internal_payload() const;
+  void _internal_set_payload(const std::string& value);
+  std::string* _internal_mutable_payload();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tunnelbroker.InboundMessage)
  private:
   class _Internal;
 
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  int checkresponsetype_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> blobhashes_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromdeviceid_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromconnectionid_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   friend struct ::TableStruct_tunnelbroker_2eproto;
 };
 // -------------------------------------------------------------------
 
-class NewPrimaryRequest PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryRequest) */ {
+class CheckRequest PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckRequest) */ {
  public:
-  inline NewPrimaryRequest() : NewPrimaryRequest(nullptr) {}
-  virtual ~NewPrimaryRequest();
-  explicit constexpr NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline CheckRequest() : CheckRequest(nullptr) {}
+  virtual ~CheckRequest();
+  explicit constexpr CheckRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  NewPrimaryRequest(const NewPrimaryRequest& from);
-  NewPrimaryRequest(NewPrimaryRequest&& from) noexcept
-    : NewPrimaryRequest() {
+  CheckRequest(const CheckRequest& from);
+  CheckRequest(CheckRequest&& from) noexcept
+    : CheckRequest() {
     *this = ::std::move(from);
   }
 
-  inline NewPrimaryRequest& operator=(const NewPrimaryRequest& from) {
+  inline CheckRequest& operator=(const CheckRequest& from) {
     CopyFrom(from);
     return *this;
   }
-  inline NewPrimaryRequest& operator=(NewPrimaryRequest&& from) noexcept {
+  inline CheckRequest& operator=(CheckRequest&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -1751,20 +1854,20 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const NewPrimaryRequest& default_instance() {
+  static const CheckRequest& default_instance() {
     return *internal_default_instance();
   }
-  static inline const NewPrimaryRequest* internal_default_instance() {
-    return reinterpret_cast<const NewPrimaryRequest*>(
-               &_NewPrimaryRequest_default_instance_);
+  static inline const CheckRequest* internal_default_instance() {
+    return reinterpret_cast<const CheckRequest*>(
+               &_CheckRequest_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     9;
 
-  friend void swap(NewPrimaryRequest& a, NewPrimaryRequest& b) {
+  friend void swap(CheckRequest& a, CheckRequest& b) {
     a.Swap(&b);
   }
-  inline void Swap(NewPrimaryRequest* other) {
+  inline void Swap(CheckRequest* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -1772,7 +1875,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(NewPrimaryRequest* other) {
+  void UnsafeArenaSwap(CheckRequest* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -1780,17 +1883,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline NewPrimaryRequest* New() const final {
-    return CreateMaybeMessage<NewPrimaryRequest>(nullptr);
+  inline CheckRequest* New() const final {
+    return CreateMaybeMessage<CheckRequest>(nullptr);
   }
 
-  NewPrimaryRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<NewPrimaryRequest>(arena);
+  CheckRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<CheckRequest>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const NewPrimaryRequest& from);
-  void MergeFrom(const NewPrimaryRequest& from);
+  void CopyFrom(const CheckRequest& from);
+  void MergeFrom(const CheckRequest& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -1804,13 +1907,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(NewPrimaryRequest* other);
+  void InternalSwap(CheckRequest* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "tunnelbroker.NewPrimaryRequest";
+    return "tunnelbroker.CheckRequest";
   }
   protected:
-  explicit NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit CheckRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -1864,7 +1967,7 @@
   std::string* _internal_mutable_devicetoken();
   public:
 
-  // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryRequest)
+  // @@protoc_insertion_point(class_scope:tunnelbroker.CheckRequest)
  private:
   class _Internal;
 
@@ -1878,24 +1981,24 @@
 };
 // -------------------------------------------------------------------
 
-class NewPrimaryResponse PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryResponse) */ {
+class CheckResponse PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckResponse) */ {
  public:
-  inline NewPrimaryResponse() : NewPrimaryResponse(nullptr) {}
-  virtual ~NewPrimaryResponse();
-  explicit constexpr NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline CheckResponse() : CheckResponse(nullptr) {}
+  virtual ~CheckResponse();
+  explicit constexpr CheckResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  NewPrimaryResponse(const NewPrimaryResponse& from);
-  NewPrimaryResponse(NewPrimaryResponse&& from) noexcept
-    : NewPrimaryResponse() {
+  CheckResponse(const CheckResponse& from);
+  CheckResponse(CheckResponse&& from) noexcept
+    : CheckResponse() {
     *this = ::std::move(from);
   }
 
-  inline NewPrimaryResponse& operator=(const NewPrimaryResponse& from) {
+  inline CheckResponse& operator=(const CheckResponse& from) {
     CopyFrom(from);
     return *this;
   }
-  inline NewPrimaryResponse& operator=(NewPrimaryResponse&& from) noexcept {
+  inline CheckResponse& operator=(CheckResponse&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -1913,20 +2016,20 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const NewPrimaryResponse& default_instance() {
+  static const CheckResponse& default_instance() {
     return *internal_default_instance();
   }
-  static inline const NewPrimaryResponse* internal_default_instance() {
-    return reinterpret_cast<const NewPrimaryResponse*>(
-               &_NewPrimaryResponse_default_instance_);
+  static inline const CheckResponse* internal_default_instance() {
+    return reinterpret_cast<const CheckResponse*>(
+               &_CheckResponse_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     10;
 
-  friend void swap(NewPrimaryResponse& a, NewPrimaryResponse& b) {
+  friend void swap(CheckResponse& a, CheckResponse& b) {
     a.Swap(&b);
   }
-  inline void Swap(NewPrimaryResponse* other) {
+  inline void Swap(CheckResponse* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -1934,7 +2037,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(NewPrimaryResponse* other) {
+  void UnsafeArenaSwap(CheckResponse* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -1942,17 +2045,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline NewPrimaryResponse* New() const final {
-    return CreateMaybeMessage<NewPrimaryResponse>(nullptr);
+  inline CheckResponse* New() const final {
+    return CreateMaybeMessage<CheckResponse>(nullptr);
   }
 
-  NewPrimaryResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<NewPrimaryResponse>(arena);
+  CheckResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<CheckResponse>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const NewPrimaryResponse& from);
-  void MergeFrom(const NewPrimaryResponse& from);
+  void CopyFrom(const CheckResponse& from);
+  void MergeFrom(const CheckResponse& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -1966,13 +2069,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(NewPrimaryResponse* other);
+  void InternalSwap(CheckResponse* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "tunnelbroker.NewPrimaryResponse";
+    return "tunnelbroker.CheckResponse";
   }
   protected:
-  explicit NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit CheckResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -1991,48 +2094,48 @@
   // accessors -------------------------------------------------------
 
   enum : int {
-    kSuccessFieldNumber = 1,
+    kCheckResponseTypeFieldNumber = 1,
   };
-  // bool success = 1;
-  void clear_success();
-  bool success() const;
-  void set_success(bool value);
+  // .tunnelbroker.CheckResponseType checkResponseType = 1;
+  void clear_checkresponsetype();
+  ::tunnelbroker::CheckResponseType checkresponsetype() const;
+  void set_checkresponsetype(::tunnelbroker::CheckResponseType value);
   private:
-  bool _internal_success() const;
-  void _internal_set_success(bool value);
+  ::tunnelbroker::CheckResponseType _internal_checkresponsetype() const;
+  void _internal_set_checkresponsetype(::tunnelbroker::CheckResponseType value);
   public:
 
-  // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryResponse)
+  // @@protoc_insertion_point(class_scope:tunnelbroker.CheckResponse)
  private:
   class _Internal;
 
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  bool success_;
+  int checkresponsetype_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   friend struct ::TableStruct_tunnelbroker_2eproto;
 };
 // -------------------------------------------------------------------
 
-class PongRequest PROTOBUF_FINAL :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.PongRequest) */ {
+class NewPrimaryRequest PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryRequest) */ {
  public:
-  inline PongRequest() : PongRequest(nullptr) {}
-  virtual ~PongRequest();
-  explicit constexpr PongRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline NewPrimaryRequest() : NewPrimaryRequest(nullptr) {}
+  virtual ~NewPrimaryRequest();
+  explicit constexpr NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  PongRequest(const PongRequest& from);
-  PongRequest(PongRequest&& from) noexcept
-    : PongRequest() {
+  NewPrimaryRequest(const NewPrimaryRequest& from);
+  NewPrimaryRequest(NewPrimaryRequest&& from) noexcept
+    : NewPrimaryRequest() {
     *this = ::std::move(from);
   }
 
-  inline PongRequest& operator=(const PongRequest& from) {
+  inline NewPrimaryRequest& operator=(const NewPrimaryRequest& from) {
     CopyFrom(from);
     return *this;
   }
-  inline PongRequest& operator=(PongRequest&& from) noexcept {
+  inline NewPrimaryRequest& operator=(NewPrimaryRequest&& from) noexcept {
     if (GetArena() == from.GetArena()) {
       if (this != &from) InternalSwap(&from);
     } else {
@@ -2050,20 +2153,20 @@
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return GetMetadataStatic().reflection;
   }
-  static const PongRequest& default_instance() {
+  static const NewPrimaryRequest& default_instance() {
     return *internal_default_instance();
   }
-  static inline const PongRequest* internal_default_instance() {
-    return reinterpret_cast<const PongRequest*>(
-               &_PongRequest_default_instance_);
+  static inline const NewPrimaryRequest* internal_default_instance() {
+    return reinterpret_cast<const NewPrimaryRequest*>(
+               &_NewPrimaryRequest_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     11;
 
-  friend void swap(PongRequest& a, PongRequest& b) {
+  friend void swap(NewPrimaryRequest& a, NewPrimaryRequest& b) {
     a.Swap(&b);
   }
-  inline void Swap(PongRequest* other) {
+  inline void Swap(NewPrimaryRequest* other) {
     if (other == this) return;
     if (GetArena() == other->GetArena()) {
       InternalSwap(other);
@@ -2071,7 +2174,7 @@
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(PongRequest* other) {
+  void UnsafeArenaSwap(NewPrimaryRequest* other) {
     if (other == this) return;
     GOOGLE_DCHECK(GetArena() == other->GetArena());
     InternalSwap(other);
@@ -2079,17 +2182,17 @@
 
   // implements Message ----------------------------------------------
 
-  inline PongRequest* New() const final {
-    return CreateMaybeMessage<PongRequest>(nullptr);
+  inline NewPrimaryRequest* New() const final {
+    return CreateMaybeMessage<NewPrimaryRequest>(nullptr);
   }
 
-  PongRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
-    return CreateMaybeMessage<PongRequest>(arena);
+  NewPrimaryRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<NewPrimaryRequest>(arena);
   }
   void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void CopyFrom(const PongRequest& from);
-  void MergeFrom(const PongRequest& from);
+  void CopyFrom(const NewPrimaryRequest& from);
+  void MergeFrom(const NewPrimaryRequest& from);
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
@@ -2103,13 +2206,13 @@
   inline void SharedCtor();
   inline void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(PongRequest* other);
+  void InternalSwap(NewPrimaryRequest* other);
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "tunnelbroker.PongRequest";
+    return "tunnelbroker.NewPrimaryRequest";
   }
   protected:
-  explicit PongRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   private:
   static void ArenaDtor(void* object);
   inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -2163,7 +2266,7 @@
   std::string* _internal_mutable_devicetoken();
   public:
 
-  // @@protoc_insertion_point(class_scope:tunnelbroker.PongRequest)
+  // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryRequest)
  private:
   class _Internal;
 
@@ -2175,726 +2278,1490 @@
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   friend struct ::TableStruct_tunnelbroker_2eproto;
 };
-// ===================================================================
+// -------------------------------------------------------------------
 
+class NewPrimaryResponse PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryResponse) */ {
+ public:
+  inline NewPrimaryResponse() : NewPrimaryResponse(nullptr) {}
+  virtual ~NewPrimaryResponse();
+  explicit constexpr NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-// ===================================================================
+  NewPrimaryResponse(const NewPrimaryResponse& from);
+  NewPrimaryResponse(NewPrimaryResponse&& from) noexcept
+    : NewPrimaryResponse() {
+    *this = ::std::move(from);
+  }
 
-#ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif  // __GNUC__
-// SessionSignatureRequest
+  inline NewPrimaryResponse& operator=(const NewPrimaryResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NewPrimaryResponse& operator=(NewPrimaryResponse&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
 
-// string deviceID = 1;
-inline void SessionSignatureRequest::clear_deviceid() {
-  deviceid_.ClearToEmpty();
-}
-inline const std::string& SessionSignatureRequest::deviceid() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureRequest.deviceID)
-  return _internal_deviceid();
-}
-inline void SessionSignatureRequest::set_deviceid(const std::string& value) {
-  _internal_set_deviceid(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureRequest.deviceID)
-}
-inline std::string* SessionSignatureRequest::mutable_deviceid() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureRequest.deviceID)
-  return _internal_mutable_deviceid();
-}
-inline const std::string& SessionSignatureRequest::_internal_deviceid() const {
-  return deviceid_.Get();
-}
-inline void SessionSignatureRequest::_internal_set_deviceid(const std::string& value) {
-  
-  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void SessionSignatureRequest::set_deviceid(std::string&& value) {
-  
-  deviceid_.Set(
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureRequest.deviceID)
-}
-inline void SessionSignatureRequest::set_deviceid(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureRequest.deviceID)
-}
-inline void SessionSignatureRequest::set_deviceid(const char* value,
-    size_t size) {
-  
-  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureRequest.deviceID)
-}
-inline std::string* SessionSignatureRequest::_internal_mutable_deviceid() {
-  
-  return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* SessionSignatureRequest::release_deviceid() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureRequest.deviceID)
-  return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void SessionSignatureRequest::set_allocated_deviceid(std::string* deviceid) {
-  if (deviceid != nullptr) {
-    
-  } else {
-    
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
   }
-  deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureRequest.deviceID)
-}
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const NewPrimaryResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NewPrimaryResponse* internal_default_instance() {
+    return reinterpret_cast<const NewPrimaryResponse*>(
+               &_NewPrimaryResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
 
-// -------------------------------------------------------------------
+  friend void swap(NewPrimaryResponse& a, NewPrimaryResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NewPrimaryResponse* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NewPrimaryResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
 
-// SessionSignatureResponse
+  // implements Message ----------------------------------------------
 
-// string toSign = 1;
-inline void SessionSignatureResponse::clear_tosign() {
-  tosign_.ClearToEmpty();
-}
-inline const std::string& SessionSignatureResponse::tosign() const {
+  inline NewPrimaryResponse* New() const final {
+    return CreateMaybeMessage<NewPrimaryResponse>(nullptr);
+  }
+
+  NewPrimaryResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<NewPrimaryResponse>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const NewPrimaryResponse& from);
+  void MergeFrom(const NewPrimaryResponse& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NewPrimaryResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tunnelbroker.NewPrimaryResponse";
+  }
+  protected:
+  explicit NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages);
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSuccessFieldNumber = 1,
+  };
+  // bool success = 1;
+  void clear_success();
+  bool success() const;
+  void set_success(bool value);
+  private:
+  bool _internal_success() const;
+  void _internal_set_success(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  bool success_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_tunnelbroker_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PongRequest PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.PongRequest) */ {
+ public:
+  inline PongRequest() : PongRequest(nullptr) {}
+  virtual ~PongRequest();
+  explicit constexpr PongRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PongRequest(const PongRequest& from);
+  PongRequest(PongRequest&& from) noexcept
+    : PongRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline PongRequest& operator=(const PongRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PongRequest& operator=(PongRequest&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const PongRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PongRequest* internal_default_instance() {
+    return reinterpret_cast<const PongRequest*>(
+               &_PongRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(PongRequest& a, PongRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PongRequest* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PongRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PongRequest* New() const final {
+    return CreateMaybeMessage<PongRequest>(nullptr);
+  }
+
+  PongRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PongRequest>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const PongRequest& from);
+  void MergeFrom(const PongRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PongRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tunnelbroker.PongRequest";
+  }
+  protected:
+  explicit PongRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages);
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUserIdFieldNumber = 1,
+    kDeviceTokenFieldNumber = 2,
+  };
+  // string userId = 1;
+  void clear_userid();
+  const std::string& userid() const;
+  void set_userid(const std::string& value);
+  void set_userid(std::string&& value);
+  void set_userid(const char* value);
+  void set_userid(const char* value, size_t size);
+  std::string* mutable_userid();
+  std::string* release_userid();
+  void set_allocated_userid(std::string* userid);
+  private:
+  const std::string& _internal_userid() const;
+  void _internal_set_userid(const std::string& value);
+  std::string* _internal_mutable_userid();
+  public:
+
+  // string deviceToken = 2;
+  void clear_devicetoken();
+  const std::string& devicetoken() const;
+  void set_devicetoken(const std::string& value);
+  void set_devicetoken(std::string&& value);
+  void set_devicetoken(const char* value);
+  void set_devicetoken(const char* value, size_t size);
+  std::string* mutable_devicetoken();
+  std::string* release_devicetoken();
+  void set_allocated_devicetoken(std::string* devicetoken);
+  private:
+  const std::string& _internal_devicetoken() const;
+  void _internal_set_devicetoken(const std::string& value);
+  std::string* _internal_mutable_devicetoken();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tunnelbroker.PongRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicetoken_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_tunnelbroker_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SessionSignatureRequest
+
+// string deviceID = 1;
+inline void SessionSignatureRequest::clear_deviceid() {
+  deviceid_.ClearToEmpty();
+}
+inline const std::string& SessionSignatureRequest::deviceid() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureRequest.deviceID)
+  return _internal_deviceid();
+}
+inline void SessionSignatureRequest::set_deviceid(const std::string& value) {
+  _internal_set_deviceid(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureRequest.deviceID)
+}
+inline std::string* SessionSignatureRequest::mutable_deviceid() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureRequest.deviceID)
+  return _internal_mutable_deviceid();
+}
+inline const std::string& SessionSignatureRequest::_internal_deviceid() const {
+  return deviceid_.Get();
+}
+inline void SessionSignatureRequest::_internal_set_deviceid(const std::string& value) {
+  
+  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void SessionSignatureRequest::set_deviceid(std::string&& value) {
+  
+  deviceid_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureRequest.deviceID)
+}
+inline void SessionSignatureRequest::set_deviceid(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureRequest.deviceID)
+}
+inline void SessionSignatureRequest::set_deviceid(const char* value,
+    size_t size) {
+  
+  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureRequest.deviceID)
+}
+inline std::string* SessionSignatureRequest::_internal_mutable_deviceid() {
+  
+  return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* SessionSignatureRequest::release_deviceid() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureRequest.deviceID)
+  return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void SessionSignatureRequest::set_allocated_deviceid(std::string* deviceid) {
+  if (deviceid != nullptr) {
+    
+  } else {
+    
+  }
+  deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureRequest.deviceID)
+}
+
+// -------------------------------------------------------------------
+
+// SessionSignatureResponse
+
+// string toSign = 1;
+inline void SessionSignatureResponse::clear_tosign() {
+  tosign_.ClearToEmpty();
+}
+inline const std::string& SessionSignatureResponse::tosign() const {
   // @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureResponse.toSign)
   return _internal_tosign();
 }
-inline void SessionSignatureResponse::set_tosign(const std::string& value) {
-  _internal_set_tosign(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureResponse.toSign)
+inline void SessionSignatureResponse::set_tosign(const std::string& value) {
+  _internal_set_tosign(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureResponse.toSign)
+}
+inline std::string* SessionSignatureResponse::mutable_tosign() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureResponse.toSign)
+  return _internal_mutable_tosign();
+}
+inline const std::string& SessionSignatureResponse::_internal_tosign() const {
+  return tosign_.Get();
+}
+inline void SessionSignatureResponse::_internal_set_tosign(const std::string& value) {
+  
+  tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void SessionSignatureResponse::set_tosign(std::string&& value) {
+  
+  tosign_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureResponse.toSign)
+}
+inline void SessionSignatureResponse::set_tosign(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureResponse.toSign)
+}
+inline void SessionSignatureResponse::set_tosign(const char* value,
+    size_t size) {
+  
+  tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureResponse.toSign)
+}
+inline std::string* SessionSignatureResponse::_internal_mutable_tosign() {
+  
+  return tosign_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* SessionSignatureResponse::release_tosign() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureResponse.toSign)
+  return tosign_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void SessionSignatureResponse::set_allocated_tosign(std::string* tosign) {
+  if (tosign != nullptr) {
+    
+  } else {
+    
+  }
+  tosign_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tosign,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureResponse.toSign)
+}
+
+// -------------------------------------------------------------------
+
+// NewSessionRequest
+
+// string deviceID = 1;
+inline void NewSessionRequest::clear_deviceid() {
+  deviceid_.ClearToEmpty();
+}
+inline const std::string& NewSessionRequest::deviceid() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceID)
+  return _internal_deviceid();
+}
+inline void NewSessionRequest::set_deviceid(const std::string& value) {
+  _internal_set_deviceid(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceID)
+}
+inline std::string* NewSessionRequest::mutable_deviceid() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceID)
+  return _internal_mutable_deviceid();
+}
+inline const std::string& NewSessionRequest::_internal_deviceid() const {
+  return deviceid_.Get();
+}
+inline void NewSessionRequest::_internal_set_deviceid(const std::string& value) {
+  
+  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void NewSessionRequest::set_deviceid(std::string&& value) {
+  
+  deviceid_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceID)
+}
+inline void NewSessionRequest::set_deviceid(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceID)
+}
+inline void NewSessionRequest::set_deviceid(const char* value,
+    size_t size) {
+  
+  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceID)
+}
+inline std::string* NewSessionRequest::_internal_mutable_deviceid() {
+  
+  return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* NewSessionRequest::release_deviceid() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceID)
+  return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void NewSessionRequest::set_allocated_deviceid(std::string* deviceid) {
+  if (deviceid != nullptr) {
+    
+  } else {
+    
+  }
+  deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceID)
+}
+
+// string publicKey = 2;
+inline void NewSessionRequest::clear_publickey() {
+  publickey_.ClearToEmpty();
+}
+inline const std::string& NewSessionRequest::publickey() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.publicKey)
+  return _internal_publickey();
+}
+inline void NewSessionRequest::set_publickey(const std::string& value) {
+  _internal_set_publickey(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.publicKey)
+}
+inline std::string* NewSessionRequest::mutable_publickey() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.publicKey)
+  return _internal_mutable_publickey();
+}
+inline const std::string& NewSessionRequest::_internal_publickey() const {
+  return publickey_.Get();
+}
+inline void NewSessionRequest::_internal_set_publickey(const std::string& value) {
+  
+  publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void NewSessionRequest::set_publickey(std::string&& value) {
+  
+  publickey_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.publicKey)
+}
+inline void NewSessionRequest::set_publickey(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.publicKey)
+}
+inline void NewSessionRequest::set_publickey(const char* value,
+    size_t size) {
+  
+  publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.publicKey)
+}
+inline std::string* NewSessionRequest::_internal_mutable_publickey() {
+  
+  return publickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* NewSessionRequest::release_publickey() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.publicKey)
+  return publickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void NewSessionRequest::set_allocated_publickey(std::string* publickey) {
+  if (publickey != nullptr) {
+    
+  } else {
+    
+  }
+  publickey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), publickey,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.publicKey)
+}
+
+// string signature = 3;
+inline void NewSessionRequest::clear_signature() {
+  signature_.ClearToEmpty();
+}
+inline const std::string& NewSessionRequest::signature() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.signature)
+  return _internal_signature();
+}
+inline void NewSessionRequest::set_signature(const std::string& value) {
+  _internal_set_signature(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.signature)
+}
+inline std::string* NewSessionRequest::mutable_signature() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.signature)
+  return _internal_mutable_signature();
+}
+inline const std::string& NewSessionRequest::_internal_signature() const {
+  return signature_.Get();
+}
+inline void NewSessionRequest::_internal_set_signature(const std::string& value) {
+  
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void NewSessionRequest::set_signature(std::string&& value) {
+  
+  signature_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.signature)
+}
+inline void NewSessionRequest::set_signature(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.signature)
+}
+inline void NewSessionRequest::set_signature(const char* value,
+    size_t size) {
+  
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.signature)
+}
+inline std::string* NewSessionRequest::_internal_mutable_signature() {
+  
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* NewSessionRequest::release_signature() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.signature)
+  return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void NewSessionRequest::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    
+  } else {
+    
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.signature)
+}
+
+// string notifyToken = 4;
+inline bool NewSessionRequest::_internal_has_notifytoken() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool NewSessionRequest::has_notifytoken() const {
+  return _internal_has_notifytoken();
+}
+inline void NewSessionRequest::clear_notifytoken() {
+  notifytoken_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& NewSessionRequest::notifytoken() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.notifyToken)
+  return _internal_notifytoken();
+}
+inline void NewSessionRequest::set_notifytoken(const std::string& value) {
+  _internal_set_notifytoken(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.notifyToken)
+}
+inline std::string* NewSessionRequest::mutable_notifytoken() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.notifyToken)
+  return _internal_mutable_notifytoken();
+}
+inline const std::string& NewSessionRequest::_internal_notifytoken() const {
+  return notifytoken_.Get();
+}
+inline void NewSessionRequest::_internal_set_notifytoken(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void NewSessionRequest::set_notifytoken(std::string&& value) {
+  _has_bits_[0] |= 0x00000001u;
+  notifytoken_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.notifyToken)
+}
+inline void NewSessionRequest::set_notifytoken(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _has_bits_[0] |= 0x00000001u;
+  notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.notifyToken)
+}
+inline void NewSessionRequest::set_notifytoken(const char* value,
+    size_t size) {
+  _has_bits_[0] |= 0x00000001u;
+  notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.notifyToken)
+}
+inline std::string* NewSessionRequest::_internal_mutable_notifytoken() {
+  _has_bits_[0] |= 0x00000001u;
+  return notifytoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* NewSessionRequest::release_notifytoken() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.notifyToken)
+  if (!_internal_has_notifytoken()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return notifytoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void NewSessionRequest::set_allocated_notifytoken(std::string* notifytoken) {
+  if (notifytoken != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  notifytoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), notifytoken,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.notifyToken)
+}
+
+// .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5;
+inline void NewSessionRequest::clear_devicetype() {
+  devicetype_ = 0;
+}
+inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::_internal_devicetype() const {
+  return static_cast< ::tunnelbroker::NewSessionRequest_DeviceTypes >(devicetype_);
+}
+inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::devicetype() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceType)
+  return _internal_devicetype();
+}
+inline void NewSessionRequest::_internal_set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
+  
+  devicetype_ = value;
+}
+inline void NewSessionRequest::set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
+  _internal_set_devicetype(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceType)
+}
+
+// string deviceAppVersion = 6;
+inline void NewSessionRequest::clear_deviceappversion() {
+  deviceappversion_.ClearToEmpty();
+}
+inline const std::string& NewSessionRequest::deviceappversion() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceAppVersion)
+  return _internal_deviceappversion();
+}
+inline void NewSessionRequest::set_deviceappversion(const std::string& value) {
+  _internal_set_deviceappversion(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceAppVersion)
+}
+inline std::string* NewSessionRequest::mutable_deviceappversion() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceAppVersion)
+  return _internal_mutable_deviceappversion();
+}
+inline const std::string& NewSessionRequest::_internal_deviceappversion() const {
+  return deviceappversion_.Get();
+}
+inline void NewSessionRequest::_internal_set_deviceappversion(const std::string& value) {
+  
+  deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void NewSessionRequest::set_deviceappversion(std::string&& value) {
+  
+  deviceappversion_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceAppVersion)
+}
+inline void NewSessionRequest::set_deviceappversion(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceAppVersion)
+}
+inline void NewSessionRequest::set_deviceappversion(const char* value,
+    size_t size) {
+  
+  deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceAppVersion)
+}
+inline std::string* NewSessionRequest::_internal_mutable_deviceappversion() {
+  
+  return deviceappversion_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* NewSessionRequest::release_deviceappversion() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceAppVersion)
+  return deviceappversion_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void NewSessionRequest::set_allocated_deviceappversion(std::string* deviceappversion) {
+  if (deviceappversion != nullptr) {
+    
+  } else {
+    
+  }
+  deviceappversion_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceappversion,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceAppVersion)
 }
-inline std::string* SessionSignatureResponse::mutable_tosign() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureResponse.toSign)
-  return _internal_mutable_tosign();
+
+// string deviceOS = 7;
+inline void NewSessionRequest::clear_deviceos() {
+  deviceos_.ClearToEmpty();
 }
-inline const std::string& SessionSignatureResponse::_internal_tosign() const {
-  return tosign_.Get();
+inline const std::string& NewSessionRequest::deviceos() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceOS)
+  return _internal_deviceos();
 }
-inline void SessionSignatureResponse::_internal_set_tosign(const std::string& value) {
+inline void NewSessionRequest::set_deviceos(const std::string& value) {
+  _internal_set_deviceos(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceOS)
+}
+inline std::string* NewSessionRequest::mutable_deviceos() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceOS)
+  return _internal_mutable_deviceos();
+}
+inline const std::string& NewSessionRequest::_internal_deviceos() const {
+  return deviceos_.Get();
+}
+inline void NewSessionRequest::_internal_set_deviceos(const std::string& value) {
   
-  tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void SessionSignatureResponse::set_tosign(std::string&& value) {
+inline void NewSessionRequest::set_deviceos(std::string&& value) {
   
-  tosign_.Set(
+  deviceos_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureResponse.toSign)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceOS)
 }
-inline void SessionSignatureResponse::set_tosign(const char* value) {
+inline void NewSessionRequest::set_deviceos(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureResponse.toSign)
+  deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceOS)
 }
-inline void SessionSignatureResponse::set_tosign(const char* value,
+inline void NewSessionRequest::set_deviceos(const char* value,
     size_t size) {
   
-  tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+  deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureResponse.toSign)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceOS)
 }
-inline std::string* SessionSignatureResponse::_internal_mutable_tosign() {
+inline std::string* NewSessionRequest::_internal_mutable_deviceos() {
   
-  return tosign_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  return deviceos_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* SessionSignatureResponse::release_tosign() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureResponse.toSign)
-  return tosign_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* NewSessionRequest::release_deviceos() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceOS)
+  return deviceos_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void SessionSignatureResponse::set_allocated_tosign(std::string* tosign) {
-  if (tosign != nullptr) {
+inline void NewSessionRequest::set_allocated_deviceos(std::string* deviceos) {
+  if (deviceos != nullptr) {
     
   } else {
     
   }
-  tosign_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tosign,
+  deviceos_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceos,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureResponse.toSign)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceOS)
 }
 
 // -------------------------------------------------------------------
 
-// NewSessionRequest
+// NewSessionResponse
 
-// string deviceID = 1;
-inline void NewSessionRequest::clear_deviceid() {
-  deviceid_.ClearToEmpty();
+// string sessionID = 1;
+inline void NewSessionResponse::clear_sessionid() {
+  sessionid_.ClearToEmpty();
 }
-inline const std::string& NewSessionRequest::deviceid() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceID)
-  return _internal_deviceid();
+inline const std::string& NewSessionResponse::sessionid() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionResponse.sessionID)
+  return _internal_sessionid();
 }
-inline void NewSessionRequest::set_deviceid(const std::string& value) {
-  _internal_set_deviceid(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceID)
+inline void NewSessionResponse::set_sessionid(const std::string& value) {
+  _internal_set_sessionid(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionResponse.sessionID)
 }
-inline std::string* NewSessionRequest::mutable_deviceid() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceID)
-  return _internal_mutable_deviceid();
+inline std::string* NewSessionResponse::mutable_sessionid() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionResponse.sessionID)
+  return _internal_mutable_sessionid();
 }
-inline const std::string& NewSessionRequest::_internal_deviceid() const {
-  return deviceid_.Get();
+inline const std::string& NewSessionResponse::_internal_sessionid() const {
+  return sessionid_.Get();
 }
-inline void NewSessionRequest::_internal_set_deviceid(const std::string& value) {
+inline void NewSessionResponse::_internal_set_sessionid(const std::string& value) {
   
-  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void NewSessionRequest::set_deviceid(std::string&& value) {
+inline void NewSessionResponse::set_sessionid(std::string&& value) {
   
-  deviceid_.Set(
+  sessionid_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceID)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionResponse.sessionID)
 }
-inline void NewSessionRequest::set_deviceid(const char* value) {
+inline void NewSessionResponse::set_sessionid(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceID)
+  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionResponse.sessionID)
 }
-inline void NewSessionRequest::set_deviceid(const char* value,
+inline void NewSessionResponse::set_sessionid(const char* value,
     size_t size) {
   
-  deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceID)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionResponse.sessionID)
 }
-inline std::string* NewSessionRequest::_internal_mutable_deviceid() {
+inline std::string* NewSessionResponse::_internal_mutable_sessionid() {
   
-  return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* NewSessionRequest::release_deviceid() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceID)
-  return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* NewSessionResponse::release_sessionid() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionResponse.sessionID)
+  return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void NewSessionRequest::set_allocated_deviceid(std::string* deviceid) {
-  if (deviceid != nullptr) {
+inline void NewSessionResponse::set_allocated_sessionid(std::string* sessionid) {
+  if (sessionid != nullptr) {
     
   } else {
     
   }
-  deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
+  sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceID)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionResponse.sessionID)
 }
 
-// bytes publicKey = 2;
-inline void NewSessionRequest::clear_publickey() {
-  publickey_.ClearToEmpty();
+// -------------------------------------------------------------------
+
+// SendRequest
+
+// string sessionID = 1;
+inline void SendRequest::clear_sessionid() {
+  sessionid_.ClearToEmpty();
 }
-inline const std::string& NewSessionRequest::publickey() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.publicKey)
-  return _internal_publickey();
+inline const std::string& SendRequest::sessionid() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.sessionID)
+  return _internal_sessionid();
 }
-inline void NewSessionRequest::set_publickey(const std::string& value) {
-  _internal_set_publickey(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.publicKey)
+inline void SendRequest::set_sessionid(const std::string& value) {
+  _internal_set_sessionid(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.sessionID)
 }
-inline std::string* NewSessionRequest::mutable_publickey() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.publicKey)
-  return _internal_mutable_publickey();
+inline std::string* SendRequest::mutable_sessionid() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.sessionID)
+  return _internal_mutable_sessionid();
 }
-inline const std::string& NewSessionRequest::_internal_publickey() const {
-  return publickey_.Get();
+inline const std::string& SendRequest::_internal_sessionid() const {
+  return sessionid_.Get();
 }
-inline void NewSessionRequest::_internal_set_publickey(const std::string& value) {
+inline void SendRequest::_internal_set_sessionid(const std::string& value) {
   
-  publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void NewSessionRequest::set_publickey(std::string&& value) {
+inline void SendRequest::set_sessionid(std::string&& value) {
   
-  publickey_.Set(
+  sessionid_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.publicKey)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.sessionID)
 }
-inline void NewSessionRequest::set_publickey(const char* value) {
+inline void SendRequest::set_sessionid(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.publicKey)
+  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.sessionID)
+}
+inline void SendRequest::set_sessionid(const char* value,
+    size_t size) {
+  
+  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.sessionID)
+}
+inline std::string* SendRequest::_internal_mutable_sessionid() {
+  
+  return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* SendRequest::release_sessionid() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.sessionID)
+  return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void SendRequest::set_allocated_sessionid(std::string* sessionid) {
+  if (sessionid != nullptr) {
+    
+  } else {
+    
+  }
+  sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.sessionID)
+}
+
+// string toDeviceID = 2;
+inline void SendRequest::clear_todeviceid() {
+  todeviceid_.ClearToEmpty();
+}
+inline const std::string& SendRequest::todeviceid() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.toDeviceID)
+  return _internal_todeviceid();
+}
+inline void SendRequest::set_todeviceid(const std::string& value) {
+  _internal_set_todeviceid(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.toDeviceID)
+}
+inline std::string* SendRequest::mutable_todeviceid() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.toDeviceID)
+  return _internal_mutable_todeviceid();
+}
+inline const std::string& SendRequest::_internal_todeviceid() const {
+  return todeviceid_.Get();
+}
+inline void SendRequest::_internal_set_todeviceid(const std::string& value) {
+  
+  todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void SendRequest::set_todeviceid(std::string&& value) {
+  
+  todeviceid_.Set(
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.toDeviceID)
+}
+inline void SendRequest::set_todeviceid(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.toDeviceID)
 }
-inline void NewSessionRequest::set_publickey(const void* value,
+inline void SendRequest::set_todeviceid(const char* value,
     size_t size) {
   
-  publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+  todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.publicKey)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.toDeviceID)
 }
-inline std::string* NewSessionRequest::_internal_mutable_publickey() {
+inline std::string* SendRequest::_internal_mutable_todeviceid() {
   
-  return publickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  return todeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* NewSessionRequest::release_publickey() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.publicKey)
-  return publickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* SendRequest::release_todeviceid() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.toDeviceID)
+  return todeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void NewSessionRequest::set_allocated_publickey(std::string* publickey) {
-  if (publickey != nullptr) {
+inline void SendRequest::set_allocated_todeviceid(std::string* todeviceid) {
+  if (todeviceid != nullptr) {
     
   } else {
     
   }
-  publickey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), publickey,
+  todeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), todeviceid,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.publicKey)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.toDeviceID)
 }
 
-// string signature = 3;
-inline void NewSessionRequest::clear_signature() {
-  signature_.ClearToEmpty();
+// bytes payload = 3;
+inline void SendRequest::clear_payload() {
+  payload_.ClearToEmpty();
 }
-inline const std::string& NewSessionRequest::signature() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.signature)
-  return _internal_signature();
+inline const std::string& SendRequest::payload() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.payload)
+  return _internal_payload();
 }
-inline void NewSessionRequest::set_signature(const std::string& value) {
-  _internal_set_signature(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.signature)
+inline void SendRequest::set_payload(const std::string& value) {
+  _internal_set_payload(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.payload)
 }
-inline std::string* NewSessionRequest::mutable_signature() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.signature)
-  return _internal_mutable_signature();
+inline std::string* SendRequest::mutable_payload() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.payload)
+  return _internal_mutable_payload();
 }
-inline const std::string& NewSessionRequest::_internal_signature() const {
-  return signature_.Get();
+inline const std::string& SendRequest::_internal_payload() const {
+  return payload_.Get();
 }
-inline void NewSessionRequest::_internal_set_signature(const std::string& value) {
+inline void SendRequest::_internal_set_payload(const std::string& value) {
   
-  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void NewSessionRequest::set_signature(std::string&& value) {
+inline void SendRequest::set_payload(std::string&& value) {
   
-  signature_.Set(
+  payload_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.signature)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.payload)
 }
-inline void NewSessionRequest::set_signature(const char* value) {
+inline void SendRequest::set_payload(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.signature)
+  payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.payload)
 }
-inline void NewSessionRequest::set_signature(const char* value,
+inline void SendRequest::set_payload(const void* value,
     size_t size) {
   
-  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+  payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.signature)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.payload)
 }
-inline std::string* NewSessionRequest::_internal_mutable_signature() {
+inline std::string* SendRequest::_internal_mutable_payload() {
   
-  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* NewSessionRequest::release_signature() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.signature)
-  return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* SendRequest::release_payload() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.payload)
+  return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void NewSessionRequest::set_allocated_signature(std::string* signature) {
-  if (signature != nullptr) {
+inline void SendRequest::set_allocated_payload(std::string* payload) {
+  if (payload != nullptr) {
     
   } else {
     
   }
-  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+  payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.signature)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.payload)
 }
 
-// string notifyToken = 4;
-inline bool NewSessionRequest::_internal_has_notifytoken() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
-  return value;
+// repeated string blobHashes = 4;
+inline int SendRequest::_internal_blobhashes_size() const {
+  return blobhashes_.size();
 }
-inline bool NewSessionRequest::has_notifytoken() const {
-  return _internal_has_notifytoken();
+inline int SendRequest::blobhashes_size() const {
+  return _internal_blobhashes_size();
 }
-inline void NewSessionRequest::clear_notifytoken() {
-  notifytoken_.ClearToEmpty();
-  _has_bits_[0] &= ~0x00000001u;
+inline void SendRequest::clear_blobhashes() {
+  blobhashes_.Clear();
 }
-inline const std::string& NewSessionRequest::notifytoken() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.notifyToken)
-  return _internal_notifytoken();
+inline std::string* SendRequest::add_blobhashes() {
+  // @@protoc_insertion_point(field_add_mutable:tunnelbroker.SendRequest.blobHashes)
+  return _internal_add_blobhashes();
 }
-inline void NewSessionRequest::set_notifytoken(const std::string& value) {
-  _internal_set_notifytoken(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.notifyToken)
+inline const std::string& SendRequest::_internal_blobhashes(int index) const {
+  return blobhashes_.Get(index);
 }
-inline std::string* NewSessionRequest::mutable_notifytoken() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.notifyToken)
-  return _internal_mutable_notifytoken();
+inline const std::string& SendRequest::blobhashes(int index) const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.blobHashes)
+  return _internal_blobhashes(index);
 }
-inline const std::string& NewSessionRequest::_internal_notifytoken() const {
-  return notifytoken_.Get();
+inline std::string* SendRequest::mutable_blobhashes(int index) {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.blobHashes)
+  return blobhashes_.Mutable(index);
 }
-inline void NewSessionRequest::_internal_set_notifytoken(const std::string& value) {
-  _has_bits_[0] |= 0x00000001u;
-  notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline void SendRequest::set_blobhashes(int index, const std::string& value) {
+  // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
+  blobhashes_.Mutable(index)->assign(value);
 }
-inline void NewSessionRequest::set_notifytoken(std::string&& value) {
-  _has_bits_[0] |= 0x00000001u;
-  notifytoken_.Set(
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.notifyToken)
+inline void SendRequest::set_blobhashes(int index, std::string&& value) {
+  // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
+  blobhashes_.Mutable(index)->assign(std::move(value));
 }
-inline void NewSessionRequest::set_notifytoken(const char* value) {
+inline void SendRequest::set_blobhashes(int index, const char* value) {
   GOOGLE_DCHECK(value != nullptr);
-  _has_bits_[0] |= 0x00000001u;
-  notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.notifyToken)
-}
-inline void NewSessionRequest::set_notifytoken(const char* value,
-    size_t size) {
-  _has_bits_[0] |= 0x00000001u;
-  notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.notifyToken)
+  blobhashes_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.blobHashes)
 }
-inline std::string* NewSessionRequest::_internal_mutable_notifytoken() {
-  _has_bits_[0] |= 0x00000001u;
-  return notifytoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline void SendRequest::set_blobhashes(int index, const char* value, size_t size) {
+  blobhashes_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.blobHashes)
 }
-inline std::string* NewSessionRequest::release_notifytoken() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.notifyToken)
-  if (!_internal_has_notifytoken()) {
-    return nullptr;
-  }
-  _has_bits_[0] &= ~0x00000001u;
-  return notifytoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* SendRequest::_internal_add_blobhashes() {
+  return blobhashes_.Add();
 }
-inline void NewSessionRequest::set_allocated_notifytoken(std::string* notifytoken) {
-  if (notifytoken != nullptr) {
-    _has_bits_[0] |= 0x00000001u;
-  } else {
-    _has_bits_[0] &= ~0x00000001u;
-  }
-  notifytoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), notifytoken,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.notifyToken)
+inline void SendRequest::add_blobhashes(const std::string& value) {
+  blobhashes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
 }
-
-// .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5;
-inline void NewSessionRequest::clear_devicetype() {
-  devicetype_ = 0;
+inline void SendRequest::add_blobhashes(std::string&& value) {
+  blobhashes_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
 }
-inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::_internal_devicetype() const {
-  return static_cast< ::tunnelbroker::NewSessionRequest_DeviceTypes >(devicetype_);
+inline void SendRequest::add_blobhashes(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  blobhashes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tunnelbroker.SendRequest.blobHashes)
 }
-inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::devicetype() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceType)
-  return _internal_devicetype();
+inline void SendRequest::add_blobhashes(const char* value, size_t size) {
+  blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tunnelbroker.SendRequest.blobHashes)
 }
-inline void NewSessionRequest::_internal_set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
-  
-  devicetype_ = value;
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+SendRequest::blobhashes() const {
+  // @@protoc_insertion_point(field_list:tunnelbroker.SendRequest.blobHashes)
+  return blobhashes_;
 }
-inline void NewSessionRequest::set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
-  _internal_set_devicetype(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceType)
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+SendRequest::mutable_blobhashes() {
+  // @@protoc_insertion_point(field_mutable_list:tunnelbroker.SendRequest.blobHashes)
+  return &blobhashes_;
 }
 
-// string deviceAppVersion = 6;
-inline void NewSessionRequest::clear_deviceappversion() {
-  deviceappversion_.ClearToEmpty();
+// -------------------------------------------------------------------
+
+// GetRequest
+
+// string sessionID = 1;
+inline void GetRequest::clear_sessionid() {
+  sessionid_.ClearToEmpty();
 }
-inline const std::string& NewSessionRequest::deviceappversion() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceAppVersion)
-  return _internal_deviceappversion();
+inline const std::string& GetRequest::sessionid() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.GetRequest.sessionID)
+  return _internal_sessionid();
 }
-inline void NewSessionRequest::set_deviceappversion(const std::string& value) {
-  _internal_set_deviceappversion(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceAppVersion)
+inline void GetRequest::set_sessionid(const std::string& value) {
+  _internal_set_sessionid(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.GetRequest.sessionID)
 }
-inline std::string* NewSessionRequest::mutable_deviceappversion() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceAppVersion)
-  return _internal_mutable_deviceappversion();
+inline std::string* GetRequest::mutable_sessionid() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.GetRequest.sessionID)
+  return _internal_mutable_sessionid();
 }
-inline const std::string& NewSessionRequest::_internal_deviceappversion() const {
-  return deviceappversion_.Get();
+inline const std::string& GetRequest::_internal_sessionid() const {
+  return sessionid_.Get();
 }
-inline void NewSessionRequest::_internal_set_deviceappversion(const std::string& value) {
+inline void GetRequest::_internal_set_sessionid(const std::string& value) {
   
-  deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void NewSessionRequest::set_deviceappversion(std::string&& value) {
+inline void GetRequest::set_sessionid(std::string&& value) {
   
-  deviceappversion_.Set(
+  sessionid_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceAppVersion)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetRequest.sessionID)
 }
-inline void NewSessionRequest::set_deviceappversion(const char* value) {
+inline void GetRequest::set_sessionid(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceAppVersion)
+  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.GetRequest.sessionID)
 }
-inline void NewSessionRequest::set_deviceappversion(const char* value,
+inline void GetRequest::set_sessionid(const char* value,
     size_t size) {
   
-  deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceAppVersion)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetRequest.sessionID)
 }
-inline std::string* NewSessionRequest::_internal_mutable_deviceappversion() {
+inline std::string* GetRequest::_internal_mutable_sessionid() {
   
-  return deviceappversion_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* NewSessionRequest::release_deviceappversion() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceAppVersion)
-  return deviceappversion_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* GetRequest::release_sessionid() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.GetRequest.sessionID)
+  return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void NewSessionRequest::set_allocated_deviceappversion(std::string* deviceappversion) {
-  if (deviceappversion != nullptr) {
+inline void GetRequest::set_allocated_sessionid(std::string* sessionid) {
+  if (sessionid != nullptr) {
     
   } else {
     
   }
-  deviceappversion_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceappversion,
+  sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceAppVersion)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetRequest.sessionID)
 }
 
-// string deviceOS = 7;
-inline void NewSessionRequest::clear_deviceos() {
-  deviceos_.ClearToEmpty();
+// -------------------------------------------------------------------
+
+// GetResponse
+
+// string fromDeviceID = 1;
+inline void GetResponse::clear_fromdeviceid() {
+  fromdeviceid_.ClearToEmpty();
 }
-inline const std::string& NewSessionRequest::deviceos() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceOS)
-  return _internal_deviceos();
+inline const std::string& GetResponse::fromdeviceid() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.fromDeviceID)
+  return _internal_fromdeviceid();
 }
-inline void NewSessionRequest::set_deviceos(const std::string& value) {
-  _internal_set_deviceos(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceOS)
+inline void GetResponse::set_fromdeviceid(const std::string& value) {
+  _internal_set_fromdeviceid(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.fromDeviceID)
 }
-inline std::string* NewSessionRequest::mutable_deviceos() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceOS)
-  return _internal_mutable_deviceos();
+inline std::string* GetResponse::mutable_fromdeviceid() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.fromDeviceID)
+  return _internal_mutable_fromdeviceid();
 }
-inline const std::string& NewSessionRequest::_internal_deviceos() const {
-  return deviceos_.Get();
+inline const std::string& GetResponse::_internal_fromdeviceid() const {
+  return fromdeviceid_.Get();
 }
-inline void NewSessionRequest::_internal_set_deviceos(const std::string& value) {
+inline void GetResponse::_internal_set_fromdeviceid(const std::string& value) {
   
-  deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void NewSessionRequest::set_deviceos(std::string&& value) {
+inline void GetResponse::set_fromdeviceid(std::string&& value) {
   
-  deviceos_.Set(
+  fromdeviceid_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceOS)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.fromDeviceID)
 }
-inline void NewSessionRequest::set_deviceos(const char* value) {
+inline void GetResponse::set_fromdeviceid(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceOS)
+  fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.fromDeviceID)
 }
-inline void NewSessionRequest::set_deviceos(const char* value,
+inline void GetResponse::set_fromdeviceid(const char* value,
     size_t size) {
   
-  deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+  fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceOS)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.fromDeviceID)
 }
-inline std::string* NewSessionRequest::_internal_mutable_deviceos() {
+inline std::string* GetResponse::_internal_mutable_fromdeviceid() {
   
-  return deviceos_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* NewSessionRequest::release_deviceos() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceOS)
-  return deviceos_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* GetResponse::release_fromdeviceid() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.fromDeviceID)
+  return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void NewSessionRequest::set_allocated_deviceos(std::string* deviceos) {
-  if (deviceos != nullptr) {
+inline void GetResponse::set_allocated_fromdeviceid(std::string* fromdeviceid) {
+  if (fromdeviceid != nullptr) {
     
   } else {
     
   }
-  deviceos_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceos,
+  fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceOS)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.fromDeviceID)
 }
 
-// -------------------------------------------------------------------
-
-// NewSessionResponse
-
-// string sessionID = 1;
-inline void NewSessionResponse::clear_sessionid() {
-  sessionid_.ClearToEmpty();
+// bytes payload = 2;
+inline void GetResponse::clear_payload() {
+  payload_.ClearToEmpty();
 }
-inline const std::string& NewSessionResponse::sessionid() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionResponse.sessionID)
-  return _internal_sessionid();
+inline const std::string& GetResponse::payload() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.payload)
+  return _internal_payload();
 }
-inline void NewSessionResponse::set_sessionid(const std::string& value) {
-  _internal_set_sessionid(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionResponse.sessionID)
+inline void GetResponse::set_payload(const std::string& value) {
+  _internal_set_payload(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.payload)
 }
-inline std::string* NewSessionResponse::mutable_sessionid() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionResponse.sessionID)
-  return _internal_mutable_sessionid();
+inline std::string* GetResponse::mutable_payload() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.payload)
+  return _internal_mutable_payload();
 }
-inline const std::string& NewSessionResponse::_internal_sessionid() const {
-  return sessionid_.Get();
+inline const std::string& GetResponse::_internal_payload() const {
+  return payload_.Get();
 }
-inline void NewSessionResponse::_internal_set_sessionid(const std::string& value) {
+inline void GetResponse::_internal_set_payload(const std::string& value) {
   
-  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void NewSessionResponse::set_sessionid(std::string&& value) {
+inline void GetResponse::set_payload(std::string&& value) {
   
-  sessionid_.Set(
+  payload_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionResponse.sessionID)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.payload)
 }
-inline void NewSessionResponse::set_sessionid(const char* value) {
+inline void GetResponse::set_payload(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionResponse.sessionID)
+  payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.payload)
 }
-inline void NewSessionResponse::set_sessionid(const char* value,
+inline void GetResponse::set_payload(const void* value,
     size_t size) {
   
-  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+  payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionResponse.sessionID)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.payload)
 }
-inline std::string* NewSessionResponse::_internal_mutable_sessionid() {
+inline std::string* GetResponse::_internal_mutable_payload() {
   
-  return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* NewSessionResponse::release_sessionid() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionResponse.sessionID)
-  return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* GetResponse::release_payload() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.payload)
+  return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void NewSessionResponse::set_allocated_sessionid(std::string* sessionid) {
-  if (sessionid != nullptr) {
+inline void GetResponse::set_allocated_payload(std::string* payload) {
+  if (payload != nullptr) {
     
   } else {
     
   }
-  sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
+  payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionResponse.sessionID)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.payload)
 }
 
-// -------------------------------------------------------------------
-
-// SendRequest
-
-// string sessionID = 1;
-inline void SendRequest::clear_sessionid() {
-  sessionid_.ClearToEmpty();
+// repeated string blobHashes = 3;
+inline int GetResponse::_internal_blobhashes_size() const {
+  return blobhashes_.size();
 }
-inline const std::string& SendRequest::sessionid() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.sessionID)
-  return _internal_sessionid();
+inline int GetResponse::blobhashes_size() const {
+  return _internal_blobhashes_size();
 }
-inline void SendRequest::set_sessionid(const std::string& value) {
-  _internal_set_sessionid(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.sessionID)
+inline void GetResponse::clear_blobhashes() {
+  blobhashes_.Clear();
 }
-inline std::string* SendRequest::mutable_sessionid() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.sessionID)
-  return _internal_mutable_sessionid();
+inline std::string* GetResponse::add_blobhashes() {
+  // @@protoc_insertion_point(field_add_mutable:tunnelbroker.GetResponse.blobHashes)
+  return _internal_add_blobhashes();
 }
-inline const std::string& SendRequest::_internal_sessionid() const {
-  return sessionid_.Get();
+inline const std::string& GetResponse::_internal_blobhashes(int index) const {
+  return blobhashes_.Get(index);
 }
-inline void SendRequest::_internal_set_sessionid(const std::string& value) {
-  
-  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline const std::string& GetResponse::blobhashes(int index) const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.blobHashes)
+  return _internal_blobhashes(index);
 }
-inline void SendRequest::set_sessionid(std::string&& value) {
-  
-  sessionid_.Set(
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.sessionID)
+inline std::string* GetResponse::mutable_blobhashes(int index) {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.blobHashes)
+  return blobhashes_.Mutable(index);
 }
-inline void SendRequest::set_sessionid(const char* value) {
+inline void GetResponse::set_blobhashes(int index, const std::string& value) {
+  // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
+  blobhashes_.Mutable(index)->assign(value);
+}
+inline void GetResponse::set_blobhashes(int index, std::string&& value) {
+  // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
+  blobhashes_.Mutable(index)->assign(std::move(value));
+}
+inline void GetResponse::set_blobhashes(int index, const char* value) {
   GOOGLE_DCHECK(value != nullptr);
-  
-  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.sessionID)
+  blobhashes_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.blobHashes)
 }
-inline void SendRequest::set_sessionid(const char* value,
-    size_t size) {
-  
-  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.sessionID)
+inline void GetResponse::set_blobhashes(int index, const char* value, size_t size) {
+  blobhashes_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.blobHashes)
+}
+inline std::string* GetResponse::_internal_add_blobhashes() {
+  return blobhashes_.Add();
+}
+inline void GetResponse::add_blobhashes(const std::string& value) {
+  blobhashes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
+}
+inline void GetResponse::add_blobhashes(std::string&& value) {
+  blobhashes_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
 }
-inline std::string* SendRequest::_internal_mutable_sessionid() {
-  
-  return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline void GetResponse::add_blobhashes(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  blobhashes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tunnelbroker.GetResponse.blobHashes)
 }
-inline std::string* SendRequest::release_sessionid() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.sessionID)
-  return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline void GetResponse::add_blobhashes(const char* value, size_t size) {
+  blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tunnelbroker.GetResponse.blobHashes)
 }
-inline void SendRequest::set_allocated_sessionid(std::string* sessionid) {
-  if (sessionid != nullptr) {
-    
-  } else {
-    
-  }
-  sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.sessionID)
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+GetResponse::blobhashes() const {
+  // @@protoc_insertion_point(field_list:tunnelbroker.GetResponse.blobHashes)
+  return blobhashes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+GetResponse::mutable_blobhashes() {
+  // @@protoc_insertion_point(field_mutable_list:tunnelbroker.GetResponse.blobHashes)
+  return &blobhashes_;
 }
 
-// string toDeviceID = 2;
-inline void SendRequest::clear_todeviceid() {
+// -------------------------------------------------------------------
+
+// OutboundMessage
+
+// string toDeviceID = 1;
+inline void OutboundMessage::clear_todeviceid() {
   todeviceid_.ClearToEmpty();
 }
-inline const std::string& SendRequest::todeviceid() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.toDeviceID)
+inline const std::string& OutboundMessage::todeviceid() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.toDeviceID)
   return _internal_todeviceid();
 }
-inline void SendRequest::set_todeviceid(const std::string& value) {
+inline void OutboundMessage::set_todeviceid(const std::string& value) {
   _internal_set_todeviceid(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.toDeviceID)
+  // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.toDeviceID)
 }
-inline std::string* SendRequest::mutable_todeviceid() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.toDeviceID)
+inline std::string* OutboundMessage::mutable_todeviceid() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.toDeviceID)
   return _internal_mutable_todeviceid();
 }
-inline const std::string& SendRequest::_internal_todeviceid() const {
+inline const std::string& OutboundMessage::_internal_todeviceid() const {
   return todeviceid_.Get();
 }
-inline void SendRequest::_internal_set_todeviceid(const std::string& value) {
+inline void OutboundMessage::_internal_set_todeviceid(const std::string& value) {
   
   todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void SendRequest::set_todeviceid(std::string&& value) {
+inline void OutboundMessage::set_todeviceid(std::string&& value) {
   
   todeviceid_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.toDeviceID)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.OutboundMessage.toDeviceID)
 }
-inline void SendRequest::set_todeviceid(const char* value) {
+inline void OutboundMessage::set_todeviceid(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
   todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.toDeviceID)
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.toDeviceID)
 }
-inline void SendRequest::set_todeviceid(const char* value,
+inline void OutboundMessage::set_todeviceid(const char* value,
     size_t size) {
   
   todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.toDeviceID)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.toDeviceID)
 }
-inline std::string* SendRequest::_internal_mutable_todeviceid() {
+inline std::string* OutboundMessage::_internal_mutable_todeviceid() {
   
   return todeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* SendRequest::release_todeviceid() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.toDeviceID)
+inline std::string* OutboundMessage::release_todeviceid() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.OutboundMessage.toDeviceID)
   return todeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void SendRequest::set_allocated_todeviceid(std::string* todeviceid) {
+inline void OutboundMessage::set_allocated_todeviceid(std::string* todeviceid) {
   if (todeviceid != nullptr) {
     
   } else {
@@ -2902,60 +3769,60 @@
   }
   todeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), todeviceid,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.toDeviceID)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.OutboundMessage.toDeviceID)
 }
 
-// bytes payload = 3;
-inline void SendRequest::clear_payload() {
+// string payload = 2;
+inline void OutboundMessage::clear_payload() {
   payload_.ClearToEmpty();
 }
-inline const std::string& SendRequest::payload() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.payload)
+inline const std::string& OutboundMessage::payload() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.payload)
   return _internal_payload();
 }
-inline void SendRequest::set_payload(const std::string& value) {
+inline void OutboundMessage::set_payload(const std::string& value) {
   _internal_set_payload(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.payload)
+  // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.payload)
 }
-inline std::string* SendRequest::mutable_payload() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.payload)
+inline std::string* OutboundMessage::mutable_payload() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.payload)
   return _internal_mutable_payload();
 }
-inline const std::string& SendRequest::_internal_payload() const {
+inline const std::string& OutboundMessage::_internal_payload() const {
   return payload_.Get();
 }
-inline void SendRequest::_internal_set_payload(const std::string& value) {
+inline void OutboundMessage::_internal_set_payload(const std::string& value) {
   
   payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void SendRequest::set_payload(std::string&& value) {
+inline void OutboundMessage::set_payload(std::string&& value) {
   
   payload_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.payload)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.OutboundMessage.payload)
 }
-inline void SendRequest::set_payload(const char* value) {
+inline void OutboundMessage::set_payload(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
   payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.payload)
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.payload)
 }
-inline void SendRequest::set_payload(const void* value,
+inline void OutboundMessage::set_payload(const char* value,
     size_t size) {
   
   payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.payload)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.payload)
 }
-inline std::string* SendRequest::_internal_mutable_payload() {
+inline std::string* OutboundMessage::_internal_mutable_payload() {
   
   return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* SendRequest::release_payload() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.payload)
+inline std::string* OutboundMessage::release_payload() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.OutboundMessage.payload)
   return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void SendRequest::set_allocated_payload(std::string* payload) {
+inline void OutboundMessage::set_allocated_payload(std::string* payload) {
   if (payload != nullptr) {
     
   } else {
@@ -2963,264 +3830,260 @@
   }
   payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.payload)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.OutboundMessage.payload)
 }
 
-// repeated string blobHashes = 4;
-inline int SendRequest::_internal_blobhashes_size() const {
+// repeated string blobHashes = 3;
+inline int OutboundMessage::_internal_blobhashes_size() const {
   return blobhashes_.size();
 }
-inline int SendRequest::blobhashes_size() const {
+inline int OutboundMessage::blobhashes_size() const {
   return _internal_blobhashes_size();
 }
-inline void SendRequest::clear_blobhashes() {
+inline void OutboundMessage::clear_blobhashes() {
   blobhashes_.Clear();
 }
-inline std::string* SendRequest::add_blobhashes() {
-  // @@protoc_insertion_point(field_add_mutable:tunnelbroker.SendRequest.blobHashes)
+inline std::string* OutboundMessage::add_blobhashes() {
+  // @@protoc_insertion_point(field_add_mutable:tunnelbroker.OutboundMessage.blobHashes)
   return _internal_add_blobhashes();
 }
-inline const std::string& SendRequest::_internal_blobhashes(int index) const {
+inline const std::string& OutboundMessage::_internal_blobhashes(int index) const {
   return blobhashes_.Get(index);
 }
-inline const std::string& SendRequest::blobhashes(int index) const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.blobHashes)
+inline const std::string& OutboundMessage::blobhashes(int index) const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.blobHashes)
   return _internal_blobhashes(index);
 }
-inline std::string* SendRequest::mutable_blobhashes(int index) {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.blobHashes)
+inline std::string* OutboundMessage::mutable_blobhashes(int index) {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.blobHashes)
   return blobhashes_.Mutable(index);
 }
-inline void SendRequest::set_blobhashes(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
+inline void OutboundMessage::set_blobhashes(int index, const std::string& value) {
+  // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.blobHashes)
   blobhashes_.Mutable(index)->assign(value);
 }
-inline void SendRequest::set_blobhashes(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
+inline void OutboundMessage::set_blobhashes(int index, std::string&& value) {
+  // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.blobHashes)
   blobhashes_.Mutable(index)->assign(std::move(value));
 }
-inline void SendRequest::set_blobhashes(int index, const char* value) {
+inline void OutboundMessage::set_blobhashes(int index, const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   blobhashes_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.blobHashes)
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.blobHashes)
 }
-inline void SendRequest::set_blobhashes(int index, const char* value, size_t size) {
+inline void OutboundMessage::set_blobhashes(int index, const char* value, size_t size) {
   blobhashes_.Mutable(index)->assign(
     reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.blobHashes)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.blobHashes)
 }
-inline std::string* SendRequest::_internal_add_blobhashes() {
+inline std::string* OutboundMessage::_internal_add_blobhashes() {
   return blobhashes_.Add();
 }
-inline void SendRequest::add_blobhashes(const std::string& value) {
+inline void OutboundMessage::add_blobhashes(const std::string& value) {
   blobhashes_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
+  // @@protoc_insertion_point(field_add:tunnelbroker.OutboundMessage.blobHashes)
 }
-inline void SendRequest::add_blobhashes(std::string&& value) {
+inline void OutboundMessage::add_blobhashes(std::string&& value) {
   blobhashes_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
+  // @@protoc_insertion_point(field_add:tunnelbroker.OutboundMessage.blobHashes)
 }
-inline void SendRequest::add_blobhashes(const char* value) {
+inline void OutboundMessage::add_blobhashes(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   blobhashes_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:tunnelbroker.SendRequest.blobHashes)
+  // @@protoc_insertion_point(field_add_char:tunnelbroker.OutboundMessage.blobHashes)
 }
-inline void SendRequest::add_blobhashes(const char* value, size_t size) {
+inline void OutboundMessage::add_blobhashes(const char* value, size_t size) {
   blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:tunnelbroker.SendRequest.blobHashes)
+  // @@protoc_insertion_point(field_add_pointer:tunnelbroker.OutboundMessage.blobHashes)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-SendRequest::blobhashes() const {
-  // @@protoc_insertion_point(field_list:tunnelbroker.SendRequest.blobHashes)
+OutboundMessage::blobhashes() const {
+  // @@protoc_insertion_point(field_list:tunnelbroker.OutboundMessage.blobHashes)
   return blobhashes_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-SendRequest::mutable_blobhashes() {
-  // @@protoc_insertion_point(field_mutable_list:tunnelbroker.SendRequest.blobHashes)
+OutboundMessage::mutable_blobhashes() {
+  // @@protoc_insertion_point(field_mutable_list:tunnelbroker.OutboundMessage.blobHashes)
   return &blobhashes_;
 }
 
 // -------------------------------------------------------------------
 
-// GetRequest
+// InboundMessage
 
-// string sessionID = 1;
-inline void GetRequest::clear_sessionid() {
-  sessionid_.ClearToEmpty();
+// string fromDeviceID = 1;
+inline void InboundMessage::clear_fromdeviceid() {
+  fromdeviceid_.ClearToEmpty();
 }
-inline const std::string& GetRequest::sessionid() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.GetRequest.sessionID)
-  return _internal_sessionid();
+inline const std::string& InboundMessage::fromdeviceid() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.fromDeviceID)
+  return _internal_fromdeviceid();
 }
-inline void GetRequest::set_sessionid(const std::string& value) {
-  _internal_set_sessionid(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.GetRequest.sessionID)
+inline void InboundMessage::set_fromdeviceid(const std::string& value) {
+  _internal_set_fromdeviceid(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.fromDeviceID)
 }
-inline std::string* GetRequest::mutable_sessionid() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.GetRequest.sessionID)
-  return _internal_mutable_sessionid();
+inline std::string* InboundMessage::mutable_fromdeviceid() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.fromDeviceID)
+  return _internal_mutable_fromdeviceid();
 }
-inline const std::string& GetRequest::_internal_sessionid() const {
-  return sessionid_.Get();
+inline const std::string& InboundMessage::_internal_fromdeviceid() const {
+  return fromdeviceid_.Get();
 }
-inline void GetRequest::_internal_set_sessionid(const std::string& value) {
+inline void InboundMessage::_internal_set_fromdeviceid(const std::string& value) {
   
-  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void GetRequest::set_sessionid(std::string&& value) {
+inline void InboundMessage::set_fromdeviceid(std::string&& value) {
   
-  sessionid_.Set(
+  fromdeviceid_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetRequest.sessionID)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.fromDeviceID)
 }
-inline void GetRequest::set_sessionid(const char* value) {
+inline void InboundMessage::set_fromdeviceid(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.GetRequest.sessionID)
+  fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.fromDeviceID)
 }
-inline void GetRequest::set_sessionid(const char* value,
+inline void InboundMessage::set_fromdeviceid(const char* value,
     size_t size) {
   
-  sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+  fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetRequest.sessionID)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.fromDeviceID)
 }
-inline std::string* GetRequest::_internal_mutable_sessionid() {
+inline std::string* InboundMessage::_internal_mutable_fromdeviceid() {
   
-  return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* GetRequest::release_sessionid() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.GetRequest.sessionID)
-  return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* InboundMessage::release_fromdeviceid() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.fromDeviceID)
+  return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void GetRequest::set_allocated_sessionid(std::string* sessionid) {
-  if (sessionid != nullptr) {
+inline void InboundMessage::set_allocated_fromdeviceid(std::string* fromdeviceid) {
+  if (fromdeviceid != nullptr) {
     
   } else {
     
   }
-  sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
+  fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetRequest.sessionID)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.fromDeviceID)
 }
 
-// -------------------------------------------------------------------
-
-// GetResponse
-
-// string fromDeviceID = 1;
-inline void GetResponse::clear_fromdeviceid() {
-  fromdeviceid_.ClearToEmpty();
+// string fromConnectionID = 2;
+inline void InboundMessage::clear_fromconnectionid() {
+  fromconnectionid_.ClearToEmpty();
 }
-inline const std::string& GetResponse::fromdeviceid() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.fromDeviceID)
-  return _internal_fromdeviceid();
+inline const std::string& InboundMessage::fromconnectionid() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.fromConnectionID)
+  return _internal_fromconnectionid();
 }
-inline void GetResponse::set_fromdeviceid(const std::string& value) {
-  _internal_set_fromdeviceid(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.fromDeviceID)
+inline void InboundMessage::set_fromconnectionid(const std::string& value) {
+  _internal_set_fromconnectionid(value);
+  // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.fromConnectionID)
 }
-inline std::string* GetResponse::mutable_fromdeviceid() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.fromDeviceID)
-  return _internal_mutable_fromdeviceid();
+inline std::string* InboundMessage::mutable_fromconnectionid() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.fromConnectionID)
+  return _internal_mutable_fromconnectionid();
 }
-inline const std::string& GetResponse::_internal_fromdeviceid() const {
-  return fromdeviceid_.Get();
+inline const std::string& InboundMessage::_internal_fromconnectionid() const {
+  return fromconnectionid_.Get();
 }
-inline void GetResponse::_internal_set_fromdeviceid(const std::string& value) {
+inline void InboundMessage::_internal_set_fromconnectionid(const std::string& value) {
   
-  fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+  fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void GetResponse::set_fromdeviceid(std::string&& value) {
+inline void InboundMessage::set_fromconnectionid(std::string&& value) {
   
-  fromdeviceid_.Set(
+  fromconnectionid_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.fromDeviceID)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.fromConnectionID)
 }
-inline void GetResponse::set_fromdeviceid(const char* value) {
+inline void InboundMessage::set_fromconnectionid(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
-  fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.fromDeviceID)
+  fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.fromConnectionID)
 }
-inline void GetResponse::set_fromdeviceid(const char* value,
+inline void InboundMessage::set_fromconnectionid(const char* value,
     size_t size) {
   
-  fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+  fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.fromDeviceID)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.fromConnectionID)
 }
-inline std::string* GetResponse::_internal_mutable_fromdeviceid() {
+inline std::string* InboundMessage::_internal_mutable_fromconnectionid() {
   
-  return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+  return fromconnectionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* GetResponse::release_fromdeviceid() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.fromDeviceID)
-  return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* InboundMessage::release_fromconnectionid() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.fromConnectionID)
+  return fromconnectionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void GetResponse::set_allocated_fromdeviceid(std::string* fromdeviceid) {
-  if (fromdeviceid != nullptr) {
+inline void InboundMessage::set_allocated_fromconnectionid(std::string* fromconnectionid) {
+  if (fromconnectionid != nullptr) {
     
   } else {
     
   }
-  fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid,
+  fromconnectionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromconnectionid,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.fromDeviceID)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.fromConnectionID)
 }
 
-// bytes payload = 2;
-inline void GetResponse::clear_payload() {
+// string payload = 3;
+inline void InboundMessage::clear_payload() {
   payload_.ClearToEmpty();
 }
-inline const std::string& GetResponse::payload() const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.payload)
+inline const std::string& InboundMessage::payload() const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.payload)
   return _internal_payload();
 }
-inline void GetResponse::set_payload(const std::string& value) {
+inline void InboundMessage::set_payload(const std::string& value) {
   _internal_set_payload(value);
-  // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.payload)
+  // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.payload)
 }
-inline std::string* GetResponse::mutable_payload() {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.payload)
+inline std::string* InboundMessage::mutable_payload() {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.payload)
   return _internal_mutable_payload();
 }
-inline const std::string& GetResponse::_internal_payload() const {
+inline const std::string& InboundMessage::_internal_payload() const {
   return payload_.Get();
 }
-inline void GetResponse::_internal_set_payload(const std::string& value) {
+inline void InboundMessage::_internal_set_payload(const std::string& value) {
   
   payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 }
-inline void GetResponse::set_payload(std::string&& value) {
+inline void InboundMessage::set_payload(std::string&& value) {
   
   payload_.Set(
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.payload)
+  // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.payload)
 }
-inline void GetResponse::set_payload(const char* value) {
+inline void InboundMessage::set_payload(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   
   payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.payload)
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.payload)
 }
-inline void GetResponse::set_payload(const void* value,
+inline void InboundMessage::set_payload(const char* value,
     size_t size) {
   
   payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
       reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.payload)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.payload)
 }
-inline std::string* GetResponse::_internal_mutable_payload() {
+inline std::string* InboundMessage::_internal_mutable_payload() {
   
   return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 }
-inline std::string* GetResponse::release_payload() {
-  // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.payload)
+inline std::string* InboundMessage::release_payload() {
+  // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.payload)
   return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void GetResponse::set_allocated_payload(std::string* payload) {
+inline void InboundMessage::set_allocated_payload(std::string* payload) {
   if (payload != nullptr) {
     
   } else {
@@ -3228,80 +4091,80 @@
   }
   payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
       GetArena());
-  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.payload)
+  // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.payload)
 }
 
-// repeated string blobHashes = 3;
-inline int GetResponse::_internal_blobhashes_size() const {
+// repeated string blobHashes = 4;
+inline int InboundMessage::_internal_blobhashes_size() const {
   return blobhashes_.size();
 }
-inline int GetResponse::blobhashes_size() const {
+inline int InboundMessage::blobhashes_size() const {
   return _internal_blobhashes_size();
 }
-inline void GetResponse::clear_blobhashes() {
+inline void InboundMessage::clear_blobhashes() {
   blobhashes_.Clear();
 }
-inline std::string* GetResponse::add_blobhashes() {
-  // @@protoc_insertion_point(field_add_mutable:tunnelbroker.GetResponse.blobHashes)
+inline std::string* InboundMessage::add_blobhashes() {
+  // @@protoc_insertion_point(field_add_mutable:tunnelbroker.InboundMessage.blobHashes)
   return _internal_add_blobhashes();
 }
-inline const std::string& GetResponse::_internal_blobhashes(int index) const {
+inline const std::string& InboundMessage::_internal_blobhashes(int index) const {
   return blobhashes_.Get(index);
 }
-inline const std::string& GetResponse::blobhashes(int index) const {
-  // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.blobHashes)
+inline const std::string& InboundMessage::blobhashes(int index) const {
+  // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.blobHashes)
   return _internal_blobhashes(index);
 }
-inline std::string* GetResponse::mutable_blobhashes(int index) {
-  // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.blobHashes)
+inline std::string* InboundMessage::mutable_blobhashes(int index) {
+  // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.blobHashes)
   return blobhashes_.Mutable(index);
 }
-inline void GetResponse::set_blobhashes(int index, const std::string& value) {
-  // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
+inline void InboundMessage::set_blobhashes(int index, const std::string& value) {
+  // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.blobHashes)
   blobhashes_.Mutable(index)->assign(value);
 }
-inline void GetResponse::set_blobhashes(int index, std::string&& value) {
-  // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
+inline void InboundMessage::set_blobhashes(int index, std::string&& value) {
+  // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.blobHashes)
   blobhashes_.Mutable(index)->assign(std::move(value));
 }
-inline void GetResponse::set_blobhashes(int index, const char* value) {
+inline void InboundMessage::set_blobhashes(int index, const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   blobhashes_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.blobHashes)
+  // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.blobHashes)
 }
-inline void GetResponse::set_blobhashes(int index, const char* value, size_t size) {
+inline void InboundMessage::set_blobhashes(int index, const char* value, size_t size) {
   blobhashes_.Mutable(index)->assign(
     reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.blobHashes)
+  // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.blobHashes)
 }
-inline std::string* GetResponse::_internal_add_blobhashes() {
+inline std::string* InboundMessage::_internal_add_blobhashes() {
   return blobhashes_.Add();
 }
-inline void GetResponse::add_blobhashes(const std::string& value) {
+inline void InboundMessage::add_blobhashes(const std::string& value) {
   blobhashes_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
+  // @@protoc_insertion_point(field_add:tunnelbroker.InboundMessage.blobHashes)
 }
-inline void GetResponse::add_blobhashes(std::string&& value) {
+inline void InboundMessage::add_blobhashes(std::string&& value) {
   blobhashes_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
+  // @@protoc_insertion_point(field_add:tunnelbroker.InboundMessage.blobHashes)
 }
-inline void GetResponse::add_blobhashes(const char* value) {
+inline void InboundMessage::add_blobhashes(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   blobhashes_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:tunnelbroker.GetResponse.blobHashes)
+  // @@protoc_insertion_point(field_add_char:tunnelbroker.InboundMessage.blobHashes)
 }
-inline void GetResponse::add_blobhashes(const char* value, size_t size) {
+inline void InboundMessage::add_blobhashes(const char* value, size_t size) {
   blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:tunnelbroker.GetResponse.blobHashes)
+  // @@protoc_insertion_point(field_add_pointer:tunnelbroker.InboundMessage.blobHashes)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-GetResponse::blobhashes() const {
-  // @@protoc_insertion_point(field_list:tunnelbroker.GetResponse.blobHashes)
+InboundMessage::blobhashes() const {
+  // @@protoc_insertion_point(field_list:tunnelbroker.InboundMessage.blobHashes)
   return blobhashes_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-GetResponse::mutable_blobhashes() {
-  // @@protoc_insertion_point(field_mutable_list:tunnelbroker.GetResponse.blobHashes)
+InboundMessage::mutable_blobhashes() {
+  // @@protoc_insertion_point(field_mutable_list:tunnelbroker.InboundMessage.blobHashes)
   return &blobhashes_;
 }
 
@@ -3756,6 +4619,10 @@
 
 // -------------------------------------------------------------------
 
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc
--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc
+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc
@@ -113,6 +113,35 @@
   };
 };
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetResponseDefaultTypeInternal _GetResponse_default_instance_;
+constexpr OutboundMessage::OutboundMessage(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : blobhashes_()
+  , todeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct OutboundMessageDefaultTypeInternal {
+  constexpr OutboundMessageDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~OutboundMessageDefaultTypeInternal() {}
+  union {
+    OutboundMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OutboundMessageDefaultTypeInternal _OutboundMessage_default_instance_;
+constexpr InboundMessage::InboundMessage(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : blobhashes_()
+  , fromdeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , fromconnectionid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct InboundMessageDefaultTypeInternal {
+  constexpr InboundMessageDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~InboundMessageDefaultTypeInternal() {}
+  union {
+    InboundMessage _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InboundMessageDefaultTypeInternal _InboundMessage_default_instance_;
 constexpr CheckRequest::CheckRequest(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
   : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
@@ -178,7 +207,7 @@
 };
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PongRequestDefaultTypeInternal _PongRequest_default_instance_;
 }  // namespace tunnelbroker
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_tunnelbroker_2eproto[12];
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_tunnelbroker_2eproto[14];
 static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_tunnelbroker_2eproto[2];
 static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_tunnelbroker_2eproto = nullptr;
 
@@ -244,6 +273,23 @@
   PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponse, payload_),
   PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponse, blobhashes_),
   ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, todeviceid_),
+  PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, payload_),
+  PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, blobhashes_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, fromdeviceid_),
+  PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, fromconnectionid_),
+  PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, payload_),
+  PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, blobhashes_),
+  ~0u,  // no _has_bits_
   PROTOBUF_FIELD_OFFSET(::tunnelbroker::CheckRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
@@ -285,11 +331,13 @@
   { 37, -1, sizeof(::tunnelbroker::SendRequest)},
   { 46, -1, sizeof(::tunnelbroker::GetRequest)},
   { 52, -1, sizeof(::tunnelbroker::GetResponse)},
-  { 60, -1, sizeof(::tunnelbroker::CheckRequest)},
-  { 67, -1, sizeof(::tunnelbroker::CheckResponse)},
-  { 73, -1, sizeof(::tunnelbroker::NewPrimaryRequest)},
-  { 80, -1, sizeof(::tunnelbroker::NewPrimaryResponse)},
-  { 86, -1, sizeof(::tunnelbroker::PongRequest)},
+  { 60, -1, sizeof(::tunnelbroker::OutboundMessage)},
+  { 68, -1, sizeof(::tunnelbroker::InboundMessage)},
+  { 77, -1, sizeof(::tunnelbroker::CheckRequest)},
+  { 84, -1, sizeof(::tunnelbroker::CheckResponse)},
+  { 90, -1, sizeof(::tunnelbroker::NewPrimaryRequest)},
+  { 97, -1, sizeof(::tunnelbroker::NewPrimaryResponse)},
+  { 103, -1, sizeof(::tunnelbroker::PongRequest)},
 };
 
 static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
@@ -300,6 +348,8 @@
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_SendRequest_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_GetRequest_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_GetResponse_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_OutboundMessage_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_InboundMessage_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_CheckRequest_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_CheckResponse_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_NewPrimaryRequest_default_instance_),
@@ -313,7 +363,7 @@
   "ureRequest\022\020\n\010deviceID\030\001 \001(\t\"*\n\030SessionS"
   "ignatureResponse\022\016\n\006toSign\030\001 \001(\t\"\225\002\n\021New"
   "SessionRequest\022\020\n\010deviceID\030\001 \001(\t\022\021\n\tpubl"
-  "icKey\030\002 \001(\014\022\021\n\tsignature\030\003 \001(\t\022\030\n\013notify"
+  "icKey\030\002 \001(\t\022\021\n\tsignature\030\003 \001(\t\022\030\n\013notify"
   "Token\030\004 \001(\tH\000\210\001\001\022\?\n\ndeviceType\030\005 \001(\0162+.t"
   "unnelbroker.NewSessionRequest.DeviceType"
   "s\022\030\n\020deviceAppVersion\030\006 \001(\t\022\020\n\010deviceOS\030"
@@ -324,40 +374,46 @@
   "D\030\002 \001(\t\022\017\n\007payload\030\003 \001(\014\022\022\n\nblobHashes\030\004"
   " \003(\t\"\037\n\nGetRequest\022\021\n\tsessionID\030\001 \001(\t\"H\n"
   "\013GetResponse\022\024\n\014fromDeviceID\030\001 \001(\t\022\017\n\007pa"
-  "yload\030\002 \001(\014\022\022\n\nblobHashes\030\003 \003(\t\"3\n\014Check"
-  "Request\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceToken\030\002"
-  " \001(\t\"K\n\rCheckResponse\022:\n\021checkResponseTy"
-  "pe\030\001 \001(\0162\037.tunnelbroker.CheckResponseTyp"
-  "e\"8\n\021NewPrimaryRequest\022\016\n\006userId\030\001 \001(\t\022\023"
-  "\n\013deviceToken\030\002 \001(\t\"%\n\022NewPrimaryRespons"
-  "e\022\017\n\007success\030\001 \001(\010\"2\n\013PongRequest\022\016\n\006use"
-  "rId\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t*n\n\021CheckR"
-  "esponseType\022\030\n\024PRIMARY_DOESNT_EXIST\020\000\022\022\n"
-  "\016PRIMARY_ONLINE\020\001\022\023\n\017PRIMARY_OFFLINE\020\002\022\026"
-  "\n\022CURRENT_IS_PRIMARY\020\0032\303\004\n\023TunnelbrokerS"
-  "ervice\022W\n\032CheckIfPrimaryDeviceOnline\022\032.t"
-  "unnelbroker.CheckRequest\032\033.tunnelbroker."
-  "CheckResponse\"\000\022]\n\026BecomeNewPrimaryDevic"
-  "e\022\037.tunnelbroker.NewPrimaryRequest\032 .tun"
-  "nelbroker.NewPrimaryResponse\"\000\022\?\n\010SendPo"
-  "ng\022\031.tunnelbroker.PongRequest\032\026.google.p"
-  "rotobuf.Empty\"\000\022c\n\020SessionSignature\022%.tu"
-  "nnelbroker.SessionSignatureRequest\032&.tun"
-  "nelbroker.SessionSignatureResponse\"\000\022Q\n\n"
-  "NewSession\022\037.tunnelbroker.NewSessionRequ"
-  "est\032 .tunnelbroker.NewSessionResponse\"\000\022"
-  ";\n\004Send\022\031.tunnelbroker.SendRequest\032\026.goo"
-  "gle.protobuf.Empty\"\000\022>\n\003Get\022\030.tunnelbrok"
-  "er.GetRequest\032\031.tunnelbroker.GetResponse"
-  "\"\0000\001b\006proto3"
+  "yload\030\002 \001(\014\022\022\n\nblobHashes\030\003 \003(\t\"J\n\017Outbo"
+  "undMessage\022\022\n\ntoDeviceID\030\001 \001(\t\022\017\n\007payloa"
+  "d\030\002 \001(\t\022\022\n\nblobHashes\030\003 \003(\t\"e\n\016InboundMe"
+  "ssage\022\024\n\014fromDeviceID\030\001 \001(\t\022\030\n\020fromConne"
+  "ctionID\030\002 \001(\t\022\017\n\007payload\030\003 \001(\t\022\022\n\nblobHa"
+  "shes\030\004 \003(\t\"3\n\014CheckRequest\022\016\n\006userId\030\001 \001"
+  "(\t\022\023\n\013deviceToken\030\002 \001(\t\"K\n\rCheckResponse"
+  "\022:\n\021checkResponseType\030\001 \001(\0162\037.tunnelbrok"
+  "er.CheckResponseType\"8\n\021NewPrimaryReques"
+  "t\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t\"%"
+  "\n\022NewPrimaryResponse\022\017\n\007success\030\001 \001(\010\"2\n"
+  "\013PongRequest\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceTo"
+  "ken\030\002 \001(\t*n\n\021CheckResponseType\022\030\n\024PRIMAR"
+  "Y_DOESNT_EXIST\020\000\022\022\n\016PRIMARY_ONLINE\020\001\022\023\n\017"
+  "PRIMARY_OFFLINE\020\002\022\026\n\022CURRENT_IS_PRIMARY\020"
+  "\0032\224\005\n\023TunnelbrokerService\022W\n\032CheckIfPrim"
+  "aryDeviceOnline\022\032.tunnelbroker.CheckRequ"
+  "est\032\033.tunnelbroker.CheckResponse\"\000\022]\n\026Be"
+  "comeNewPrimaryDevice\022\037.tunnelbroker.NewP"
+  "rimaryRequest\032 .tunnelbroker.NewPrimaryR"
+  "esponse\"\000\022\?\n\010SendPong\022\031.tunnelbroker.Pon"
+  "gRequest\032\026.google.protobuf.Empty\"\000\022c\n\020Se"
+  "ssionSignature\022%.tunnelbroker.SessionSig"
+  "natureRequest\032&.tunnelbroker.SessionSign"
+  "atureResponse\"\000\022Q\n\nNewSession\022\037.tunnelbr"
+  "oker.NewSessionRequest\032 .tunnelbroker.Ne"
+  "wSessionResponse\"\000\022;\n\004Send\022\031.tunnelbroke"
+  "r.SendRequest\032\026.google.protobuf.Empty\"\000\022"
+  ">\n\003Get\022\030.tunnelbroker.GetRequest\032\031.tunne"
+  "lbroker.GetResponse\"\0000\001\022O\n\nOpenStream\022\035."
+  "tunnelbroker.OutboundMessage\032\034.tunnelbro"
+  "ker.InboundMessage\"\000(\0010\001b\006proto3"
   ;
 static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_tunnelbroker_2eproto_deps[1] = {
   &::descriptor_table_google_2fprotobuf_2fempty_2eproto,
 };
 static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_tunnelbroker_2eproto_once;
 const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tunnelbroker_2eproto = {
-  false, false, 1652, descriptor_table_protodef_tunnelbroker_2eproto, "tunnelbroker.proto", 
-  &descriptor_table_tunnelbroker_2eproto_once, descriptor_table_tunnelbroker_2eproto_deps, 1, 12,
+  false, false, 1912, descriptor_table_protodef_tunnelbroker_2eproto, "tunnelbroker.proto", 
+  &descriptor_table_tunnelbroker_2eproto_once, descriptor_table_tunnelbroker_2eproto_deps, 1, 14,
   schemas, file_default_instances, TableStruct_tunnelbroker_2eproto::offsets,
   file_level_metadata_tunnelbroker_2eproto, file_level_enum_descriptors_tunnelbroker_2eproto, file_level_service_descriptors_tunnelbroker_2eproto,
 };
@@ -937,11 +993,12 @@
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
-      // bytes publicKey = 2;
+      // string publicKey = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
           auto str = _internal_mutable_publickey();
           ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewSessionRequest.publicKey"));
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
@@ -1028,9 +1085,13 @@
         1, this->_internal_deviceid(), target);
   }
 
-  // bytes publicKey = 2;
+  // string publicKey = 2;
   if (this->publickey().size() > 0) {
-    target = stream->WriteBytesMaybeAliased(
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_publickey().data(), static_cast<int>(this->_internal_publickey().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "tunnelbroker.NewSessionRequest.publicKey");
+    target = stream->WriteStringMaybeAliased(
         2, this->_internal_publickey(), target);
   }
 
@@ -1104,10 +1165,10 @@
         this->_internal_deviceid());
   }
 
-  // bytes publicKey = 2;
+  // string publicKey = 2;
   if (this->publickey().size() > 0) {
     total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
         this->_internal_publickey());
   }
 
@@ -2214,6 +2275,594 @@
 }
 
 
+// ===================================================================
+
+class OutboundMessage::_Internal {
+ public:
+};
+
+OutboundMessage::OutboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
+  blobhashes_(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:tunnelbroker.OutboundMessage)
+}
+OutboundMessage::OutboundMessage(const OutboundMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      blobhashes_(from.blobhashes_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from._internal_todeviceid().empty()) {
+    todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_todeviceid(), 
+      GetArena());
+  }
+  payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from._internal_payload().empty()) {
+    payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(), 
+      GetArena());
+  }
+  // @@protoc_insertion_point(copy_constructor:tunnelbroker.OutboundMessage)
+}
+
+void OutboundMessage::SharedCtor() {
+todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+OutboundMessage::~OutboundMessage() {
+  // @@protoc_insertion_point(destructor:tunnelbroker.OutboundMessage)
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void OutboundMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  todeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void OutboundMessage::ArenaDtor(void* object) {
+  OutboundMessage* _this = reinterpret_cast< OutboundMessage* >(object);
+  (void)_this;
+}
+void OutboundMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void OutboundMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void OutboundMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:tunnelbroker.OutboundMessage)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  blobhashes_.Clear();
+  todeviceid_.ClearToEmpty();
+  payload_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* OutboundMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // string toDeviceID = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          auto str = _internal_mutable_todeviceid();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.toDeviceID"));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string payload = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          auto str = _internal_mutable_payload();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.payload"));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // repeated string blobHashes = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_blobhashes();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.blobHashes"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* OutboundMessage::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.OutboundMessage)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string toDeviceID = 1;
+  if (this->todeviceid().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_todeviceid().data(), static_cast<int>(this->_internal_todeviceid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "tunnelbroker.OutboundMessage.toDeviceID");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_todeviceid(), target);
+  }
+
+  // string payload = 2;
+  if (this->payload().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_payload().data(), static_cast<int>(this->_internal_payload().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "tunnelbroker.OutboundMessage.payload");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_payload(), target);
+  }
+
+  // repeated string blobHashes = 3;
+  for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) {
+    const auto& s = this->_internal_blobhashes(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "tunnelbroker.OutboundMessage.blobHashes");
+    target = stream->WriteString(3, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.OutboundMessage)
+  return target;
+}
+
+size_t OutboundMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.OutboundMessage)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string blobHashes = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size());
+  for (int i = 0, n = blobhashes_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      blobhashes_.Get(i));
+  }
+
+  // string toDeviceID = 1;
+  if (this->todeviceid().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_todeviceid());
+  }
+
+  // string payload = 2;
+  if (this->payload().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_payload());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void OutboundMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.OutboundMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const OutboundMessage* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<OutboundMessage>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.OutboundMessage)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.OutboundMessage)
+    MergeFrom(*source);
+  }
+}
+
+void OutboundMessage::MergeFrom(const OutboundMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.OutboundMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  blobhashes_.MergeFrom(from.blobhashes_);
+  if (from.todeviceid().size() > 0) {
+    _internal_set_todeviceid(from._internal_todeviceid());
+  }
+  if (from.payload().size() > 0) {
+    _internal_set_payload(from._internal_payload());
+  }
+}
+
+void OutboundMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.OutboundMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void OutboundMessage::CopyFrom(const OutboundMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.OutboundMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool OutboundMessage::IsInitialized() const {
+  return true;
+}
+
+void OutboundMessage::InternalSwap(OutboundMessage* other) {
+  using std::swap;
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+  blobhashes_.InternalSwap(&other->blobhashes_);
+  todeviceid_.Swap(&other->todeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata OutboundMessage::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class InboundMessage::_Internal {
+ public:
+};
+
+InboundMessage::InboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
+  blobhashes_(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:tunnelbroker.InboundMessage)
+}
+InboundMessage::InboundMessage(const InboundMessage& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      blobhashes_(from.blobhashes_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from._internal_fromdeviceid().empty()) {
+    fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromdeviceid(), 
+      GetArena());
+  }
+  fromconnectionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from._internal_fromconnectionid().empty()) {
+    fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromconnectionid(), 
+      GetArena());
+  }
+  payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from._internal_payload().empty()) {
+    payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(), 
+      GetArena());
+  }
+  // @@protoc_insertion_point(copy_constructor:tunnelbroker.InboundMessage)
+}
+
+void InboundMessage::SharedCtor() {
+fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+fromconnectionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+InboundMessage::~InboundMessage() {
+  // @@protoc_insertion_point(destructor:tunnelbroker.InboundMessage)
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void InboundMessage::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  fromdeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  fromconnectionid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void InboundMessage::ArenaDtor(void* object) {
+  InboundMessage* _this = reinterpret_cast< InboundMessage* >(object);
+  (void)_this;
+}
+void InboundMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void InboundMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void InboundMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:tunnelbroker.InboundMessage)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  blobhashes_.Clear();
+  fromdeviceid_.ClearToEmpty();
+  fromconnectionid_.ClearToEmpty();
+  payload_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* InboundMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // string fromDeviceID = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          auto str = _internal_mutable_fromdeviceid();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.fromDeviceID"));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string fromConnectionID = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          auto str = _internal_mutable_fromconnectionid();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.fromConnectionID"));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string payload = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+          auto str = _internal_mutable_payload();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.payload"));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // repeated string blobHashes = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_blobhashes();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.blobHashes"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* InboundMessage::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.InboundMessage)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string fromDeviceID = 1;
+  if (this->fromdeviceid().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_fromdeviceid().data(), static_cast<int>(this->_internal_fromdeviceid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "tunnelbroker.InboundMessage.fromDeviceID");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_fromdeviceid(), target);
+  }
+
+  // string fromConnectionID = 2;
+  if (this->fromconnectionid().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_fromconnectionid().data(), static_cast<int>(this->_internal_fromconnectionid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "tunnelbroker.InboundMessage.fromConnectionID");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_fromconnectionid(), target);
+  }
+
+  // string payload = 3;
+  if (this->payload().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_payload().data(), static_cast<int>(this->_internal_payload().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "tunnelbroker.InboundMessage.payload");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_payload(), target);
+  }
+
+  // repeated string blobHashes = 4;
+  for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) {
+    const auto& s = this->_internal_blobhashes(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "tunnelbroker.InboundMessage.blobHashes");
+    target = stream->WriteString(4, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.InboundMessage)
+  return target;
+}
+
+size_t InboundMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.InboundMessage)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string blobHashes = 4;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size());
+  for (int i = 0, n = blobhashes_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      blobhashes_.Get(i));
+  }
+
+  // string fromDeviceID = 1;
+  if (this->fromdeviceid().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_fromdeviceid());
+  }
+
+  // string fromConnectionID = 2;
+  if (this->fromconnectionid().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_fromconnectionid());
+  }
+
+  // string payload = 3;
+  if (this->payload().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_payload());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void InboundMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.InboundMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const InboundMessage* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<InboundMessage>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.InboundMessage)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.InboundMessage)
+    MergeFrom(*source);
+  }
+}
+
+void InboundMessage::MergeFrom(const InboundMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.InboundMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  blobhashes_.MergeFrom(from.blobhashes_);
+  if (from.fromdeviceid().size() > 0) {
+    _internal_set_fromdeviceid(from._internal_fromdeviceid());
+  }
+  if (from.fromconnectionid().size() > 0) {
+    _internal_set_fromconnectionid(from._internal_fromconnectionid());
+  }
+  if (from.payload().size() > 0) {
+    _internal_set_payload(from._internal_payload());
+  }
+}
+
+void InboundMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.InboundMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void InboundMessage::CopyFrom(const InboundMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.InboundMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool InboundMessage::IsInitialized() const {
+  return true;
+}
+
+void InboundMessage::InternalSwap(InboundMessage* other) {
+  using std::swap;
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+  blobhashes_.InternalSwap(&other->blobhashes_);
+  fromdeviceid_.Swap(&other->fromdeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  fromconnectionid_.Swap(&other->fromconnectionid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata InboundMessage::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
 // ===================================================================
 
 class CheckRequest::_Internal {
@@ -3329,6 +3978,12 @@
 template<> PROTOBUF_NOINLINE ::tunnelbroker::GetResponse* Arena::CreateMaybeMessage< ::tunnelbroker::GetResponse >(Arena* arena) {
   return Arena::CreateMessageInternal< ::tunnelbroker::GetResponse >(arena);
 }
+template<> PROTOBUF_NOINLINE ::tunnelbroker::OutboundMessage* Arena::CreateMaybeMessage< ::tunnelbroker::OutboundMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::tunnelbroker::OutboundMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::tunnelbroker::InboundMessage* Arena::CreateMaybeMessage< ::tunnelbroker::InboundMessage >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::tunnelbroker::InboundMessage >(arena);
+}
 template<> PROTOBUF_NOINLINE ::tunnelbroker::CheckRequest* Arena::CreateMaybeMessage< ::tunnelbroker::CheckRequest >(Arena* arena) {
   return Arena::CreateMessageInternal< ::tunnelbroker::CheckRequest >(arena);
 }
diff --git a/native/cpp/CommonCpp/grpc/protos/backup.proto b/native/cpp/CommonCpp/grpc/protos/backup.proto
--- a/native/cpp/CommonCpp/grpc/protos/backup.proto
+++ b/native/cpp/CommonCpp/grpc/protos/backup.proto
@@ -5,48 +5,93 @@
 import "google/protobuf/empty.proto";
 
 service BackupService {
-  rpc ResetKey(stream ResetKeyRequest) returns (google.protobuf.Empty) {}
-  rpc SendLog(SendLogRequest) returns (google.protobuf.Empty) {}
-  rpc PullBackupKey(PullBackupKeyRequest) returns (PullBackupKeyResponse) {}
-  rpc PullCompaction(PullCompactionRequest) returns (stream PullCompactionResponse) {}
+  rpc CreateNewBackup(stream CreateNewBackupRequest) returns (stream CreateNewBackupResponse) {}
+  rpc SendLog(stream SendLogRequest) returns (google.protobuf.Empty) {}
+  rpc RecoverBackupKey(stream RecoverBackupKeyRequest) returns (stream RecoverBackupKeyResponse) {}
+  rpc PullBackup(stream PullBackupRequest) returns (stream PullBackupResponse) {}
 }
 
-// ResetKey
+// Helper types
 
-message ResetKeyRequest {
-  string userId = 1;
+message FullAuthenticationRequestData {
+  oneof requestBytes {
+    bytes pakeRegistrationRequest = 1;
+    bytes pakeRegistrationUpload = 2;
+    bytes pakeCredentialRequest = 3;
+    bytes pakeCredentialFinalization = 4;
+    bytes pakeChallengeResponse = 5;
+    bytes walletAuthenticationRequest = 6;
+  }
+  string userID = 7;
+}
+
+message FullAuthenticationResponseData {
+  oneof responseData {
+    bytes pakeRegistrationResponse = 1;
+    bool pakeRegistrationSuccess = 2;
+    bytes pakeCredentialResponse = 3;
+    bytes pakeChallengeMessage = 4;
+    bytes walletAuthenticationResponse = 5;
+  }
+}
+
+message SimpleAuthenticationRequestData {
+  string backupID = 1;
+  string userID = 2;
+}
+
+message AuthenticationInformationData {
   oneof data {
-    bytes newKey = 2;
-    bytes compactionChunk = 3;
+    bytes nonce = 1;
+    bytes rawMessage = 2;
+  }
+}
+
+// CreateNewBackup
+
+message CreateNewBackupRequest {
+  oneof data {
+    FullAuthenticationRequestData authenticationRequestData = 1;
+    AuthenticationInformationData authenticationInformationData = 2;
+    bytes newCompactionChunk = 3;
+  }
+}
+
+message CreateNewBackupResponse {
+  oneof data {
+    FullAuthenticationResponseData authenticationResponseData = 1;
+    string backupID = 2;
   }
 }
 
 // SendLog
 
 message SendLogRequest {
-  string userId = 1;
-  bytes data = 2;
+  SimpleAuthenticationRequestData authenticationData = 1;
+  bytes logData = 2;
 }
 
-// PullBackupKey
+// RecoverBackupKey
 
-message PullBackupKeyRequest {
-  string userId = 1;
-  bytes pakeKey = 2;
+message RecoverBackupKeyRequest {
+  FullAuthenticationRequestData authenticationData = 1;
 }
 
-message PullBackupKeyResponse {
-  bytes encryptedBackupKey = 1;
+message RecoverBackupKeyResponse {
+  oneof data {
+    FullAuthenticationResponseData authenticationResponseData = 1;
+    AuthenticationInformationData authenticationInformationData = 2;
+    string backupID = 3;
+  }
 }
 
-// PullCompaction
+// PullBackup
 
-message PullCompactionRequest {
-  string userId = 1;
-  bytes message = 2;
+message PullBackupRequest {
+  SimpleAuthenticationRequestData authenticationData = 1;
 }
 
-message PullCompactionResponse {
+message PullBackupResponse {
   oneof data {
     bytes compactionChunk = 1;
     bytes logChunk = 2;