api.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: api/api.proto

package api

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	messages "github.com/percona/percona-backup-mongodb/proto/messages"
	grpc "google.golang.org/grpc"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type BackupType int32

const (
	BackupType_BACKUP_TYPE_INVALID   BackupType = 0
	BackupType_BACKUP_TYPE_LOGICAL   BackupType = 1
	BackupType_BACKUP_TYPE_HOTBACKUP BackupType = 2
)

var BackupType_name = map[int32]string{
	0: "BACKUP_TYPE_INVALID",
	1: "BACKUP_TYPE_LOGICAL",
	2: "BACKUP_TYPE_HOTBACKUP",
}

var BackupType_value = map[string]int32{
	"BACKUP_TYPE_INVALID":   0,
	"BACKUP_TYPE_LOGICAL":   1,
	"BACKUP_TYPE_HOTBACKUP": 2,
}

func (x BackupType) String() string {
	return proto.EnumName(BackupType_name, int32(x))
}

func (BackupType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{0}
}

type CompressionType int32

const (
	CompressionType_COMPRESSION_TYPE_INVALID        CompressionType = 0
	CompressionType_COMPRESSION_TYPE_NO_COMPRESSION CompressionType = 1
	CompressionType_COMPRESSION_TYPE_GZIP           CompressionType = 2
	CompressionType_COMPRESSION_TYPE_SNAPPY         CompressionType = 3
	CompressionType_COMPRESSION_TYPE_LZ4            CompressionType = 4
)

var CompressionType_name = map[int32]string{
	0: "COMPRESSION_TYPE_INVALID",
	1: "COMPRESSION_TYPE_NO_COMPRESSION",
	2: "COMPRESSION_TYPE_GZIP",
	3: "COMPRESSION_TYPE_SNAPPY",
	4: "COMPRESSION_TYPE_LZ4",
}

var CompressionType_value = map[string]int32{
	"COMPRESSION_TYPE_INVALID":        0,
	"COMPRESSION_TYPE_NO_COMPRESSION": 1,
	"COMPRESSION_TYPE_GZIP":           2,
	"COMPRESSION_TYPE_SNAPPY":         3,
	"COMPRESSION_TYPE_LZ4":            4,
}

func (x CompressionType) String() string {
	return proto.EnumName(CompressionType_name, int32(x))
}

func (CompressionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{1}
}

type Cypher int32

const (
	Cypher_CYPHER_INVALID   Cypher = 0
	Cypher_CYPHER_NO_CYPHER Cypher = 1
	Cypher_CYPHER_AES       Cypher = 2
	Cypher_CYPHER_DES       Cypher = 3
	Cypher_CYPHER_RC4       Cypher = 4
	Cypher_CYPHER_RSA       Cypher = 5
)

var Cypher_name = map[int32]string{
	0: "CYPHER_INVALID",
	1: "CYPHER_NO_CYPHER",
	2: "CYPHER_AES",
	3: "CYPHER_DES",
	4: "CYPHER_RC4",
	5: "CYPHER_RSA",
}

var Cypher_value = map[string]int32{
	"CYPHER_INVALID":   0,
	"CYPHER_NO_CYPHER": 1,
	"CYPHER_AES":       2,
	"CYPHER_DES":       3,
	"CYPHER_RC4":       4,
	"CYPHER_RSA":       5,
}

func (x Cypher) String() string {
	return proto.EnumName(Cypher_name, int32(x))
}

func (Cypher) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{2}
}

type Empty struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Empty) Reset()         { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage()    {}
func (*Empty) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{0}
}

func (m *Empty) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Empty.Unmarshal(m, b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
}
func (m *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(m, src)
}
func (m *Empty) XXX_Size() int {
	return xxx_messageInfo_Empty.Size(m)
}
func (m *Empty) XXX_DiscardUnknown() {
	xxx_messageInfo_Empty.DiscardUnknown(m)
}

var xxx_messageInfo_Empty proto.InternalMessageInfo

type BackupsMetadataParams struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BackupsMetadataParams) Reset()         { *m = BackupsMetadataParams{} }
func (m *BackupsMetadataParams) String() string { return proto.CompactTextString(m) }
func (*BackupsMetadataParams) ProtoMessage()    {}
func (*BackupsMetadataParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{1}
}

func (m *BackupsMetadataParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BackupsMetadataParams.Unmarshal(m, b)
}
func (m *BackupsMetadataParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BackupsMetadataParams.Marshal(b, m, deterministic)
}
func (m *BackupsMetadataParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupsMetadataParams.Merge(m, src)
}
func (m *BackupsMetadataParams) XXX_Size() int {
	return xxx_messageInfo_BackupsMetadataParams.Size(m)
}
func (m *BackupsMetadataParams) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupsMetadataParams.DiscardUnknown(m)
}

var xxx_messageInfo_BackupsMetadataParams proto.InternalMessageInfo

type LastBackupMetadataParams struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LastBackupMetadataParams) Reset()         { *m = LastBackupMetadataParams{} }
func (m *LastBackupMetadataParams) String() string { return proto.CompactTextString(m) }
func (*LastBackupMetadataParams) ProtoMessage()    {}
func (*LastBackupMetadataParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{2}
}

func (m *LastBackupMetadataParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LastBackupMetadataParams.Unmarshal(m, b)
}
func (m *LastBackupMetadataParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LastBackupMetadataParams.Marshal(b, m, deterministic)
}
func (m *LastBackupMetadataParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LastBackupMetadataParams.Merge(m, src)
}
func (m *LastBackupMetadataParams) XXX_Size() int {
	return xxx_messageInfo_LastBackupMetadataParams.Size(m)
}
func (m *LastBackupMetadataParams) XXX_DiscardUnknown() {
	xxx_messageInfo_LastBackupMetadataParams.DiscardUnknown(m)
}

var xxx_messageInfo_LastBackupMetadataParams proto.InternalMessageInfo

type ListStoragesParams struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListStoragesParams) Reset()         { *m = ListStoragesParams{} }
func (m *ListStoragesParams) String() string { return proto.CompactTextString(m) }
func (*ListStoragesParams) ProtoMessage()    {}
func (*ListStoragesParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{3}
}

func (m *ListStoragesParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListStoragesParams.Unmarshal(m, b)
}
func (m *ListStoragesParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListStoragesParams.Marshal(b, m, deterministic)
}
func (m *ListStoragesParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListStoragesParams.Merge(m, src)
}
func (m *ListStoragesParams) XXX_Size() int {
	return xxx_messageInfo_ListStoragesParams.Size(m)
}
func (m *ListStoragesParams) XXX_DiscardUnknown() {
	xxx_messageInfo_ListStoragesParams.DiscardUnknown(m)
}

var xxx_messageInfo_ListStoragesParams proto.InternalMessageInfo

type LastBackupErrorsParams struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LastBackupErrorsParams) Reset()         { *m = LastBackupErrorsParams{} }
func (m *LastBackupErrorsParams) String() string { return proto.CompactTextString(m) }
func (*LastBackupErrorsParams) ProtoMessage()    {}
func (*LastBackupErrorsParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{4}
}

func (m *LastBackupErrorsParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LastBackupErrorsParams.Unmarshal(m, b)
}
func (m *LastBackupErrorsParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LastBackupErrorsParams.Marshal(b, m, deterministic)
}
func (m *LastBackupErrorsParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LastBackupErrorsParams.Merge(m, src)
}
func (m *LastBackupErrorsParams) XXX_Size() int {
	return xxx_messageInfo_LastBackupErrorsParams.Size(m)
}
func (m *LastBackupErrorsParams) XXX_DiscardUnknown() {
	xxx_messageInfo_LastBackupErrorsParams.DiscardUnknown(m)
}

var xxx_messageInfo_LastBackupErrorsParams proto.InternalMessageInfo

type RunBackupResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RunBackupResponse) Reset()         { *m = RunBackupResponse{} }
func (m *RunBackupResponse) String() string { return proto.CompactTextString(m) }
func (*RunBackupResponse) ProtoMessage()    {}
func (*RunBackupResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{5}
}

func (m *RunBackupResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RunBackupResponse.Unmarshal(m, b)
}
func (m *RunBackupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RunBackupResponse.Marshal(b, m, deterministic)
}
func (m *RunBackupResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RunBackupResponse.Merge(m, src)
}
func (m *RunBackupResponse) XXX_Size() int {
	return xxx_messageInfo_RunBackupResponse.Size(m)
}
func (m *RunBackupResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RunBackupResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RunBackupResponse proto.InternalMessageInfo

type RunRestoreResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RunRestoreResponse) Reset()         { *m = RunRestoreResponse{} }
func (m *RunRestoreResponse) String() string { return proto.CompactTextString(m) }
func (*RunRestoreResponse) ProtoMessage()    {}
func (*RunRestoreResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{6}
}

func (m *RunRestoreResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RunRestoreResponse.Unmarshal(m, b)
}
func (m *RunRestoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RunRestoreResponse.Marshal(b, m, deterministic)
}
func (m *RunRestoreResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RunRestoreResponse.Merge(m, src)
}
func (m *RunRestoreResponse) XXX_Size() int {
	return xxx_messageInfo_RunRestoreResponse.Size(m)
}
func (m *RunRestoreResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RunRestoreResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RunRestoreResponse proto.InternalMessageInfo

type Error struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	Code                 int64    `protobuf:"varint,2,opt,name=code,proto3" json:"code,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Error) Reset()         { *m = Error{} }
func (m *Error) String() string { return proto.CompactTextString(m) }
func (*Error) ProtoMessage()    {}
func (*Error) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{7}
}

func (m *Error) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Error.Unmarshal(m, b)
}
func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Error.Marshal(b, m, deterministic)
}
func (m *Error) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Error.Merge(m, src)
}
func (m *Error) XXX_Size() int {
	return xxx_messageInfo_Error.Size(m)
}
func (m *Error) XXX_DiscardUnknown() {
	xxx_messageInfo_Error.DiscardUnknown(m)
}

var xxx_messageInfo_Error proto.InternalMessageInfo

func (m *Error) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *Error) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

type ClientStatus struct {
	ReplicasetUuid       string   `protobuf:"bytes,1,opt,name=replicaset_uuid,json=replicasetUuid,proto3" json:"replicaset_uuid,omitempty"`
	ReplicasetName       string   `protobuf:"bytes,2,opt,name=replicaset_name,json=replicasetName,proto3" json:"replicaset_name,omitempty"`
	ReplicasetVersion    uint64   `protobuf:"varint,3,opt,name=replicaset_version,json=replicasetVersion,proto3" json:"replicaset_version,omitempty"`
	RunningDbBackup      bool     `protobuf:"varint,4,opt,name=running_db_backup,json=runningDbBackup,proto3" json:"running_db_backup,omitempty"`
	RunningOplogBackup   bool     `protobuf:"varint,5,opt,name=running_oplog_backup,json=runningOplogBackup,proto3" json:"running_oplog_backup,omitempty"`
	BackupType           string   `protobuf:"bytes,6,opt,name=backup_type,json=backupType,proto3" json:"backup_type,omitempty"`
	Compression          string   `protobuf:"bytes,7,opt,name=compression,proto3" json:"compression,omitempty"`
	Encrypted            string   `protobuf:"bytes,8,opt,name=encrypted,proto3" json:"encrypted,omitempty"`
	Filename             string   `protobuf:"bytes,9,opt,name=filename,proto3" json:"filename,omitempty"`
	Started              int64    `protobuf:"varint,10,opt,name=started,proto3" json:"started,omitempty"`
	Finished             int64    `protobuf:"varint,11,opt,name=finished,proto3" json:"finished,omitempty"`
	StartOplogTs         int64    `protobuf:"varint,12,opt,name=start_oplog_ts,json=startOplogTs,proto3" json:"start_oplog_ts,omitempty"`
	LastOplogTs          int64    `protobuf:"varint,13,opt,name=last_oplog_ts,json=lastOplogTs,proto3" json:"last_oplog_ts,omitempty"`
	LastError            string   `protobuf:"bytes,14,opt,name=last_error,json=lastError,proto3" json:"last_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ClientStatus) Reset()         { *m = ClientStatus{} }
func (m *ClientStatus) String() string { return proto.CompactTextString(m) }
func (*ClientStatus) ProtoMessage()    {}
func (*ClientStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{8}
}

func (m *ClientStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientStatus.Unmarshal(m, b)
}
func (m *ClientStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientStatus.Marshal(b, m, deterministic)
}
func (m *ClientStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientStatus.Merge(m, src)
}
func (m *ClientStatus) XXX_Size() int {
	return xxx_messageInfo_ClientStatus.Size(m)
}
func (m *ClientStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ClientStatus proto.InternalMessageInfo

func (m *ClientStatus) GetReplicasetUuid() string {
	if m != nil {
		return m.ReplicasetUuid
	}
	return ""
}

func (m *ClientStatus) GetReplicasetName() string {
	if m != nil {
		return m.ReplicasetName
	}
	return ""
}

func (m *ClientStatus) GetReplicasetVersion() uint64 {
	if m != nil {
		return m.ReplicasetVersion
	}
	return 0
}

func (m *ClientStatus) GetRunningDbBackup() bool {
	if m != nil {
		return m.RunningDbBackup
	}
	return false
}

func (m *ClientStatus) GetRunningOplogBackup() bool {
	if m != nil {
		return m.RunningOplogBackup
	}
	return false
}

func (m *ClientStatus) GetBackupType() string {
	if m != nil {
		return m.BackupType
	}
	return ""
}

func (m *ClientStatus) GetCompression() string {
	if m != nil {
		return m.Compression
	}
	return ""
}

func (m *ClientStatus) GetEncrypted() string {
	if m != nil {
		return m.Encrypted
	}
	return ""
}

func (m *ClientStatus) GetFilename() string {
	if m != nil {
		return m.Filename
	}
	return ""
}

func (m *ClientStatus) GetStarted() int64 {
	if m != nil {
		return m.Started
	}
	return 0
}

func (m *ClientStatus) GetFinished() int64 {
	if m != nil {
		return m.Finished
	}
	return 0
}

func (m *ClientStatus) GetStartOplogTs() int64 {
	if m != nil {
		return m.StartOplogTs
	}
	return 0
}

func (m *ClientStatus) GetLastOplogTs() int64 {
	if m != nil {
		return m.LastOplogTs
	}
	return 0
}

func (m *ClientStatus) GetLastError() string {
	if m != nil {
		return m.LastError
	}
	return ""
}

type Client struct {
	Version              int32         `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	Id                   string        `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	NodeType             string        `protobuf:"bytes,3,opt,name=node_type,json=nodeType,proto3" json:"node_type,omitempty"`
	NodeName             string        `protobuf:"bytes,4,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
	ClusterId            string        `protobuf:"bytes,5,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	ReplicasetName       string        `protobuf:"bytes,6,opt,name=replicaset_name,json=replicasetName,proto3" json:"replicaset_name,omitempty"`
	ReplicasetId         string        `protobuf:"bytes,7,opt,name=replicaset_id,json=replicasetId,proto3" json:"replicaset_id,omitempty"`
	LastCommandSent      string        `protobuf:"bytes,8,opt,name=last_command_sent,json=lastCommandSent,proto3" json:"last_command_sent,omitempty"`
	LastSeen             int64         `protobuf:"varint,9,opt,name=last_seen,json=lastSeen,proto3" json:"last_seen,omitempty"`
	Status               *ClientStatus `protobuf:"bytes,10,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Client) Reset()         { *m = Client{} }
func (m *Client) String() string { return proto.CompactTextString(m) }
func (*Client) ProtoMessage()    {}
func (*Client) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{9}
}

func (m *Client) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Client.Unmarshal(m, b)
}
func (m *Client) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Client.Marshal(b, m, deterministic)
}
func (m *Client) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Client.Merge(m, src)
}
func (m *Client) XXX_Size() int {
	return xxx_messageInfo_Client.Size(m)
}
func (m *Client) XXX_DiscardUnknown() {
	xxx_messageInfo_Client.DiscardUnknown(m)
}

var xxx_messageInfo_Client proto.InternalMessageInfo

func (m *Client) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *Client) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Client) GetNodeType() string {
	if m != nil {
		return m.NodeType
	}
	return ""
}

func (m *Client) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

func (m *Client) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

func (m *Client) GetReplicasetName() string {
	if m != nil {
		return m.ReplicasetName
	}
	return ""
}

func (m *Client) GetReplicasetId() string {
	if m != nil {
		return m.ReplicasetId
	}
	return ""
}

func (m *Client) GetLastCommandSent() string {
	if m != nil {
		return m.LastCommandSent
	}
	return ""
}

func (m *Client) GetLastSeen() int64 {
	if m != nil {
		return m.LastSeen
	}
	return 0
}

func (m *Client) GetStatus() *ClientStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type GetStorageInfoParams struct {
	StorageName          string   `protobuf:"bytes,1,opt,name=storage_name,json=storageName,proto3" json:"storage_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetStorageInfoParams) Reset()         { *m = GetStorageInfoParams{} }
func (m *GetStorageInfoParams) String() string { return proto.CompactTextString(m) }
func (*GetStorageInfoParams) ProtoMessage()    {}
func (*GetStorageInfoParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{10}
}

func (m *GetStorageInfoParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetStorageInfoParams.Unmarshal(m, b)
}
func (m *GetStorageInfoParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetStorageInfoParams.Marshal(b, m, deterministic)
}
func (m *GetStorageInfoParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetStorageInfoParams.Merge(m, src)
}
func (m *GetStorageInfoParams) XXX_Size() int {
	return xxx_messageInfo_GetStorageInfoParams.Size(m)
}
func (m *GetStorageInfoParams) XXX_DiscardUnknown() {
	xxx_messageInfo_GetStorageInfoParams.DiscardUnknown(m)
}

var xxx_messageInfo_GetStorageInfoParams proto.InternalMessageInfo

func (m *GetStorageInfoParams) GetStorageName() string {
	if m != nil {
		return m.StorageName
	}
	return ""
}

type MetadataFile struct {
	Filename             string                   `protobuf:"bytes,1,opt,name=filename,proto3" json:"filename,omitempty"`
	Metadata             *messages.BackupMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *MetadataFile) Reset()         { *m = MetadataFile{} }
func (m *MetadataFile) String() string { return proto.CompactTextString(m) }
func (*MetadataFile) ProtoMessage()    {}
func (*MetadataFile) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{11}
}

func (m *MetadataFile) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MetadataFile.Unmarshal(m, b)
}
func (m *MetadataFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MetadataFile.Marshal(b, m, deterministic)
}
func (m *MetadataFile) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetadataFile.Merge(m, src)
}
func (m *MetadataFile) XXX_Size() int {
	return xxx_messageInfo_MetadataFile.Size(m)
}
func (m *MetadataFile) XXX_DiscardUnknown() {
	xxx_messageInfo_MetadataFile.DiscardUnknown(m)
}

var xxx_messageInfo_MetadataFile proto.InternalMessageInfo

func (m *MetadataFile) GetFilename() string {
	if m != nil {
		return m.Filename
	}
	return ""
}

func (m *MetadataFile) GetMetadata() *messages.BackupMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

type RunBackupParams struct {
	BackupType           BackupType      `protobuf:"varint,1,opt,name=backup_type,json=backupType,proto3,enum=api.BackupType" json:"backup_type,omitempty"`
	CompressionType      CompressionType `protobuf:"varint,2,opt,name=compression_type,json=compressionType,proto3,enum=api.CompressionType" json:"compression_type,omitempty"`
	Cypher               Cypher          `protobuf:"varint,3,opt,name=cypher,proto3,enum=api.Cypher" json:"cypher,omitempty"`
	Filename             string          `protobuf:"bytes,4,opt,name=filename,proto3" json:"filename,omitempty"`
	StartOplogTs         int64           `protobuf:"varint,5,opt,name=start_oplog_ts,json=startOplogTs,proto3" json:"start_oplog_ts,omitempty"`
	Description          string          `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"`
	StorageName          string          `protobuf:"bytes,7,opt,name=storage_name,json=storageName,proto3" json:"storage_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *RunBackupParams) Reset()         { *m = RunBackupParams{} }
func (m *RunBackupParams) String() string { return proto.CompactTextString(m) }
func (*RunBackupParams) ProtoMessage()    {}
func (*RunBackupParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{12}
}

func (m *RunBackupParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RunBackupParams.Unmarshal(m, b)
}
func (m *RunBackupParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RunBackupParams.Marshal(b, m, deterministic)
}
func (m *RunBackupParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RunBackupParams.Merge(m, src)
}
func (m *RunBackupParams) XXX_Size() int {
	return xxx_messageInfo_RunBackupParams.Size(m)
}
func (m *RunBackupParams) XXX_DiscardUnknown() {
	xxx_messageInfo_RunBackupParams.DiscardUnknown(m)
}

var xxx_messageInfo_RunBackupParams proto.InternalMessageInfo

func (m *RunBackupParams) GetBackupType() BackupType {
	if m != nil {
		return m.BackupType
	}
	return BackupType_BACKUP_TYPE_INVALID
}

func (m *RunBackupParams) GetCompressionType() CompressionType {
	if m != nil {
		return m.CompressionType
	}
	return CompressionType_COMPRESSION_TYPE_INVALID
}

func (m *RunBackupParams) GetCypher() Cypher {
	if m != nil {
		return m.Cypher
	}
	return Cypher_CYPHER_INVALID
}

func (m *RunBackupParams) GetFilename() string {
	if m != nil {
		return m.Filename
	}
	return ""
}

func (m *RunBackupParams) GetStartOplogTs() int64 {
	if m != nil {
		return m.StartOplogTs
	}
	return 0
}

func (m *RunBackupParams) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *RunBackupParams) GetStorageName() string {
	if m != nil {
		return m.StorageName
	}
	return ""
}

type RunRestoreParams struct {
	MetadataFile         string   `protobuf:"bytes,1,opt,name=metadata_file,json=metadataFile,proto3" json:"metadata_file,omitempty"`
	SkipUsersAndRoles    bool     `protobuf:"varint,2,opt,name=skip_users_and_roles,json=skipUsersAndRoles,proto3" json:"skip_users_and_roles,omitempty"`
	StorageName          string   `protobuf:"bytes,3,opt,name=storage_name,json=storageName,proto3" json:"storage_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RunRestoreParams) Reset()         { *m = RunRestoreParams{} }
func (m *RunRestoreParams) String() string { return proto.CompactTextString(m) }
func (*RunRestoreParams) ProtoMessage()    {}
func (*RunRestoreParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{13}
}

func (m *RunRestoreParams) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RunRestoreParams.Unmarshal(m, b)
}
func (m *RunRestoreParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RunRestoreParams.Marshal(b, m, deterministic)
}
func (m *RunRestoreParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RunRestoreParams.Merge(m, src)
}
func (m *RunRestoreParams) XXX_Size() int {
	return xxx_messageInfo_RunRestoreParams.Size(m)
}
func (m *RunRestoreParams) XXX_DiscardUnknown() {
	xxx_messageInfo_RunRestoreParams.DiscardUnknown(m)
}

var xxx_messageInfo_RunRestoreParams proto.InternalMessageInfo

func (m *RunRestoreParams) GetMetadataFile() string {
	if m != nil {
		return m.MetadataFile
	}
	return ""
}

func (m *RunRestoreParams) GetSkipUsersAndRoles() bool {
	if m != nil {
		return m.SkipUsersAndRoles
	}
	return false
}

func (m *RunRestoreParams) GetStorageName() string {
	if m != nil {
		return m.StorageName
	}
	return ""
}

type BackupReplica struct {
	AgentId              string   `protobuf:"bytes,1,opt,name=agent_id,json=agentId,proto3" json:"agent_id,omitempty"`
	NodeType             string   `protobuf:"bytes,2,opt,name=node_type,json=nodeType,proto3" json:"node_type,omitempty"`
	NodeName             string   `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
	ClusterId            string   `protobuf:"bytes,4,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	ReplicasetName       string   `protobuf:"bytes,5,opt,name=replicaset_name,json=replicasetName,proto3" json:"replicaset_name,omitempty"`
	ReplicasetId         string   `protobuf:"bytes,6,opt,name=replicaset_id,json=replicasetId,proto3" json:"replicaset_id,omitempty"`
	StartedAt            int64    `protobuf:"varint,7,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BackupReplica) Reset()         { *m = BackupReplica{} }
func (m *BackupReplica) String() string { return proto.CompactTextString(m) }
func (*BackupReplica) ProtoMessage()    {}
func (*BackupReplica) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{14}
}

func (m *BackupReplica) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BackupReplica.Unmarshal(m, b)
}
func (m *BackupReplica) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BackupReplica.Marshal(b, m, deterministic)
}
func (m *BackupReplica) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BackupReplica.Merge(m, src)
}
func (m *BackupReplica) XXX_Size() int {
	return xxx_messageInfo_BackupReplica.Size(m)
}
func (m *BackupReplica) XXX_DiscardUnknown() {
	xxx_messageInfo_BackupReplica.DiscardUnknown(m)
}

var xxx_messageInfo_BackupReplica proto.InternalMessageInfo

func (m *BackupReplica) GetAgentId() string {
	if m != nil {
		return m.AgentId
	}
	return ""
}

func (m *BackupReplica) GetNodeType() string {
	if m != nil {
		return m.NodeType
	}
	return ""
}

func (m *BackupReplica) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

func (m *BackupReplica) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

func (m *BackupReplica) GetReplicasetName() string {
	if m != nil {
		return m.ReplicasetName
	}
	return ""
}

func (m *BackupReplica) GetReplicasetId() string {
	if m != nil {
		return m.ReplicasetId
	}
	return ""
}

func (m *BackupReplica) GetStartedAt() int64 {
	if m != nil {
		return m.StartedAt
	}
	return 0
}

type LastBackupError struct {
	Error                string   `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LastBackupError) Reset()         { *m = LastBackupError{} }
func (m *LastBackupError) String() string { return proto.CompactTextString(m) }
func (*LastBackupError) ProtoMessage()    {}
func (*LastBackupError) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{15}
}

func (m *LastBackupError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LastBackupError.Unmarshal(m, b)
}
func (m *LastBackupError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LastBackupError.Marshal(b, m, deterministic)
}
func (m *LastBackupError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LastBackupError.Merge(m, src)
}
func (m *LastBackupError) XXX_Size() int {
	return xxx_messageInfo_LastBackupError.Size(m)
}
func (m *LastBackupError) XXX_DiscardUnknown() {
	xxx_messageInfo_LastBackupError.DiscardUnknown(m)
}

var xxx_messageInfo_LastBackupError proto.InternalMessageInfo

func (m *LastBackupError) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

type StorageInfo struct {
	Name                 string                `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	MatchClients         []string              `protobuf:"bytes,2,rep,name=match_clients,json=matchClients,proto3" json:"match_clients,omitempty"`
	DifferClients        []string              `protobuf:"bytes,3,rep,name=differ_clients,json=differClients,proto3" json:"differ_clients,omitempty"`
	Info                 *messages.StorageInfo `protobuf:"bytes,4,opt,name=Info,proto3" json:"Info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *StorageInfo) Reset()         { *m = StorageInfo{} }
func (m *StorageInfo) String() string { return proto.CompactTextString(m) }
func (*StorageInfo) ProtoMessage()    {}
func (*StorageInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b40cafcd4234784, []int{16}
}

func (m *StorageInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StorageInfo.Unmarshal(m, b)
}
func (m *StorageInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StorageInfo.Marshal(b, m, deterministic)
}
func (m *StorageInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageInfo.Merge(m, src)
}
func (m *StorageInfo) XXX_Size() int {
	return xxx_messageInfo_StorageInfo.Size(m)
}
func (m *StorageInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageInfo.DiscardUnknown(m)
}

var xxx_messageInfo_StorageInfo proto.InternalMessageInfo

func (m *StorageInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *StorageInfo) GetMatchClients() []string {
	if m != nil {
		return m.MatchClients
	}
	return nil
}

func (m *StorageInfo) GetDifferClients() []string {
	if m != nil {
		return m.DifferClients
	}
	return nil
}

func (m *StorageInfo) GetInfo() *messages.StorageInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

func init() {
	proto.RegisterEnum("api.BackupType", BackupType_name, BackupType_value)
	proto.RegisterEnum("api.CompressionType", CompressionType_name, CompressionType_value)
	proto.RegisterEnum("api.Cypher", Cypher_name, Cypher_value)
	proto.RegisterType((*Empty)(nil), "api.Empty")
	proto.RegisterType((*BackupsMetadataParams)(nil), "api.BackupsMetadataParams")
	proto.RegisterType((*LastBackupMetadataParams)(nil), "api.LastBackupMetadataParams")
	proto.RegisterType((*ListStoragesParams)(nil), "api.ListStoragesParams")
	proto.RegisterType((*LastBackupErrorsParams)(nil), "api.LastBackupErrorsParams")
	proto.RegisterType((*RunBackupResponse)(nil), "api.RunBackupResponse")
	proto.RegisterType((*RunRestoreResponse)(nil), "api.RunRestoreResponse")
	proto.RegisterType((*Error)(nil), "api.Error")
	proto.RegisterType((*ClientStatus)(nil), "api.ClientStatus")
	proto.RegisterType((*Client)(nil), "api.Client")
	proto.RegisterType((*GetStorageInfoParams)(nil), "api.GetStorageInfoParams")
	proto.RegisterType((*MetadataFile)(nil), "api.MetadataFile")
	proto.RegisterType((*RunBackupParams)(nil), "api.RunBackupParams")
	proto.RegisterType((*RunRestoreParams)(nil), "api.RunRestoreParams")
	proto.RegisterType((*BackupReplica)(nil), "api.BackupReplica")
	proto.RegisterType((*LastBackupError)(nil), "api.LastBackupError")
	proto.RegisterType((*StorageInfo)(nil), "api.StorageInfo")
}

func init() { proto.RegisterFile("api/api.proto", fileDescriptor_1b40cafcd4234784) }

var fileDescriptor_1b40cafcd4234784 = []byte{
	// 1283 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x56, 0xdd, 0x6e, 0xdb, 0x46,
	0x13, 0x35, 0x45, 0x49, 0x96, 0x86, 0xfa, 0xa1, 0x37, 0x72, 0xcc, 0x28, 0x31, 0xe2, 0x8f, 0xfe,
	0x8a, 0x38, 0x06, 0x62, 0x07, 0x4e, 0x7a, 0x51, 0x14, 0x6d, 0x21, 0xcb, 0xaa, 0xa3, 0xd6, 0xb1,
	0x04, 0xca, 0x09, 0xe0, 0xdc, 0xb0, 0x34, 0xb9, 0xb6, 0x89, 0x88, 0x3f, 0xe0, 0xae, 0x0a, 0xf8,
	0xba, 0x57, 0x45, 0x5f, 0xa0, 0x4f, 0xd0, 0xeb, 0xbe, 0x48, 0xdf, 0xa5, 0x8f, 0x50, 0xec, 0x2c,
	0x29, 0x51, 0x94, 0x13, 0xe4, 0x4a, 0xdc, 0x73, 0xce, 0x8a, 0x33, 0x3b, 0x73, 0x86, 0x0b, 0x4d,
	0x27, 0xf6, 0x0f, 0x9d, 0xd8, 0x3f, 0x88, 0x93, 0x88, 0x47, 0x44, 0x75, 0x62, 0xbf, 0xbb, 0x15,
	0x50, 0xc6, 0x9c, 0x1b, 0xca, 0x0e, 0xb3, 0x07, 0xc9, 0x9a, 0xeb, 0x50, 0x19, 0x04, 0x31, 0xbf,
	0x33, 0xb7, 0x60, 0xf3, 0xd8, 0x71, 0x3f, 0xce, 0x62, 0xf6, 0x96, 0x72, 0xc7, 0x73, 0xb8, 0x33,
	0x76, 0x12, 0x27, 0x60, 0x66, 0x17, 0x8c, 0x33, 0x87, 0x71, 0x49, 0x16, 0xb8, 0x0e, 0x90, 0x33,
	0x9f, 0xf1, 0x09, 0x8f, 0x12, 0xf1, 0x9f, 0x29, 0x6a, 0xc0, 0xc3, 0xc5, 0x8e, 0x41, 0x92, 0x44,
	0x49, 0xc6, 0x3c, 0x80, 0x0d, 0x6b, 0x16, 0x4a, 0xc2, 0xa2, 0x2c, 0x8e, 0x42, 0x46, 0xc5, 0x9f,
	0x58, 0xb3, 0xd0, 0xa2, 0x8c, 0x47, 0x09, 0x9d, 0xa3, 0x5f, 0x43, 0x05, 0xb7, 0x12, 0x03, 0xd6,
	0xd3, 0x98, 0x0d, 0x65, 0x47, 0xd9, 0xab, 0x5b, 0xd9, 0x92, 0x10, 0x28, 0xbb, 0x91, 0x47, 0x8d,
	0xd2, 0x8e, 0xb2, 0xa7, 0x5a, 0xf8, 0x6c, 0xfe, 0x5e, 0x86, 0x46, 0x7f, 0xea, 0xd3, 0x90, 0x4f,
	0xb8, 0xc3, 0x67, 0x8c, 0x3c, 0x83, 0x76, 0x42, 0xe3, 0xa9, 0xef, 0x3a, 0x8c, 0x72, 0x7b, 0x36,
	0xf3, 0xbd, 0xf4, 0x6f, 0x5a, 0x0b, 0xf8, 0xdd, 0xcc, 0xf7, 0x0a, 0xc2, 0xd0, 0x09, 0xe4, 0x1f,
	0x2f, 0x09, 0xcf, 0x9d, 0x80, 0x92, 0x17, 0x40, 0x72, 0xc2, 0x5f, 0x69, 0xc2, 0xfc, 0x28, 0x34,
	0xd4, 0x1d, 0x65, 0xaf, 0x6c, 0x6d, 0x2c, 0x98, 0xf7, 0x92, 0x20, 0xfb, 0xb0, 0x91, 0xcc, 0xc2,
	0xd0, 0x0f, 0x6f, 0x6c, 0xef, 0xca, 0xbe, 0xc2, 0xdc, 0x8d, 0xf2, 0x8e, 0xb2, 0x57, 0xb3, 0xda,
	0x29, 0x71, 0x72, 0x25, 0x8f, 0x84, 0xbc, 0x84, 0x4e, 0xa6, 0x8d, 0xe2, 0x69, 0x74, 0x93, 0xc9,
	0x2b, 0x28, 0x27, 0x29, 0x37, 0x12, 0x54, 0xba, 0xe3, 0x29, 0x68, 0x52, 0x63, 0xf3, 0xbb, 0x98,
	0x1a, 0x55, 0x8c, 0x18, 0x24, 0x74, 0x71, 0x17, 0x53, 0xb2, 0x03, 0x9a, 0x1b, 0x05, 0x71, 0x42,
	0x19, 0x86, 0xb9, 0x8e, 0x82, 0x3c, 0x44, 0x9e, 0x40, 0x9d, 0x86, 0x6e, 0x72, 0x17, 0x73, 0xea,
	0x19, 0x35, 0xe4, 0x17, 0x00, 0xe9, 0x42, 0xed, 0xda, 0x9f, 0x52, 0x3c, 0x8f, 0x3a, 0x92, 0xf3,
	0xb5, 0x28, 0x0d, 0xe3, 0x4e, 0x22, 0xf6, 0x01, 0xd6, 0x20, 0x5b, 0xca, 0x5d, 0xa1, 0xcf, 0x6e,
	0xa9, 0x67, 0x68, 0x48, 0xcd, 0xd7, 0xe4, 0xff, 0xd0, 0x42, 0x59, 0x9a, 0x22, 0x67, 0x46, 0x03,
	0x15, 0x0d, 0x44, 0x31, 0xb9, 0x0b, 0x46, 0x4c, 0x68, 0x4e, 0x1d, 0x96, 0x13, 0x35, 0x51, 0xa4,
	0x09, 0x30, 0xd3, 0x6c, 0x03, 0xa0, 0x86, 0x8a, 0x46, 0x31, 0x5a, 0x32, 0x74, 0x81, 0x60, 0xe7,
	0x98, 0xff, 0x94, 0xa0, 0x2a, 0x7b, 0x41, 0x44, 0x9a, 0x15, 0x4a, 0x54, 0xbf, 0x62, 0x65, 0x4b,
	0xd2, 0x82, 0x92, 0xef, 0xa5, 0x95, 0x2e, 0xf9, 0x1e, 0x79, 0x0c, 0xf5, 0x30, 0xf2, 0xa8, 0x3c,
	0x4e, 0x55, 0x26, 0x2c, 0x00, 0x3c, 0xcc, 0x8c, 0xc4, 0xd3, 0x28, 0x2f, 0x48, 0xec, 0x8b, 0x6d,
	0x00, 0x77, 0x3a, 0x63, 0x9c, 0x26, 0xb6, 0xef, 0x61, 0xc9, 0xea, 0x56, 0x3d, 0x45, 0x86, 0xf7,
	0xf6, 0x57, 0xf5, 0xde, 0xfe, 0xda, 0x85, 0x66, 0x4e, 0xe8, 0x7b, 0x69, 0xcd, 0x1a, 0x0b, 0x70,
	0xe8, 0x89, 0xae, 0xc2, 0xd4, 0xdd, 0x28, 0x08, 0x9c, 0xd0, 0xb3, 0x19, 0x0d, 0x79, 0x5a, 0xbc,
	0xb6, 0x20, 0xfa, 0x12, 0x9f, 0x88, 0xe4, 0x1f, 0x03, 0x1e, 0x8a, 0xcd, 0x28, 0x0d, 0xb1, 0x86,
	0xaa, 0x55, 0x13, 0xc0, 0x84, 0xd2, 0x90, 0x3c, 0x87, 0x2a, 0x43, 0xa7, 0x60, 0x09, 0xb5, 0xa3,
	0x8d, 0x03, 0x31, 0x3a, 0xf2, 0x16, 0xb2, 0x52, 0x81, 0xf9, 0x0d, 0x74, 0x4e, 0x69, 0x66, 0xf6,
	0x61, 0x78, 0x1d, 0x49, 0x57, 0x93, 0xff, 0x41, 0x83, 0x49, 0x50, 0xa6, 0x25, 0xfd, 0xa5, 0xa5,
	0x98, 0xc8, 0xc9, 0xfc, 0x05, 0x1a, 0xd9, 0xe8, 0xf8, 0xd1, 0x9f, 0xd2, 0xa5, 0xae, 0x52, 0x0a,
	0x5d, 0xf5, 0x1a, 0x6a, 0x41, 0xaa, 0xc5, 0xba, 0x68, 0x47, 0xc6, 0xc1, 0x7c, 0x6a, 0x2d, 0x8f,
	0x21, 0x6b, 0xae, 0x34, 0xff, 0x2e, 0x41, 0x7b, 0x3e, 0x5b, 0xd2, 0xc0, 0x5e, 0x2e, 0x9b, 0x43,
	0xbc, 0xa8, 0x75, 0xd4, 0xc6, 0x04, 0x8f, 0xe7, 0x0e, 0x59, 0x72, 0xcb, 0x0f, 0xa0, 0xe7, 0xac,
	0x21, 0xb7, 0x95, 0x70, 0x5b, 0x47, 0x9e, 0xcb, 0x82, 0xc4, 0xbd, 0x6d, 0x77, 0x19, 0x20, 0xbb,
	0x50, 0x75, 0xef, 0xe2, 0x5b, 0x9a, 0x60, 0xef, 0xb4, 0x8e, 0x34, 0xb9, 0x0d, 0x21, 0x2b, 0xa5,
	0x96, 0xb2, 0x2f, 0x17, 0xb2, 0x5f, 0x75, 0x47, 0xe5, 0x1e, 0x77, 0xec, 0x80, 0xe6, 0x51, 0xe6,
	0x26, 0x7e, 0xcc, 0x45, 0x4f, 0xcb, 0x46, 0xca, 0x43, 0x2b, 0x45, 0x59, 0x5f, 0x2d, 0xca, 0x1f,
	0x0a, 0xe8, 0x8b, 0xc9, 0x9b, 0x9e, 0xd9, 0x2e, 0x34, 0xb3, 0x33, 0xb5, 0x45, 0x50, 0x69, 0x79,
	0x1a, 0x41, 0xbe, 0x7c, 0x87, 0xd0, 0x61, 0x1f, 0xfd, 0xd8, 0x9e, 0x31, 0x9a, 0x30, 0x5b, 0xf4,
	0x5f, 0x12, 0x4d, 0x29, 0xc3, 0xa3, 0xaa, 0x59, 0x1b, 0x82, 0x7b, 0x27, 0xa8, 0x5e, 0xe8, 0x59,
	0x82, 0x58, 0x89, 0x46, 0x5d, 0x8d, 0xe6, 0x5f, 0x05, 0x9a, 0xd9, 0x97, 0x01, 0x1b, 0x9d, 0x3c,
	0x82, 0x9a, 0x73, 0x43, 0x43, 0xf4, 0x40, 0x3a, 0xfa, 0x71, 0x3d, 0x2c, 0xb8, 0xb4, 0xf4, 0x39,
	0x97, 0xaa, 0x9f, 0x75, 0x69, 0xf9, 0x0b, 0x5c, 0x5a, 0xf9, 0x32, 0x97, 0x56, 0xef, 0x71, 0xe9,
	0x36, 0x40, 0x3a, 0x11, 0x6d, 0x87, 0x63, 0x09, 0x54, 0xab, 0x9e, 0x22, 0x3d, 0x6e, 0x3e, 0x83,
	0x76, 0xe1, 0x43, 0x49, 0x3a, 0x50, 0x91, 0xd3, 0x4c, 0x26, 0x2c, 0x17, 0xe6, 0x9f, 0x0a, 0x68,
	0x39, 0xdf, 0x89, 0x2f, 0x5f, 0xce, 0x3a, 0xf8, 0x8c, 0x85, 0x73, 0xb8, 0x7b, 0x6b, 0xbb, 0xe8,
	0x5d, 0x51, 0x0c, 0x15, 0x0b, 0x27, 0x40, 0xe9, 0x67, 0x46, 0xbe, 0x82, 0x96, 0xe7, 0x5f, 0x5f,
	0xd3, 0x64, 0xae, 0x52, 0x51, 0xd5, 0x94, 0x68, 0x26, 0x7b, 0x0e, 0x65, 0xf1, 0x1e, 0x3c, 0x1e,
	0xed, 0x68, 0x73, 0x61, 0xbf, 0x5c, 0x10, 0x16, 0x4a, 0xf6, 0x2f, 0x01, 0x16, 0x5e, 0x22, 0x5b,
	0xf0, 0xe0, 0xb8, 0xd7, 0xff, 0xf9, 0xdd, 0xd8, 0xbe, 0xb8, 0x1c, 0x0f, 0xec, 0xe1, 0xf9, 0xfb,
	0xde, 0xd9, 0xf0, 0x44, 0x5f, 0x2b, 0x12, 0x67, 0xa3, 0xd3, 0x61, 0xbf, 0x77, 0xa6, 0x2b, 0xe4,
	0x11, 0x6c, 0xe6, 0x89, 0x37, 0xa3, 0x0b, 0xb9, 0xd4, 0x4b, 0xfb, 0x7f, 0x29, 0xd0, 0x2e, 0x18,
	0x8e, 0x3c, 0x01, 0xa3, 0x3f, 0x7a, 0x3b, 0xb6, 0x06, 0x93, 0xc9, 0x70, 0x74, 0x5e, 0x7c, 0xcb,
	0x2e, 0x3c, 0x5d, 0x61, 0xcf, 0x47, 0x76, 0x0e, 0x93, 0x6f, 0x5c, 0x11, 0x9d, 0x7e, 0x18, 0x8e,
	0xf5, 0x12, 0x79, 0x0c, 0x5b, 0x2b, 0xd4, 0xe4, 0xbc, 0x37, 0x1e, 0x5f, 0xea, 0x2a, 0x31, 0xa0,
	0xb3, 0x42, 0x9e, 0x7d, 0x78, 0xad, 0x97, 0xf7, 0x13, 0xa8, 0x4a, 0x87, 0x13, 0x02, 0xad, 0xfe,
	0xe5, 0xf8, 0xcd, 0xc0, 0xca, 0x05, 0xd5, 0x01, 0x3d, 0xc5, 0x44, 0x28, 0xf8, 0xa4, 0x2b, 0xa4,
	0x05, 0x90, 0xa2, 0xbd, 0xc1, 0x44, 0x2f, 0xe5, 0xd6, 0x27, 0x83, 0x89, 0xae, 0xe6, 0xd6, 0x56,
	0xff, 0xb5, 0x5e, 0xce, 0xaf, 0x27, 0x3d, 0xbd, 0x72, 0xf4, 0x9b, 0x0a, 0x6a, 0x2f, 0xf6, 0xc9,
	0xb7, 0x50, 0x9f, 0x8f, 0x3d, 0x22, 0x87, 0x54, 0x61, 0x0c, 0x76, 0x1f, 0x2e, 0xa3, 0xf3, 0x2b,
	0xd6, 0x1a, 0xf9, 0x1e, 0x60, 0x31, 0x00, 0xc8, 0x66, 0xa6, 0x5b, 0x9a, 0x08, 0xdd, 0xad, 0x02,
	0x9c, 0xdb, 0x3f, 0x02, 0xb2, 0x7a, 0x37, 0x24, 0xdb, 0xb8, 0xe1, 0x53, 0x97, 0xc6, 0xee, 0x27,
	0xa7, 0xb9, 0xb9, 0x46, 0x4e, 0xa0, 0x5d, 0xb8, 0x85, 0x92, 0x6e, 0x6e, 0x5e, 0x17, 0xee, 0xa6,
	0x5d, 0xf9, 0xb1, 0xca, 0x7f, 0x59, 0xcc, 0xb5, 0x97, 0x0a, 0x79, 0x0e, 0x70, 0x4a, 0x79, 0xd6,
	0xcc, 0x80, 0x22, 0xbc, 0xe5, 0x76, 0xb5, 0xdc, 0xd7, 0x0d, 0xa5, 0xdf, 0x41, 0x23, 0x7f, 0x83,
	0x25, 0x32, 0xd9, 0xd5, 0x4b, 0x6d, 0x57, 0x47, 0x22, 0xd7, 0xff, 0x62, 0xfb, 0xf1, 0x4f, 0xb0,
	0xee, 0x46, 0x81, 0xa0, 0x8e, 0x6b, 0xbd, 0xd8, 0x1f, 0x8b, 0x3b, 0xf5, 0x58, 0xf9, 0xf0, 0xea,
	0xc6, 0xe7, 0xb7, 0xb3, 0xab, 0x03, 0x37, 0x0a, 0x0e, 0x63, 0x9a, 0xb8, 0x51, 0xe8, 0x64, 0xbf,
	0x2f, 0xe4, 0xd7, 0xe6, 0x45, 0x10, 0x85, 0x37, 0x91, 0x77, 0x75, 0x88, 0xd7, 0x70, 0x71, 0x5d,
	0xbf, 0xaa, 0xe2, 0xe3, 0xab, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x51, 0x48, 0xfa, 0x76, 0xc0,
	0x0b, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ApiClient is the client API for Api service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ApiClient interface {
	RunBackup(ctx context.Context, in *RunBackupParams, opts ...grpc.CallOption) (*RunBackupResponse, error)
	RunRestore(ctx context.Context, in *RunRestoreParams, opts ...grpc.CallOption) (*RunRestoreResponse, error)
	LastBackupMetadata(ctx context.Context, in *LastBackupMetadataParams, opts ...grpc.CallOption) (*messages.BackupMetadata, error)
	// Stream response
	BackupsMetadata(ctx context.Context, in *BackupsMetadataParams, opts ...grpc.CallOption) (Api_BackupsMetadataClient, error)
	GetClients(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Api_GetClientsClient, error)
	ListStorages(ctx context.Context, in *ListStoragesParams, opts ...grpc.CallOption) (Api_ListStoragesClient, error)
}

type apiClient struct {
	cc *grpc.ClientConn
}

func NewApiClient(cc *grpc.ClientConn) ApiClient {
	return &apiClient{cc}
}

func (c *apiClient) RunBackup(ctx context.Context, in *RunBackupParams, opts ...grpc.CallOption) (*RunBackupResponse, error) {
	out := new(RunBackupResponse)
	err := c.cc.Invoke(ctx, "/api.Api/RunBackup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiClient) RunRestore(ctx context.Context, in *RunRestoreParams, opts ...grpc.CallOption) (*RunRestoreResponse, error) {
	out := new(RunRestoreResponse)
	err := c.cc.Invoke(ctx, "/api.Api/RunRestore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiClient) LastBackupMetadata(ctx context.Context, in *LastBackupMetadataParams, opts ...grpc.CallOption) (*messages.BackupMetadata, error) {
	out := new(messages.BackupMetadata)
	err := c.cc.Invoke(ctx, "/api.Api/LastBackupMetadata", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiClient) BackupsMetadata(ctx context.Context, in *BackupsMetadataParams, opts ...grpc.CallOption) (Api_BackupsMetadataClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Api_serviceDesc.Streams[0], "/api.Api/BackupsMetadata", opts...)
	if err != nil {
		return nil, err
	}
	x := &apiBackupsMetadataClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Api_BackupsMetadataClient interface {
	Recv() (*MetadataFile, error)
	grpc.ClientStream
}

type apiBackupsMetadataClient struct {
	grpc.ClientStream
}

func (x *apiBackupsMetadataClient) Recv() (*MetadataFile, error) {
	m := new(MetadataFile)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *apiClient) GetClients(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Api_GetClientsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Api_serviceDesc.Streams[1], "/api.Api/GetClients", opts...)
	if err != nil {
		return nil, err
	}
	x := &apiGetClientsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Api_GetClientsClient interface {
	Recv() (*Client, error)
	grpc.ClientStream
}

type apiGetClientsClient struct {
	grpc.ClientStream
}

func (x *apiGetClientsClient) Recv() (*Client, error) {
	m := new(Client)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *apiClient) ListStorages(ctx context.Context, in *ListStoragesParams, opts ...grpc.CallOption) (Api_ListStoragesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Api_serviceDesc.Streams[2], "/api.Api/ListStorages", opts...)
	if err != nil {
		return nil, err
	}
	x := &apiListStoragesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Api_ListStoragesClient interface {
	Recv() (*StorageInfo, error)
	grpc.ClientStream
}

type apiListStoragesClient struct {
	grpc.ClientStream
}

func (x *apiListStoragesClient) Recv() (*StorageInfo, error) {
	m := new(StorageInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// ApiServer is the server API for Api service.
type ApiServer interface {
	RunBackup(context.Context, *RunBackupParams) (*RunBackupResponse, error)
	RunRestore(context.Context, *RunRestoreParams) (*RunRestoreResponse, error)
	LastBackupMetadata(context.Context, *LastBackupMetadataParams) (*messages.BackupMetadata, error)
	// Stream response
	BackupsMetadata(*BackupsMetadataParams, Api_BackupsMetadataServer) error
	GetClients(*Empty, Api_GetClientsServer) error
	ListStorages(*ListStoragesParams, Api_ListStoragesServer) error
}

func RegisterApiServer(s *grpc.Server, srv ApiServer) {
	s.RegisterService(&_Api_serviceDesc, srv)
}

func _Api_RunBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunBackupParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiServer).RunBackup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Api/RunBackup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiServer).RunBackup(ctx, req.(*RunBackupParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _Api_RunRestore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunRestoreParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiServer).RunRestore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Api/RunRestore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiServer).RunRestore(ctx, req.(*RunRestoreParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _Api_LastBackupMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LastBackupMetadataParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiServer).LastBackupMetadata(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Api/LastBackupMetadata",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiServer).LastBackupMetadata(ctx, req.(*LastBackupMetadataParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _Api_BackupsMetadata_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(BackupsMetadataParams)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ApiServer).BackupsMetadata(m, &apiBackupsMetadataServer{stream})
}

type Api_BackupsMetadataServer interface {
	Send(*MetadataFile) error
	grpc.ServerStream
}

type apiBackupsMetadataServer struct {
	grpc.ServerStream
}

func (x *apiBackupsMetadataServer) Send(m *MetadataFile) error {
	return x.ServerStream.SendMsg(m)
}

func _Api_GetClients_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ApiServer).GetClients(m, &apiGetClientsServer{stream})
}

type Api_GetClientsServer interface {
	Send(*Client) error
	grpc.ServerStream
}

type apiGetClientsServer struct {
	grpc.ServerStream
}

func (x *apiGetClientsServer) Send(m *Client) error {
	return x.ServerStream.SendMsg(m)
}

func _Api_ListStorages_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListStoragesParams)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ApiServer).ListStorages(m, &apiListStoragesServer{stream})
}

type Api_ListStoragesServer interface {
	Send(*StorageInfo) error
	grpc.ServerStream
}

type apiListStoragesServer struct {
	grpc.ServerStream
}

func (x *apiListStoragesServer) Send(m *StorageInfo) error {
	return x.ServerStream.SendMsg(m)
}

var _Api_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.Api",
	HandlerType: (*ApiServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RunBackup",
			Handler:    _Api_RunBackup_Handler,
		},
		{
			MethodName: "RunRestore",
			Handler:    _Api_RunRestore_Handler,
		},
		{
			MethodName: "LastBackupMetadata",
			Handler:    _Api_LastBackupMetadata_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "BackupsMetadata",
			Handler:       _Api_BackupsMetadata_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetClients",
			Handler:       _Api_GetClients_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListStorages",
			Handler:       _Api_ListStorages_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api/api.proto",
}