proto

type BeginCommitRequest struct {
	BackupSet string `protobuf:"bytes,1,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	// contains filtered or unexported fields
}

type BeginCommitResponse struct {
	Allowed bool `protobuf:"varint,2,opt,name=allowed,proto3" json:"allowed,omitempty"`
	// why the commit was refused, empty when allowed
	Reason string `protobuf:"bytes,3,opt,name=reason,proto3" json:"reason,omitempty"`
	// the store's write policy for this run; absent when the operator never
	// set one, which leaves the agent's key file in charge
	Policy *StorePolicy `protobuf:"bytes,4,opt,name=policy,proto3" json:"policy,omitempty"`
	// the run must read every file again, whatever its change detection
	// says, because the store lost content it could not name a path for
	Rescan bool `protobuf:"varint,5,opt,name=rescan,proto3" json:"rescan,omitempty"`
	// paths whose stored content the store lost: read them again and take
	// no chunk of theirs on trust
	DamagedPaths []string `protobuf:"bytes,6,rep,name=damaged_paths,json=damagedPaths,proto3" json:"damaged_paths,omitempty"`
	// contains filtered or unexported fields
}

type BeginSessionRequest struct {
	BackupSet string `protobuf:"bytes,1,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	// the object a restore session reads; retirement and garbage collection
	// keep it and everything it names while the session lives
	Restore *Ref `protobuf:"bytes,2,opt,name=restore,proto3" json:"restore,omitempty"`
	// contains filtered or unexported fields
}

type BeginSessionResponse struct {

	// sent as the goback-session metadata header on every call of the session
	SessionId string `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// how long the session survives without a call before the server drops
	// what it did not commit
	LeaseSeconds int64 `protobuf:"varint,2,opt,name=lease_seconds,json=leaseSeconds,proto3" json:"lease_seconds,omitempty"`
	// contains filtered or unexported fields
}

type Blob struct {
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	// contains filtered or unexported fields
}

type Chunker int32

type Commit struct {
	Timestamp int64  `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Tree      *Ref   `protobuf:"bytes,2,opt,name=tree,proto3" json:"tree,omitempty"`
	BackupSet string `protobuf:"bytes,3,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	// the commit this one was diffed against, empty for a full run
	Parent  *Ref   `protobuf:"bytes,4,opt,name=parent,proto3" json:"parent,omitempty"`
	AgentId string `protobuf:"bytes,5,opt,name=agent_id,json=agentId,proto3" json:"agent_id,omitempty"`
	// agent wall time in nanoseconds at the start of the walk
	ScanStartNs int64 `protobuf:"varint,6,opt,name=scan_start_ns,json=scanStartNs,proto3" json:"scan_start_ns,omitempty"`
	// a checkpoint written mid-run, superseded by the final commit
	Partial bool `protobuf:"varint,7,opt,name=partial,proto3" json:"partial,omitempty"`
	// the store policy version the agent wrote under, 0 for no policy
	PolicyVersion uint32 `protobuf:"varint,9,opt,name=policy_version,json=policyVersion,proto3" json:"policy_version,omitempty"`
	// the set's id, globally unique; the receiving index assigns it on Put
	// and ignores the client's value
	SetId uint64 `protobuf:"varint,10,opt,name=set_id,json=setId,proto3" json:"set_id,omitempty"`
	// server clock at receipt, nanoseconds since the Unix epoch; ordering,
	// retention and "latest commit" use this, timestamp is display metadata
	ReceivedAtNs int64 `protobuf:"varint,11,opt,name=received_at_ns,json=receivedAtNs,proto3" json:"received_at_ns,omitempty"`
	// the agent's pre hook quiesced the application and no file was torn or
	// unreadable; never set on a checkpoint
	Consistent bool `protobuf:"varint,12,opt,name=consistent,proto3" json:"consistent,omitempty"`
	// labels the agent attached; the store keeps them and never interprets them
	Metadata map[string]string `` /* 144-byte string literal not displayed */
	// the id of the store key names and contents were sealed under, empty
	// when the commit was written plain; absent on a commit written before
	// it was recorded
	KeyId []byte `protobuf:"bytes,14,opt,name=key_id,json=keyId,proto3,oneof" json:"key_id,omitempty"`
	// contains filtered or unexported fields
}

type CommitCount struct {

	// the period's first instant
	StartNs int64 `protobuf:"varint,1,opt,name=start_ns,json=startNs,proto3" json:"start_ns,omitempty"`
	Count   int64 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
	// contains filtered or unexported fields
}

type CommitInfoRequest struct {
	BackupSet string                 `protobuf:"bytes,1,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	NotAfter  *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=notAfter,proto3" json:"notAfter,omitempty"`
	Count     int32                  `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
	// contains filtered or unexported fields
}

type CommitInfoResponse struct {
	Commits []*Commit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	// what the set held at each of commits, in the same order; empty when
	// the store measures nothing
	Sizes []*CommitSize `protobuf:"bytes,2,rep,name=sizes,proto3" json:"sizes,omitempty"`
	// contains filtered or unexported fields
}

type CommitScope struct {
	Commit *Ref `protobuf:"bytes,1,opt,name=commit,proto3" json:"commit,omitempty"`
	// when it was moved to the trash; 0 when it is not there
	DeletedAtNs int64 `protobuf:"varint,2,opt,name=deleted_at_ns,json=deletedAtNs,proto3" json:"deleted_at_ns,omitempty"`
	// contains filtered or unexported fields
}

type CommitSize struct {

	// the size of every file, before deduplication and compression;
	// absent for a commit the store has not measured
	LogicalBytes *int64 `protobuf:"varint,1,opt,name=logical_bytes,json=logicalBytes,proto3,oneof" json:"logical_bytes,omitempty"`
	// how many files there were, absent likewise
	Files *int64 `protobuf:"varint,2,opt,name=files,proto3,oneof" json:"files,omitempty"`
	// contains filtered or unexported fields
}

type Compression int32

type CountCommitsRequest struct {
	BackupSet string `protobuf:"bytes,1,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	Period    Period `protobuf:"varint,2,opt,name=period,proto3,enum=proto.Period" json:"period,omitempty"`
	// the receipt range counted: from_ns inclusive, to_ns exclusive
	FromNs int64 `protobuf:"varint,3,opt,name=from_ns,json=fromNs,proto3" json:"from_ns,omitempty"`
	ToNs   int64 `protobuf:"varint,4,opt,name=to_ns,json=toNs,proto3" json:"to_ns,omitempty"`
	// IANA name the periods fall in; empty for UTC
	TimeZone string `protobuf:"bytes,5,opt,name=time_zone,json=timeZone,proto3" json:"time_zone,omitempty"`
	// count the deleted commits UndeleteCommit can still bring back
	// instead of the live ones
	Deleted bool `protobuf:"varint,6,opt,name=deleted,proto3" json:"deleted,omitempty"`
	// contains filtered or unexported fields
}

type CountCommitsResponse struct {

	// the non-empty periods, oldest first
	Counts []*CommitCount `protobuf:"bytes,1,rep,name=counts,proto3" json:"counts,omitempty"`
	// contains filtered or unexported fields
}

type DeleteCommitRequest struct {
	Ref *Ref `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	// contains filtered or unexported fields
}

type DeleteCommitResponse struct {
	// contains filtered or unexported fields
}

type DeleteSetRequest struct {
	BackupSet string `protobuf:"bytes,1,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	// erase uses a zero window: the commits are tombstoned by the next
	// retirement run
	Erase bool `protobuf:"varint,2,opt,name=erase,proto3" json:"erase,omitempty"`
	// contains filtered or unexported fields
}

type DeleteSetResponse struct {
	// contains filtered or unexported fields
}

type Encryption int32

type EndSessionRequest struct {
	SessionId string `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// contains filtered or unexported fields
}

type EndSessionResponse struct {
	// contains filtered or unexported fields
}

type EscrowedKey struct {
	KeyId    string `protobuf:"bytes,1,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
	Escrowed []byte `protobuf:"bytes,2,opt,name=escrowed,proto3" json:"escrowed,omitempty"`
	// contains filtered or unexported fields
}

type EscrowedKeysRequest struct {
	// contains filtered or unexported fields
}

type EscrowedKeysResponse struct {
	Keys []*EscrowedKey `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
	// contains filtered or unexported fields
}

type File struct {

	// an ordered list of file parts
	Parts []*FilePart `protobuf:"bytes,1,rep,name=parts,proto3" json:"parts,omitempty"`
	// an ordered list of references to other file objects, which together
	// hold the file's parts
	Splits []*Ref `protobuf:"bytes,2,rep,name=splits,proto3" json:"splits,omitempty"`
	// the chunker that cut the parts
	Chunker Chunker `protobuf:"varint,3,opt,name=chunker,proto3,enum=proto.Chunker" json:"chunker,omitempty"`
	// the whole content of a small file, stored without a blob; sealed
	// under the store key when the store is encrypted
	Inline []byte `protobuf:"bytes,4,opt,name=inline,proto3" json:"inline,omitempty"`
	// how inline is stored
	InlineEncryption Encryption `` /* 132-byte string literal not displayed */
	// the content bytes under each split, in order, so a read finds the
	// split holding an offset without loading the others; absent in a file
	// written before splits were measured
	SplitLengths []uint64 `protobuf:"varint,7,rep,packed,name=split_lengths,json=splitLengths,proto3" json:"split_lengths,omitempty"`
	// how many levels of splits lie below this one: 1 when the splits hold
	// parts, more when they are split themselves; 0 without split_lengths
	SplitDepth uint32 `protobuf:"varint,8,opt,name=split_depth,json=splitDepth,proto3" json:"split_depth,omitempty"`
	// contains filtered or unexported fields
}

type FileInfo struct {
	Name  []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Mode  uint32 `protobuf:"varint,2,opt,name=mode,proto3" json:"mode,omitempty"`
	User  []byte `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	Group []byte `protobuf:"bytes,4,opt,name=group,proto3" json:"group,omitempty"`
	Size  int64  `protobuf:"varint,6,opt,name=size,proto3" json:"size,omitempty"`
	// modification time in nanoseconds since the Unix epoch
	MtimeNs int64    `protobuf:"varint,8,opt,name=mtime_ns,json=mtimeNs,proto3" json:"mtime_ns,omitempty"`
	Type    NodeType `protobuf:"varint,9,opt,name=type,proto3,enum=proto.NodeType" json:"type,omitempty"`
	// the target of a symlink, empty for every other type
	LinkTarget []byte `protobuf:"bytes,10,opt,name=link_target,json=linkTarget,proto3" json:"link_target,omitempty"`
	// contains filtered or unexported fields
}

type FileInfoRequest struct {
	BackupSet string                 `protobuf:"bytes,1,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	Path      string                 `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	NotAfter  *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=notAfter,proto3" json:"notAfter,omitempty"`
	Count     int32                  `protobuf:"varint,4,opt,name=count,proto3" json:"count,omitempty"`
	// contains filtered or unexported fields
}

type FileInfoResponse struct {
	Files []*TreeNode `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"`
	// contains filtered or unexported fields
}

type FilePart struct {
	Offset uint64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"`
	Length uint64 `protobuf:"varint,2,opt,name=length,proto3" json:"length,omitempty"`
	Ref    *Ref   `protobuf:"bytes,3,opt,name=ref,proto3" json:"ref,omitempty"`
	// contains filtered or unexported fields
}

type GetPresenceRequest struct {

	// the set whose filter is wanted when the scope is the set
	BackupSet string `protobuf:"bytes,1,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	// contains filtered or unexported fields
}

type GetPresenceResponse struct {
	Index  uint32          `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Filter *PresenceFilter `protobuf:"bytes,2,opt,name=filter,proto3" json:"filter,omitempty"`
	// contains filtered or unexported fields
}

type GetRequest struct {
	Ref *Ref `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	// contains filtered or unexported fields
}

type GetResponse struct {

	// a store that can address its bytes answers where they are, and one
	// that cannot serves them
	//
	// Types that are valid to be assigned to Body:
	//
	//	*GetResponse_Object
	//	*GetResponse_Location
	Body isGetResponse_Body `protobuf_oneof:"body"`
	// contains filtered or unexported fields
}

type GetResponse_Location struct {
	Location *Location `protobuf:"bytes,2,opt,name=location,proto3,oneof"`
}

type GetResponse_Object struct {
	Object *Object `protobuf:"bytes,1,opt,name=object,proto3,oneof"`
}

type GetTreeRequest struct {
	Ref *Ref `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	// how many directory levels below ref to include; 0 means only ref
	MaxDepth uint32 `protobuf:"varint,2,opt,name=max_depth,json=maxDepth,proto3" json:"max_depth,omitempty"`
	// contains filtered or unexported fields
}

type GetTreeResponse struct {
	Ref    *Ref          `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	Object *Object       `protobuf:"bytes,2,opt,name=object,proto3" json:"object,omitempty"`
	Runs   []*LocatedRun `protobuf:"bytes,3,rep,name=runs,proto3" json:"runs,omitempty"`
	// contains filtered or unexported fields
}

type LatestCommitRequest struct {
	BackupSet string `protobuf:"bytes,1,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	// contains filtered or unexported fields
}

type LatestCommitResponse struct {

	// empty when the set has no commit
	Ref *Ref `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	// contains filtered or unexported fields
}

type ListPinsRequest struct {
	// contains filtered or unexported fields
}

type ListPinsResponse struct {
	Pins []*PinInfo `protobuf:"bytes,1,rep,name=pins,proto3" json:"pins,omitempty"`
	// contains filtered or unexported fields
}

type ListTrashRequest struct {
	BackupSet string `protobuf:"bytes,1,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	// only commits deleted before this instant; 0 for the newest
	BeforeNs int64 `protobuf:"varint,2,opt,name=before_ns,json=beforeNs,proto3" json:"before_ns,omitempty"`
	// at most this many, and then the rest deleted at the last one's
	// instant; 0 for all
	Limit int32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	// contains filtered or unexported fields
}

type ListTrashResponse struct {

	// newest deleted first
	Commits []*TrashedCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	// contains filtered or unexported fields
}

type LocatedRecord struct {
	Index  uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Offset int64  `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	Length int64  `protobuf:"varint,3,opt,name=length,proto3" json:"length,omitempty"`
	File   uint32 `protobuf:"varint,4,opt,name=file,proto3" json:"file,omitempty"`
	// contains filtered or unexported fields
}

type LocatedRun struct {
	Location *Location        `protobuf:"bytes,1,opt,name=location,proto3" json:"location,omitempty"`
	Records  []*LocatedRecord `protobuf:"bytes,2,rep,name=records,proto3" json:"records,omitempty"`
	// contains filtered or unexported fields
}

type Location struct {
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	// header must be sent with the request, verbatim
	Header  map[string]string      `` /* 139-byte string literal not displayed */
	Length  int64                  `protobuf:"varint,3,opt,name=length,proto3" json:"length,omitempty"`
	Expires *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=expires,proto3" json:"expires,omitempty"`
	// at_rest_key opens the record when it is sealed at rest: a Tink
	// keyset for its archive alone
	AtRestKey []byte `protobuf:"bytes,5,opt,name=at_rest_key,json=atRestKey,proto3" json:"at_rest_key,omitempty"`
	// contains filtered or unexported fields
}

type NodeType int32

type Object struct {

	// Types that are valid to be assigned to Object:
	//
	//	*Object_Commit
	//	*Object_Tree
	//	*Object_File
	//	*Object_Blob
	//	*Object_Sealed
	//	*Object_Pin
	//	*Object_Policy
	Object isObject_Object `protobuf_oneof:"object"`
	// the store key under which a tree's names or a file's part keys are
	// encrypted; transport only, never part of the hashed payload
	KeyId []byte `protobuf:"bytes,10,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
	// contains filtered or unexported fields
}

type ObjectHeader struct {
	Ref          *Ref                   `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	Predecessor  *Ref                   `protobuf:"bytes,2,opt,name=predecessor,proto3" json:"predecessor,omitempty"`
	Size         uint64                 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	Compression  Compression            `protobuf:"varint,4,opt,name=compression,proto3,enum=proto.Compression" json:"compression,omitempty"`
	Timestamp    *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Type         ObjectType             `protobuf:"varint,6,opt,name=type,proto3,enum=proto.ObjectType" json:"type,omitempty"`
	TombstoneFor *Ref                   `protobuf:"bytes,7,opt,name=tombstone_for,json=tombstoneFor,proto3" json:"tombstone_for,omitempty"`
	Encryption   Encryption             `protobuf:"varint,8,opt,name=encryption,proto3,enum=proto.Encryption" json:"encryption,omitempty"`
	// identifies the store key under which the object's sealed parts were
	// encrypted; empty for plaintext and convergent objects
	KeyId []byte `protobuf:"bytes,9,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
	// SHA-256 of the stored bytes, so a copy can be checked without a key
	StoredHash []byte `protobuf:"bytes,10,opt,name=stored_hash,json=storedHash,proto3" json:"stored_hash,omitempty"`
	// set on a tombstone written for an erasure: garbage collection rewrites
	// the archives holding the target's objects as soon as its rules allow
	Erase bool `protobuf:"varint,11,opt,name=erase,proto3" json:"erase,omitempty"`
	// identifies the server key under which the stored bytes were sealed at
	// rest; empty when they are stored as the agent sent them
	AtRestKeyId []byte `protobuf:"bytes,12,opt,name=at_rest_key_id,json=atRestKeyId,proto3" json:"at_rest_key_id,omitempty"`
	// contains filtered or unexported fields
}

type ObjectType int32

type Object_Blob struct {
	Blob *Blob `protobuf:"bytes,4,opt,name=blob,proto3,oneof"`
}

type Object_Commit struct {
	Commit *Commit `protobuf:"bytes,1,opt,name=commit,proto3,oneof"`
}

type Object_File struct {
	File *File `protobuf:"bytes,3,opt,name=file,proto3,oneof"`
}

type Object_Pin struct {
	Pin *Pin `protobuf:"bytes,6,opt,name=pin,proto3,oneof"`
}

type Object_Policy struct {
	Policy *Policy `protobuf:"bytes,7,opt,name=policy,proto3,oneof"`
}

type Object_Sealed struct {
	Sealed *Sealed `protobuf:"bytes,5,opt,name=sealed,proto3,oneof"`
}

type Object_Tree struct {
	Tree *Tree `protobuf:"bytes,2,opt,name=tree,proto3,oneof"`
}

type Period int32

type Pin struct {
	Target *Ref `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	// server clock at receipt, nanoseconds since the Unix epoch; makes every
	// pin unique
	ReceivedAtNs int64 `protobuf:"varint,3,opt,name=received_at_ns,json=receivedAtNs,proto3" json:"received_at_ns,omitempty"`
	// labels the agent attached; the store keeps them and never interprets them
	Metadata map[string]string `` /* 143-byte string literal not displayed */
	// contains filtered or unexported fields
}

type PinInfo struct {
	Ref          *Ref  `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	Target       *Ref  `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	ReceivedAtNs int64 `protobuf:"varint,3,opt,name=received_at_ns,json=receivedAtNs,proto3" json:"received_at_ns,omitempty"`
	// the labels the pin carries; the store keeps them and never
	// interprets them
	Metadata map[string]string `` /* 143-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Policy struct {

	// increases with every change the store makes
	Sequence    uint64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
	WrittenAtNs int64  `protobuf:"varint,2,opt,name=written_at_ns,json=writtenAtNs,proto3" json:"written_at_ns,omitempty"`
	// Types that are valid to be assigned to Scope:
	//
	//	*Policy_Store
	//	*Policy_Set
	//	*Policy_Commit
	Scope isPolicy_Scope `protobuf_oneof:"scope"`
	// contains filtered or unexported fields
}

type Policy_Commit struct {
	Commit *CommitScope `protobuf:"bytes,5,opt,name=commit,proto3,oneof"`
}

type Policy_Set struct {
	Set *SetScope `protobuf:"bytes,4,opt,name=set,proto3,oneof"`
}

type Policy_Store struct {
	Store *StoreScope `protobuf:"bytes,3,opt,name=store,proto3,oneof"`
}

type PresenceFilter struct {

	// format version, currently 1
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// refs added to the filter
	Entries uint64 `protobuf:"varint,2,opt,name=entries,proto3" json:"entries,omitempty"`
	// size of the bit array in bits
	Bits uint64 `protobuf:"varint,3,opt,name=bits,proto3" json:"bits,omitempty"`
	// bit positions probed per ref
	Hashes uint32 `protobuf:"varint,4,opt,name=hashes,proto3" json:"hashes,omitempty"`
	// the bit array, bits / 8 bytes; streamed in pieces over GetPresence
	Data      []byte `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
	Commit    *Ref   `protobuf:"bytes,6,opt,name=commit,proto3" json:"commit,omitempty"`
	BackupSet string `protobuf:"bytes,7,opt,name=backup_set,json=backupSet,proto3" json:"backup_set,omitempty"`
	// contains filtered or unexported fields
}