// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.30.2
// source: praefect.proto

package gitalypb

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// MarkUnverifiedRequest specifies the replicas which to mark unverified.
type MarkUnverifiedRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// selector specifies the replicas which to mark unverified.
	//
	// Types that are valid to be assigned to Selector:
	//
	//	*MarkUnverifiedRequest_RepositoryId
	//	*MarkUnverifiedRequest_VirtualStorage
	//	*MarkUnverifiedRequest_Storage_
	Selector      isMarkUnverifiedRequest_Selector `protobuf_oneof:"selector"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MarkUnverifiedRequest) Reset() {
	*x = MarkUnverifiedRequest{}
	mi := &file_praefect_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MarkUnverifiedRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MarkUnverifiedRequest) ProtoMessage() {}

func (x *MarkUnverifiedRequest) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MarkUnverifiedRequest.ProtoReflect.Descriptor instead.
func (*MarkUnverifiedRequest) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{0}
}

func (x *MarkUnverifiedRequest) GetSelector() isMarkUnverifiedRequest_Selector {
	if x != nil {
		return x.Selector
	}
	return nil
}

func (x *MarkUnverifiedRequest) GetRepositoryId() int64 {
	if x != nil {
		if x, ok := x.Selector.(*MarkUnverifiedRequest_RepositoryId); ok {
			return x.RepositoryId
		}
	}
	return 0
}

func (x *MarkUnverifiedRequest) GetVirtualStorage() string {
	if x != nil {
		if x, ok := x.Selector.(*MarkUnverifiedRequest_VirtualStorage); ok {
			return x.VirtualStorage
		}
	}
	return ""
}

func (x *MarkUnverifiedRequest) GetStorage() *MarkUnverifiedRequest_Storage {
	if x != nil {
		if x, ok := x.Selector.(*MarkUnverifiedRequest_Storage_); ok {
			return x.Storage
		}
	}
	return nil
}

type isMarkUnverifiedRequest_Selector interface {
	isMarkUnverifiedRequest_Selector()
}

type MarkUnverifiedRequest_RepositoryId struct {
	// repository_id is the id of a repository to mark all replicas for unverified.
	RepositoryId int64 `protobuf:"varint,1,opt,name=repository_id,json=repositoryId,proto3,oneof"`
}

type MarkUnverifiedRequest_VirtualStorage struct {
	// virtual_storage is the name of virtual storage which will have all of its replicas
	// marked unverified.
	VirtualStorage string `protobuf:"bytes,2,opt,name=virtual_storage,json=virtualStorage,proto3,oneof"`
}

type MarkUnverifiedRequest_Storage_ struct {
	// storage specifies a single storage. The replicas on the storage marked unverified.
	Storage *MarkUnverifiedRequest_Storage `protobuf:"bytes,3,opt,name=storage,proto3,oneof"`
}

func (*MarkUnverifiedRequest_RepositoryId) isMarkUnverifiedRequest_Selector() {}

func (*MarkUnverifiedRequest_VirtualStorage) isMarkUnverifiedRequest_Selector() {}

func (*MarkUnverifiedRequest_Storage_) isMarkUnverifiedRequest_Selector() {}

// MarkUnverifiedResponse returns the number of replicas marked unverified.
type MarkUnverifiedResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// replicas_marked indicates the number of replicas that were marked unverified.
	ReplicasMarked int64 `protobuf:"varint,1,opt,name=replicas_marked,json=replicasMarked,proto3" json:"replicas_marked,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *MarkUnverifiedResponse) Reset() {
	*x = MarkUnverifiedResponse{}
	mi := &file_praefect_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MarkUnverifiedResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MarkUnverifiedResponse) ProtoMessage() {}

func (x *MarkUnverifiedResponse) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MarkUnverifiedResponse.ProtoReflect.Descriptor instead.
func (*MarkUnverifiedResponse) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{1}
}

func (x *MarkUnverifiedResponse) GetReplicasMarked() int64 {
	if x != nil {
		return x.ReplicasMarked
	}
	return 0
}

// GetRepositoryMetadataRequest specifies the repository to retrieve metadata for.
type GetRepositoryMetadataRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Query:
	//
	//	*GetRepositoryMetadataRequest_RepositoryId
	//	*GetRepositoryMetadataRequest_Path_
	Query         isGetRepositoryMetadataRequest_Query `protobuf_oneof:"query"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetRepositoryMetadataRequest) Reset() {
	*x = GetRepositoryMetadataRequest{}
	mi := &file_praefect_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetRepositoryMetadataRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetRepositoryMetadataRequest) ProtoMessage() {}

func (x *GetRepositoryMetadataRequest) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetRepositoryMetadataRequest.ProtoReflect.Descriptor instead.
func (*GetRepositoryMetadataRequest) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{2}
}

func (x *GetRepositoryMetadataRequest) GetQuery() isGetRepositoryMetadataRequest_Query {
	if x != nil {
		return x.Query
	}
	return nil
}

func (x *GetRepositoryMetadataRequest) GetRepositoryId() int64 {
	if x != nil {
		if x, ok := x.Query.(*GetRepositoryMetadataRequest_RepositoryId); ok {
			return x.RepositoryId
		}
	}
	return 0
}

func (x *GetRepositoryMetadataRequest) GetPath() *GetRepositoryMetadataRequest_Path {
	if x != nil {
		if x, ok := x.Query.(*GetRepositoryMetadataRequest_Path_); ok {
			return x.Path
		}
	}
	return nil
}

type isGetRepositoryMetadataRequest_Query interface {
	isGetRepositoryMetadataRequest_Query()
}

type GetRepositoryMetadataRequest_RepositoryId struct {
	// repository_id is the ID of the repository to retrieve information for.
	RepositoryId int64 `protobuf:"varint,1,opt,name=repository_id,json=repositoryId,proto3,oneof"`
}

type GetRepositoryMetadataRequest_Path_ struct {
	// path is the external path of the repository to retrieve information for.
	Path *GetRepositoryMetadataRequest_Path `protobuf:"bytes,2,opt,name=path,proto3,oneof"`
}

func (*GetRepositoryMetadataRequest_RepositoryId) isGetRepositoryMetadataRequest_Query() {}

func (*GetRepositoryMetadataRequest_Path_) isGetRepositoryMetadataRequest_Query() {}

// GetRepositoryMetadataResponse contains the repository's cluster metadata.
type GetRepositoryMetadataResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository_id is the internal ID of the repository.
	RepositoryId int64 `protobuf:"varint,1,opt,name=repository_id,json=repositoryId,proto3" json:"repository_id,omitempty"`
	// virtual_storage is the virtual storage in which the repository is located.
	VirtualStorage string `protobuf:"bytes,2,opt,name=virtual_storage,json=virtualStorage,proto3" json:"virtual_storage,omitempty"`
	// relative_path is the relative path of the repository in the virtual storage.
	RelativePath string `protobuf:"bytes,3,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
	// replica_path is the path on the disk where the replicas are stored.
	ReplicaPath string `protobuf:"bytes,4,opt,name=replica_path,json=replicaPath,proto3" json:"replica_path,omitempty"`
	// primary is the current primary of the repository.
	Primary string `protobuf:"bytes,5,opt,name=primary,proto3" json:"primary,omitempty"`
	// generation is the repository's current generation.
	Generation int64 `protobuf:"varint,6,opt,name=generation,proto3" json:"generation,omitempty"`
	// replicas are the existing and supposed to exist replicas of this repository.
	Replicas      []*GetRepositoryMetadataResponse_Replica `protobuf:"bytes,7,rep,name=replicas,proto3" json:"replicas,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetRepositoryMetadataResponse) Reset() {
	*x = GetRepositoryMetadataResponse{}
	mi := &file_praefect_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetRepositoryMetadataResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetRepositoryMetadataResponse) ProtoMessage() {}

func (x *GetRepositoryMetadataResponse) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetRepositoryMetadataResponse.ProtoReflect.Descriptor instead.
func (*GetRepositoryMetadataResponse) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{3}
}

func (x *GetRepositoryMetadataResponse) GetRepositoryId() int64 {
	if x != nil {
		return x.RepositoryId
	}
	return 0
}

func (x *GetRepositoryMetadataResponse) GetVirtualStorage() string {
	if x != nil {
		return x.VirtualStorage
	}
	return ""
}

func (x *GetRepositoryMetadataResponse) GetRelativePath() string {
	if x != nil {
		return x.RelativePath
	}
	return ""
}

func (x *GetRepositoryMetadataResponse) GetReplicaPath() string {
	if x != nil {
		return x.ReplicaPath
	}
	return ""
}

func (x *GetRepositoryMetadataResponse) GetPrimary() string {
	if x != nil {
		return x.Primary
	}
	return ""
}

func (x *GetRepositoryMetadataResponse) GetGeneration() int64 {
	if x != nil {
		return x.Generation
	}
	return 0
}

func (x *GetRepositoryMetadataResponse) GetReplicas() []*GetRepositoryMetadataResponse_Replica {
	if x != nil {
		return x.Replicas
	}
	return nil
}

// SetReplicationFactorRequest sets the desired replication factor for a repository.
type SetReplicationFactorRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// virtual_storage is the virtual storage the repository is located in
	VirtualStorage string `protobuf:"bytes,1,opt,name=virtual_storage,json=virtualStorage,proto3" json:"virtual_storage,omitempty"`
	// relative_path is the relative path of the repository
	RelativePath string `protobuf:"bytes,2,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
	// replication_factor is the desired replication factor. Replication must be equal or greater than 1.
	ReplicationFactor int32 `protobuf:"varint,3,opt,name=replication_factor,json=replicationFactor,proto3" json:"replication_factor,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *SetReplicationFactorRequest) Reset() {
	*x = SetReplicationFactorRequest{}
	mi := &file_praefect_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SetReplicationFactorRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SetReplicationFactorRequest) ProtoMessage() {}

func (x *SetReplicationFactorRequest) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SetReplicationFactorRequest.ProtoReflect.Descriptor instead.
func (*SetReplicationFactorRequest) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{4}
}

func (x *SetReplicationFactorRequest) GetVirtualStorage() string {
	if x != nil {
		return x.VirtualStorage
	}
	return ""
}

func (x *SetReplicationFactorRequest) GetRelativePath() string {
	if x != nil {
		return x.RelativePath
	}
	return ""
}

func (x *SetReplicationFactorRequest) GetReplicationFactor() int32 {
	if x != nil {
		return x.ReplicationFactor
	}
	return 0
}

// SetReplicationFactorResponse returns the assigned hosts after setting the desired replication factor.
type SetReplicationFactorResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// storages are the storages assigned to host the repository.
	Storages      []string `protobuf:"bytes,1,rep,name=storages,proto3" json:"storages,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SetReplicationFactorResponse) Reset() {
	*x = SetReplicationFactorResponse{}
	mi := &file_praefect_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SetReplicationFactorResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SetReplicationFactorResponse) ProtoMessage() {}

func (x *SetReplicationFactorResponse) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SetReplicationFactorResponse.ProtoReflect.Descriptor instead.
func (*SetReplicationFactorResponse) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{5}
}

func (x *SetReplicationFactorResponse) GetStorages() []string {
	if x != nil {
		return x.Storages
	}
	return nil
}

// SetAuthoritativeStorageRequest ...
type SetAuthoritativeStorageRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// virtual_storage ...
	VirtualStorage string `protobuf:"bytes,1,opt,name=virtual_storage,json=virtualStorage,proto3" json:"virtual_storage,omitempty"`
	// relative_path ...
	RelativePath string `protobuf:"bytes,2,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
	// authoritative_storage ...
	AuthoritativeStorage string `protobuf:"bytes,3,opt,name=authoritative_storage,json=authoritativeStorage,proto3" json:"authoritative_storage,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

func (x *SetAuthoritativeStorageRequest) Reset() {
	*x = SetAuthoritativeStorageRequest{}
	mi := &file_praefect_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SetAuthoritativeStorageRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SetAuthoritativeStorageRequest) ProtoMessage() {}

func (x *SetAuthoritativeStorageRequest) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SetAuthoritativeStorageRequest.ProtoReflect.Descriptor instead.
func (*SetAuthoritativeStorageRequest) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{6}
}

func (x *SetAuthoritativeStorageRequest) GetVirtualStorage() string {
	if x != nil {
		return x.VirtualStorage
	}
	return ""
}

func (x *SetAuthoritativeStorageRequest) GetRelativePath() string {
	if x != nil {
		return x.RelativePath
	}
	return ""
}

func (x *SetAuthoritativeStorageRequest) GetAuthoritativeStorage() string {
	if x != nil {
		return x.AuthoritativeStorage
	}
	return ""
}

// SetAuthoritativeStorageResponse ...
type SetAuthoritativeStorageResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SetAuthoritativeStorageResponse) Reset() {
	*x = SetAuthoritativeStorageResponse{}
	mi := &file_praefect_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SetAuthoritativeStorageResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SetAuthoritativeStorageResponse) ProtoMessage() {}

func (x *SetAuthoritativeStorageResponse) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SetAuthoritativeStorageResponse.ProtoReflect.Descriptor instead.
func (*SetAuthoritativeStorageResponse) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{7}
}

// DatalossRequest is the request for data loss information
type DatalossRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// virtual_storage is the virtual storage to get dataloss information for.
	VirtualStorage string `protobuf:"bytes,1,opt,name=virtual_storage,json=virtualStorage,proto3" json:"virtual_storage,omitempty"`
	// include_partially_replicated indicates whether to include repositories which are available but
	// are unavailable on some assigned storages.
	IncludePartiallyReplicated bool `protobuf:"varint,2,opt,name=include_partially_replicated,json=includePartiallyReplicated,proto3" json:"include_partially_replicated,omitempty"`
	unknownFields              protoimpl.UnknownFields
	sizeCache                  protoimpl.SizeCache
}

func (x *DatalossRequest) Reset() {
	*x = DatalossRequest{}
	mi := &file_praefect_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DatalossRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DatalossRequest) ProtoMessage() {}

func (x *DatalossRequest) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DatalossRequest.ProtoReflect.Descriptor instead.
func (*DatalossRequest) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{8}
}

func (x *DatalossRequest) GetVirtualStorage() string {
	if x != nil {
		return x.VirtualStorage
	}
	return ""
}

func (x *DatalossRequest) GetIncludePartiallyReplicated() bool {
	if x != nil {
		return x.IncludePartiallyReplicated
	}
	return false
}

// DatalossResponse contains information about a repository that may be behind
// the primary.
type DatalossResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repositories with data loss
	Repositories  []*DatalossResponse_Repository `protobuf:"bytes,2,rep,name=repositories,proto3" json:"repositories,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DatalossResponse) Reset() {
	*x = DatalossResponse{}
	mi := &file_praefect_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DatalossResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DatalossResponse) ProtoMessage() {}

func (x *DatalossResponse) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DatalossResponse.ProtoReflect.Descriptor instead.
func (*DatalossResponse) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{9}
}

func (x *DatalossResponse) GetRepositories() []*DatalossResponse_Repository {
	if x != nil {
		return x.Repositories
	}
	return nil
}

// RepositoryReplicasRequest ...
type RepositoryReplicasRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository ...
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RepositoryReplicasRequest) Reset() {
	*x = RepositoryReplicasRequest{}
	mi := &file_praefect_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RepositoryReplicasRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RepositoryReplicasRequest) ProtoMessage() {}

func (x *RepositoryReplicasRequest) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RepositoryReplicasRequest.ProtoReflect.Descriptor instead.
func (*RepositoryReplicasRequest) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{10}
}

func (x *RepositoryReplicasRequest) GetRepository() *Repository {
	if x != nil {
		return x.Repository
	}
	return nil
}

// RepositoryReplicasResponse ...
type RepositoryReplicasResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// primary ...
	Primary *RepositoryReplicasResponse_RepositoryDetails `protobuf:"bytes,1,opt,name=primary,proto3" json:"primary,omitempty"`
	// replicas ...
	Replicas      []*RepositoryReplicasResponse_RepositoryDetails `protobuf:"bytes,2,rep,name=replicas,proto3" json:"replicas,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RepositoryReplicasResponse) Reset() {
	*x = RepositoryReplicasResponse{}
	mi := &file_praefect_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RepositoryReplicasResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RepositoryReplicasResponse) ProtoMessage() {}

func (x *RepositoryReplicasResponse) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RepositoryReplicasResponse.ProtoReflect.Descriptor instead.
func (*RepositoryReplicasResponse) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{11}
}

func (x *RepositoryReplicasResponse) GetPrimary() *RepositoryReplicasResponse_RepositoryDetails {
	if x != nil {
		return x.Primary
	}
	return nil
}

func (x *RepositoryReplicasResponse) GetReplicas() []*RepositoryReplicasResponse_RepositoryDetails {
	if x != nil {
		return x.Replicas
	}
	return nil
}

// Storage identifies a single storage in a virtual storage.
type MarkUnverifiedRequest_Storage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// virtual_storage is the virtual storage the storage is part of.
	VirtualStorage string `protobuf:"bytes,1,opt,name=virtual_storage,json=virtualStorage,proto3" json:"virtual_storage,omitempty"`
	// storage is the name of the storage.
	Storage       string `protobuf:"bytes,2,opt,name=storage,proto3" json:"storage,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MarkUnverifiedRequest_Storage) Reset() {
	*x = MarkUnverifiedRequest_Storage{}
	mi := &file_praefect_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MarkUnverifiedRequest_Storage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MarkUnverifiedRequest_Storage) ProtoMessage() {}

func (x *MarkUnverifiedRequest_Storage) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MarkUnverifiedRequest_Storage.ProtoReflect.Descriptor instead.
func (*MarkUnverifiedRequest_Storage) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{0, 0}
}

func (x *MarkUnverifiedRequest_Storage) GetVirtualStorage() string {
	if x != nil {
		return x.VirtualStorage
	}
	return ""
}

func (x *MarkUnverifiedRequest_Storage) GetStorage() string {
	if x != nil {
		return x.Storage
	}
	return ""
}

// Path ...
type GetRepositoryMetadataRequest_Path struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// virtual_storage is the virtual storage where the repository is.
	VirtualStorage string `protobuf:"bytes,1,opt,name=virtual_storage,json=virtualStorage,proto3" json:"virtual_storage,omitempty"`
	// relative_path is the relative path of the repository in the virtual storage.
	RelativePath  string `protobuf:"bytes,2,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetRepositoryMetadataRequest_Path) Reset() {
	*x = GetRepositoryMetadataRequest_Path{}
	mi := &file_praefect_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetRepositoryMetadataRequest_Path) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetRepositoryMetadataRequest_Path) ProtoMessage() {}

func (x *GetRepositoryMetadataRequest_Path) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetRepositoryMetadataRequest_Path.ProtoReflect.Descriptor instead.
func (*GetRepositoryMetadataRequest_Path) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{2, 0}
}

func (x *GetRepositoryMetadataRequest_Path) GetVirtualStorage() string {
	if x != nil {
		return x.VirtualStorage
	}
	return ""
}

func (x *GetRepositoryMetadataRequest_Path) GetRelativePath() string {
	if x != nil {
		return x.RelativePath
	}
	return ""
}

// Replica ...
type GetRepositoryMetadataResponse_Replica struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// storage is the name of the replica's storage.
	Storage string `protobuf:"bytes,1,opt,name=storage,proto3" json:"storage,omitempty"`
	// assigned indicates whether the replica is on an assigned storage.
	Assigned bool `protobuf:"varint,2,opt,name=assigned,proto3" json:"assigned,omitempty"`
	// generation is the replicas confirmed generation. Generation is -1 if the replica
	// does not yet exist.
	Generation int64 `protobuf:"varint,4,opt,name=generation,proto3" json:"generation,omitempty"`
	// healthy indicates whether the replica is on a healthy storage.
	Healthy bool `protobuf:"varint,5,opt,name=healthy,proto3" json:"healthy,omitempty"`
	// valid_primary indicates whether the replica is considered a valid primary.
	ValidPrimary bool `protobuf:"varint,6,opt,name=valid_primary,json=validPrimary,proto3" json:"valid_primary,omitempty"`
	// verified_at is the last successful verification time of the replica.
	VerifiedAt    *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=verified_at,json=verifiedAt,proto3" json:"verified_at,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetRepositoryMetadataResponse_Replica) Reset() {
	*x = GetRepositoryMetadataResponse_Replica{}
	mi := &file_praefect_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetRepositoryMetadataResponse_Replica) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetRepositoryMetadataResponse_Replica) ProtoMessage() {}

func (x *GetRepositoryMetadataResponse_Replica) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetRepositoryMetadataResponse_Replica.ProtoReflect.Descriptor instead.
func (*GetRepositoryMetadataResponse_Replica) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{3, 0}
}

func (x *GetRepositoryMetadataResponse_Replica) GetStorage() string {
	if x != nil {
		return x.Storage
	}
	return ""
}

func (x *GetRepositoryMetadataResponse_Replica) GetAssigned() bool {
	if x != nil {
		return x.Assigned
	}
	return false
}

func (x *GetRepositoryMetadataResponse_Replica) GetGeneration() int64 {
	if x != nil {
		return x.Generation
	}
	return 0
}

func (x *GetRepositoryMetadataResponse_Replica) GetHealthy() bool {
	if x != nil {
		return x.Healthy
	}
	return false
}

func (x *GetRepositoryMetadataResponse_Replica) GetValidPrimary() bool {
	if x != nil {
		return x.ValidPrimary
	}
	return false
}

func (x *GetRepositoryMetadataResponse_Replica) GetVerifiedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.VerifiedAt
	}
	return nil
}

// Repository is the status of a repository
type DatalossResponse_Repository struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// relative_path of the repository with outdated replicas
	RelativePath string `protobuf:"bytes,1,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
	// storages on which the repository is outdated
	Storages []*DatalossResponse_Repository_Storage `protobuf:"bytes,2,rep,name=storages,proto3" json:"storages,omitempty"`
	// unavailable indicates whether the repository is in unavailable.
	Unavailable bool `protobuf:"varint,3,opt,name=unavailable,proto3" json:"unavailable,omitempty"`
	// primary is the current primary storage of the repository.
	Primary       string `protobuf:"bytes,4,opt,name=primary,proto3" json:"primary,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DatalossResponse_Repository) Reset() {
	*x = DatalossResponse_Repository{}
	mi := &file_praefect_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DatalossResponse_Repository) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DatalossResponse_Repository) ProtoMessage() {}

func (x *DatalossResponse_Repository) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DatalossResponse_Repository.ProtoReflect.Descriptor instead.
func (*DatalossResponse_Repository) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{9, 0}
}

func (x *DatalossResponse_Repository) GetRelativePath() string {
	if x != nil {
		return x.RelativePath
	}
	return ""
}

func (x *DatalossResponse_Repository) GetStorages() []*DatalossResponse_Repository_Storage {
	if x != nil {
		return x.Storages
	}
	return nil
}

func (x *DatalossResponse_Repository) GetUnavailable() bool {
	if x != nil {
		return x.Unavailable
	}
	return false
}

func (x *DatalossResponse_Repository) GetPrimary() string {
	if x != nil {
		return x.Primary
	}
	return ""
}

// Storage ...
type DatalossResponse_Repository_Storage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// name of the storage
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// behind_by indicates how many generations this storage is behind.
	BehindBy int64 `protobuf:"varint,2,opt,name=behind_by,json=behindBy,proto3" json:"behind_by,omitempty"`
	// assigned indicates whether the storage is assigned to host the repository.
	Assigned bool `protobuf:"varint,3,opt,name=assigned,proto3" json:"assigned,omitempty"`
	// healthy indicates whether the storage is considered healthy by the consensus of Praefect nodes.
	Healthy bool `protobuf:"varint,4,opt,name=healthy,proto3" json:"healthy,omitempty"`
	// valid_primary indicates whether the storage is ready to act as the primary if necessary.
	ValidPrimary  bool `protobuf:"varint,5,opt,name=valid_primary,json=validPrimary,proto3" json:"valid_primary,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DatalossResponse_Repository_Storage) Reset() {
	*x = DatalossResponse_Repository_Storage{}
	mi := &file_praefect_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DatalossResponse_Repository_Storage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DatalossResponse_Repository_Storage) ProtoMessage() {}

func (x *DatalossResponse_Repository_Storage) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DatalossResponse_Repository_Storage.ProtoReflect.Descriptor instead.
func (*DatalossResponse_Repository_Storage) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{9, 0, 0}
}

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

func (x *DatalossResponse_Repository_Storage) GetBehindBy() int64 {
	if x != nil {
		return x.BehindBy
	}
	return 0
}

func (x *DatalossResponse_Repository_Storage) GetAssigned() bool {
	if x != nil {
		return x.Assigned
	}
	return false
}

func (x *DatalossResponse_Repository_Storage) GetHealthy() bool {
	if x != nil {
		return x.Healthy
	}
	return false
}

func (x *DatalossResponse_Repository_Storage) GetValidPrimary() bool {
	if x != nil {
		return x.ValidPrimary
	}
	return false
}

// RepositoryDetails ...
type RepositoryReplicasResponse_RepositoryDetails struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository ...
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// checksum ...
	Checksum      string `protobuf:"bytes,2,opt,name=checksum,proto3" json:"checksum,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RepositoryReplicasResponse_RepositoryDetails) Reset() {
	*x = RepositoryReplicasResponse_RepositoryDetails{}
	mi := &file_praefect_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RepositoryReplicasResponse_RepositoryDetails) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RepositoryReplicasResponse_RepositoryDetails) ProtoMessage() {}

func (x *RepositoryReplicasResponse_RepositoryDetails) ProtoReflect() protoreflect.Message {
	mi := &file_praefect_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RepositoryReplicasResponse_RepositoryDetails.ProtoReflect.Descriptor instead.
func (*RepositoryReplicasResponse_RepositoryDetails) Descriptor() ([]byte, []int) {
	return file_praefect_proto_rawDescGZIP(), []int{11, 0}
}

func (x *RepositoryReplicasResponse_RepositoryDetails) GetRepository() *Repository {
	if x != nil {
		return x.Repository
	}
	return nil
}

func (x *RepositoryReplicasResponse_RepositoryDetails) GetChecksum() string {
	if x != nil {
		return x.Checksum
	}
	return ""
}

var File_praefect_proto protoreflect.FileDescriptor

const file_praefect_proto_rawDesc = "" +
	"\n" +
	"\x0epraefect.proto\x12\x06gitaly\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\n" +
	"lint.proto\x1a\fshared.proto\"\x86\x02\n" +
	"\x15MarkUnverifiedRequest\x12%\n" +
	"\rrepository_id\x18\x01 \x01(\x03H\x00R\frepositoryId\x12)\n" +
	"\x0fvirtual_storage\x18\x02 \x01(\tH\x00R\x0evirtualStorage\x12A\n" +
	"\astorage\x18\x03 \x01(\v2%.gitaly.MarkUnverifiedRequest.StorageH\x00R\astorage\x1aL\n" +
	"\aStorage\x12'\n" +
	"\x0fvirtual_storage\x18\x01 \x01(\tR\x0evirtualStorage\x12\x18\n" +
	"\astorage\x18\x02 \x01(\tR\astorageB\n" +
	"\n" +
	"\bselector\"A\n" +
	"\x16MarkUnverifiedResponse\x12'\n" +
	"\x0freplicas_marked\x18\x01 \x01(\x03R\x0ereplicasMarked\"\xe5\x01\n" +
	"\x1cGetRepositoryMetadataRequest\x12%\n" +
	"\rrepository_id\x18\x01 \x01(\x03H\x00R\frepositoryId\x12?\n" +
	"\x04path\x18\x02 \x01(\v2).gitaly.GetRepositoryMetadataRequest.PathH\x00R\x04path\x1aT\n" +
	"\x04Path\x12'\n" +
	"\x0fvirtual_storage\x18\x01 \x01(\tR\x0evirtualStorage\x12#\n" +
	"\rrelative_path\x18\x02 \x01(\tR\frelativePathB\a\n" +
	"\x05query\"\x98\x04\n" +
	"\x1dGetRepositoryMetadataResponse\x12#\n" +
	"\rrepository_id\x18\x01 \x01(\x03R\frepositoryId\x12'\n" +
	"\x0fvirtual_storage\x18\x02 \x01(\tR\x0evirtualStorage\x12#\n" +
	"\rrelative_path\x18\x03 \x01(\tR\frelativePath\x12!\n" +
	"\freplica_path\x18\x04 \x01(\tR\vreplicaPath\x12\x18\n" +
	"\aprimary\x18\x05 \x01(\tR\aprimary\x12\x1e\n" +
	"\n" +
	"generation\x18\x06 \x01(\x03R\n" +
	"generation\x12I\n" +
	"\breplicas\x18\a \x03(\v2-.gitaly.GetRepositoryMetadataResponse.ReplicaR\breplicas\x1a\xdb\x01\n" +
	"\aReplica\x12\x18\n" +
	"\astorage\x18\x01 \x01(\tR\astorage\x12\x1a\n" +
	"\bassigned\x18\x02 \x01(\bR\bassigned\x12\x1e\n" +
	"\n" +
	"generation\x18\x04 \x01(\x03R\n" +
	"generation\x12\x18\n" +
	"\ahealthy\x18\x05 \x01(\bR\ahealthy\x12#\n" +
	"\rvalid_primary\x18\x06 \x01(\bR\fvalidPrimary\x12;\n" +
	"\vverified_at\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\n" +
	"verifiedAt\"\x9a\x01\n" +
	"\x1bSetReplicationFactorRequest\x12'\n" +
	"\x0fvirtual_storage\x18\x01 \x01(\tR\x0evirtualStorage\x12#\n" +
	"\rrelative_path\x18\x02 \x01(\tR\frelativePath\x12-\n" +
	"\x12replication_factor\x18\x03 \x01(\x05R\x11replicationFactor\":\n" +
	"\x1cSetReplicationFactorResponse\x12\x1a\n" +
	"\bstorages\x18\x01 \x03(\tR\bstorages\"\xa3\x01\n" +
	"\x1eSetAuthoritativeStorageRequest\x12'\n" +
	"\x0fvirtual_storage\x18\x01 \x01(\tR\x0evirtualStorage\x12#\n" +
	"\rrelative_path\x18\x02 \x01(\tR\frelativePath\x123\n" +
	"\x15authoritative_storage\x18\x03 \x01(\tR\x14authoritativeStorage\"!\n" +
	"\x1fSetAuthoritativeStorageResponse\"|\n" +
	"\x0fDatalossRequest\x12'\n" +
	"\x0fvirtual_storage\x18\x01 \x01(\tR\x0evirtualStorage\x12@\n" +
	"\x1cinclude_partially_replicated\x18\x02 \x01(\bR\x1aincludePartiallyReplicated\"\xac\x03\n" +
	"\x10DatalossResponse\x12G\n" +
	"\frepositories\x18\x02 \x03(\v2#.gitaly.DatalossResponse.RepositoryR\frepositories\x1a\xce\x02\n" +
	"\n" +
	"Repository\x12#\n" +
	"\rrelative_path\x18\x01 \x01(\tR\frelativePath\x12G\n" +
	"\bstorages\x18\x02 \x03(\v2+.gitaly.DatalossResponse.Repository.StorageR\bstorages\x12 \n" +
	"\vunavailable\x18\x03 \x01(\bR\vunavailable\x12\x18\n" +
	"\aprimary\x18\x04 \x01(\tR\aprimary\x1a\x95\x01\n" +
	"\aStorage\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x1b\n" +
	"\tbehind_by\x18\x02 \x01(\x03R\bbehindBy\x12\x1a\n" +
	"\bassigned\x18\x03 \x01(\bR\bassigned\x12\x18\n" +
	"\ahealthy\x18\x04 \x01(\bR\ahealthy\x12#\n" +
	"\rvalid_primary\x18\x05 \x01(\bR\fvalidPrimary\"O\n" +
	"\x19RepositoryReplicasRequest\x122\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryR\n" +
	"repository\"\xa3\x02\n" +
	"\x1aRepositoryReplicasResponse\x12N\n" +
	"\aprimary\x18\x01 \x01(\v24.gitaly.RepositoryReplicasResponse.RepositoryDetailsR\aprimary\x12P\n" +
	"\breplicas\x18\x02 \x03(\v24.gitaly.RepositoryReplicasResponse.RepositoryDetailsR\breplicas\x1ac\n" +
	"\x11RepositoryDetails\x122\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryR\n" +
	"repository\x12\x1a\n" +
	"\bchecksum\x18\x02 \x01(\tR\bchecksum2\xbf\x04\n" +
	"\x13PraefectInfoService\x12[\n" +
	"\x12RepositoryReplicas\x12!.gitaly.RepositoryReplicasRequest\x1a\".gitaly.RepositoryReplicasResponse\x12?\n" +
	"\bDataloss\x12\x17.gitaly.DatalossRequest\x1a\x18.gitaly.DatalossResponse0\x01\x12j\n" +
	"\x17SetAuthoritativeStorage\x12&.gitaly.SetAuthoritativeStorageRequest\x1a'.gitaly.SetAuthoritativeStorageResponse\x12O\n" +
	"\x0eMarkUnverified\x12\x1d.gitaly.MarkUnverifiedRequest\x1a\x1e.gitaly.MarkUnverifiedResponse\x12a\n" +
	"\x14SetReplicationFactor\x12#.gitaly.SetReplicationFactorRequest\x1a$.gitaly.SetReplicationFactorResponse\x12d\n" +
	"\x15GetRepositoryMetadata\x12$.gitaly.GetRepositoryMetadataRequest\x1a%.gitaly.GetRepositoryMetadataResponse\x1a\x04\xf0\x97(\x01B4Z2gitlab.com/gitlab-org/gitaly/v18/proto/go/gitalypbb\x06proto3"

var (
	file_praefect_proto_rawDescOnce sync.Once
	file_praefect_proto_rawDescData []byte
)

func file_praefect_proto_rawDescGZIP() []byte {
	file_praefect_proto_rawDescOnce.Do(func() {
		file_praefect_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_praefect_proto_rawDesc), len(file_praefect_proto_rawDesc)))
	})
	return file_praefect_proto_rawDescData
}

var file_praefect_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
var file_praefect_proto_goTypes = []any{
	(*MarkUnverifiedRequest)(nil),                        // 0: gitaly.MarkUnverifiedRequest
	(*MarkUnverifiedResponse)(nil),                       // 1: gitaly.MarkUnverifiedResponse
	(*GetRepositoryMetadataRequest)(nil),                 // 2: gitaly.GetRepositoryMetadataRequest
	(*GetRepositoryMetadataResponse)(nil),                // 3: gitaly.GetRepositoryMetadataResponse
	(*SetReplicationFactorRequest)(nil),                  // 4: gitaly.SetReplicationFactorRequest
	(*SetReplicationFactorResponse)(nil),                 // 5: gitaly.SetReplicationFactorResponse
	(*SetAuthoritativeStorageRequest)(nil),               // 6: gitaly.SetAuthoritativeStorageRequest
	(*SetAuthoritativeStorageResponse)(nil),              // 7: gitaly.SetAuthoritativeStorageResponse
	(*DatalossRequest)(nil),                              // 8: gitaly.DatalossRequest
	(*DatalossResponse)(nil),                             // 9: gitaly.DatalossResponse
	(*RepositoryReplicasRequest)(nil),                    // 10: gitaly.RepositoryReplicasRequest
	(*RepositoryReplicasResponse)(nil),                   // 11: gitaly.RepositoryReplicasResponse
	(*MarkUnverifiedRequest_Storage)(nil),                // 12: gitaly.MarkUnverifiedRequest.Storage
	(*GetRepositoryMetadataRequest_Path)(nil),            // 13: gitaly.GetRepositoryMetadataRequest.Path
	(*GetRepositoryMetadataResponse_Replica)(nil),        // 14: gitaly.GetRepositoryMetadataResponse.Replica
	(*DatalossResponse_Repository)(nil),                  // 15: gitaly.DatalossResponse.Repository
	(*DatalossResponse_Repository_Storage)(nil),          // 16: gitaly.DatalossResponse.Repository.Storage
	(*RepositoryReplicasResponse_RepositoryDetails)(nil), // 17: gitaly.RepositoryReplicasResponse.RepositoryDetails
	(*Repository)(nil),                                   // 18: gitaly.Repository
	(*timestamppb.Timestamp)(nil),                        // 19: google.protobuf.Timestamp
}
var file_praefect_proto_depIdxs = []int32{
	12, // 0: gitaly.MarkUnverifiedRequest.storage:type_name -> gitaly.MarkUnverifiedRequest.Storage
	13, // 1: gitaly.GetRepositoryMetadataRequest.path:type_name -> gitaly.GetRepositoryMetadataRequest.Path
	14, // 2: gitaly.GetRepositoryMetadataResponse.replicas:type_name -> gitaly.GetRepositoryMetadataResponse.Replica
	15, // 3: gitaly.DatalossResponse.repositories:type_name -> gitaly.DatalossResponse.Repository
	18, // 4: gitaly.RepositoryReplicasRequest.repository:type_name -> gitaly.Repository
	17, // 5: gitaly.RepositoryReplicasResponse.primary:type_name -> gitaly.RepositoryReplicasResponse.RepositoryDetails
	17, // 6: gitaly.RepositoryReplicasResponse.replicas:type_name -> gitaly.RepositoryReplicasResponse.RepositoryDetails
	19, // 7: gitaly.GetRepositoryMetadataResponse.Replica.verified_at:type_name -> google.protobuf.Timestamp
	16, // 8: gitaly.DatalossResponse.Repository.storages:type_name -> gitaly.DatalossResponse.Repository.Storage
	18, // 9: gitaly.RepositoryReplicasResponse.RepositoryDetails.repository:type_name -> gitaly.Repository
	10, // 10: gitaly.PraefectInfoService.RepositoryReplicas:input_type -> gitaly.RepositoryReplicasRequest
	8,  // 11: gitaly.PraefectInfoService.Dataloss:input_type -> gitaly.DatalossRequest
	6,  // 12: gitaly.PraefectInfoService.SetAuthoritativeStorage:input_type -> gitaly.SetAuthoritativeStorageRequest
	0,  // 13: gitaly.PraefectInfoService.MarkUnverified:input_type -> gitaly.MarkUnverifiedRequest
	4,  // 14: gitaly.PraefectInfoService.SetReplicationFactor:input_type -> gitaly.SetReplicationFactorRequest
	2,  // 15: gitaly.PraefectInfoService.GetRepositoryMetadata:input_type -> gitaly.GetRepositoryMetadataRequest
	11, // 16: gitaly.PraefectInfoService.RepositoryReplicas:output_type -> gitaly.RepositoryReplicasResponse
	9,  // 17: gitaly.PraefectInfoService.Dataloss:output_type -> gitaly.DatalossResponse
	7,  // 18: gitaly.PraefectInfoService.SetAuthoritativeStorage:output_type -> gitaly.SetAuthoritativeStorageResponse
	1,  // 19: gitaly.PraefectInfoService.MarkUnverified:output_type -> gitaly.MarkUnverifiedResponse
	5,  // 20: gitaly.PraefectInfoService.SetReplicationFactor:output_type -> gitaly.SetReplicationFactorResponse
	3,  // 21: gitaly.PraefectInfoService.GetRepositoryMetadata:output_type -> gitaly.GetRepositoryMetadataResponse
	16, // [16:22] is the sub-list for method output_type
	10, // [10:16] is the sub-list for method input_type
	10, // [10:10] is the sub-list for extension type_name
	10, // [10:10] is the sub-list for extension extendee
	0,  // [0:10] is the sub-list for field type_name
}

func init() { file_praefect_proto_init() }
func file_praefect_proto_init() {
	if File_praefect_proto != nil {
		return
	}
	file_lint_proto_init()
	file_shared_proto_init()
	file_praefect_proto_msgTypes[0].OneofWrappers = []any{
		(*MarkUnverifiedRequest_RepositoryId)(nil),
		(*MarkUnverifiedRequest_VirtualStorage)(nil),
		(*MarkUnverifiedRequest_Storage_)(nil),
	}
	file_praefect_proto_msgTypes[2].OneofWrappers = []any{
		(*GetRepositoryMetadataRequest_RepositoryId)(nil),
		(*GetRepositoryMetadataRequest_Path_)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_praefect_proto_rawDesc), len(file_praefect_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   18,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_praefect_proto_goTypes,
		DependencyIndexes: file_praefect_proto_depIdxs,
		MessageInfos:      file_praefect_proto_msgTypes,
	}.Build()
	File_praefect_proto = out.File
	file_praefect_proto_goTypes = nil
	file_praefect_proto_depIdxs = nil
}
