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

package gitalypb

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	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)
)

// ReferenceBackend denotes the type of backend used to store references.
type RepositoryInfoResponse_ReferencesInfo_ReferenceBackend int32

const (
	// REFERENCE_BACKEND_UNSPECIFIED is the default value for a reference backend if there
	// is an error during detection. This state should ideally never occur, and if set
	// it indicates that something has gone wrong.
	RepositoryInfoResponse_ReferencesInfo_REFERENCE_BACKEND_UNSPECIFIED RepositoryInfoResponse_ReferencesInfo_ReferenceBackend = 0
	// REFERENCE_BACKEND_FILES is the traditional backend built using files/directories.
	RepositoryInfoResponse_ReferencesInfo_REFERENCE_BACKEND_FILES RepositoryInfoResponse_ReferencesInfo_ReferenceBackend = 1
	// REFERENCE_BACKEND_REFTABLE is the new backend using customized binary file format.
	RepositoryInfoResponse_ReferencesInfo_REFERENCE_BACKEND_REFTABLE RepositoryInfoResponse_ReferencesInfo_ReferenceBackend = 2
)

// Enum value maps for RepositoryInfoResponse_ReferencesInfo_ReferenceBackend.
var (
	RepositoryInfoResponse_ReferencesInfo_ReferenceBackend_name = map[int32]string{
		0: "REFERENCE_BACKEND_UNSPECIFIED",
		1: "REFERENCE_BACKEND_FILES",
		2: "REFERENCE_BACKEND_REFTABLE",
	}
	RepositoryInfoResponse_ReferencesInfo_ReferenceBackend_value = map[string]int32{
		"REFERENCE_BACKEND_UNSPECIFIED": 0,
		"REFERENCE_BACKEND_FILES":       1,
		"REFERENCE_BACKEND_REFTABLE":    2,
	}
)

func (x RepositoryInfoResponse_ReferencesInfo_ReferenceBackend) Enum() *RepositoryInfoResponse_ReferencesInfo_ReferenceBackend {
	p := new(RepositoryInfoResponse_ReferencesInfo_ReferenceBackend)
	*p = x
	return p
}

func (x RepositoryInfoResponse_ReferencesInfo_ReferenceBackend) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (RepositoryInfoResponse_ReferencesInfo_ReferenceBackend) Descriptor() protoreflect.EnumDescriptor {
	return file_repository_proto_enumTypes[0].Descriptor()
}

func (RepositoryInfoResponse_ReferencesInfo_ReferenceBackend) Type() protoreflect.EnumType {
	return &file_repository_proto_enumTypes[0]
}

func (x RepositoryInfoResponse_ReferencesInfo_ReferenceBackend) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use RepositoryInfoResponse_ReferencesInfo_ReferenceBackend.Descriptor instead.
func (RepositoryInfoResponse_ReferencesInfo_ReferenceBackend) EnumDescriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{5, 0, 0}
}

// Format is the format which the archive should be packaged in.
type GetArchiveRequest_Format int32

const (
	// ZIP
	GetArchiveRequest_ZIP GetArchiveRequest_Format = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// TAR
	GetArchiveRequest_TAR GetArchiveRequest_Format = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// TAR_GZ
	GetArchiveRequest_TAR_GZ GetArchiveRequest_Format = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// TAR_BZ2
	GetArchiveRequest_TAR_BZ2 GetArchiveRequest_Format = 3 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for GetArchiveRequest_Format.
var (
	GetArchiveRequest_Format_name = map[int32]string{
		0: "ZIP",
		1: "TAR",
		2: "TAR_GZ",
		3: "TAR_BZ2",
	}
	GetArchiveRequest_Format_value = map[string]int32{
		"ZIP":     0,
		"TAR":     1,
		"TAR_GZ":  2,
		"TAR_BZ2": 3,
	}
)

func (x GetArchiveRequest_Format) Enum() *GetArchiveRequest_Format {
	p := new(GetArchiveRequest_Format)
	*p = x
	return p
}

func (x GetArchiveRequest_Format) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (GetArchiveRequest_Format) Descriptor() protoreflect.EnumDescriptor {
	return file_repository_proto_enumTypes[1].Descriptor()
}

func (GetArchiveRequest_Format) Type() protoreflect.EnumType {
	return &file_repository_proto_enumTypes[1]
}

func (x GetArchiveRequest_Format) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use GetArchiveRequest_Format.Descriptor instead.
func (GetArchiveRequest_Format) EnumDescriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{16, 0}
}

// Operation is the change that occurred on the file. Consult the man pages
// for git-diff(1) for additional detail on the semantics of each operation.
type GetRawChangesResponse_RawChange_Operation int32

const (
	// UNKNOWN
	GetRawChangesResponse_RawChange_UNKNOWN GetRawChangesResponse_RawChange_Operation = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// ADDED
	GetRawChangesResponse_RawChange_ADDED GetRawChangesResponse_RawChange_Operation = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// COPIED
	GetRawChangesResponse_RawChange_COPIED GetRawChangesResponse_RawChange_Operation = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// DELETED
	GetRawChangesResponse_RawChange_DELETED GetRawChangesResponse_RawChange_Operation = 3 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// MODIFIED
	GetRawChangesResponse_RawChange_MODIFIED GetRawChangesResponse_RawChange_Operation = 4 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// RENAMED
	GetRawChangesResponse_RawChange_RENAMED GetRawChangesResponse_RawChange_Operation = 5 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// TYPE_CHANGED
	GetRawChangesResponse_RawChange_TYPE_CHANGED GetRawChangesResponse_RawChange_Operation = 6 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for GetRawChangesResponse_RawChange_Operation.
var (
	GetRawChangesResponse_RawChange_Operation_name = map[int32]string{
		0: "UNKNOWN",
		1: "ADDED",
		2: "COPIED",
		3: "DELETED",
		4: "MODIFIED",
		5: "RENAMED",
		6: "TYPE_CHANGED",
	}
	GetRawChangesResponse_RawChange_Operation_value = map[string]int32{
		"UNKNOWN":      0,
		"ADDED":        1,
		"COPIED":       2,
		"DELETED":      3,
		"MODIFIED":     4,
		"RENAMED":      5,
		"TYPE_CHANGED": 6,
	}
)

func (x GetRawChangesResponse_RawChange_Operation) Enum() *GetRawChangesResponse_RawChange_Operation {
	p := new(GetRawChangesResponse_RawChange_Operation)
	*p = x
	return p
}

func (x GetRawChangesResponse_RawChange_Operation) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (GetRawChangesResponse_RawChange_Operation) Descriptor() protoreflect.EnumDescriptor {
	return file_repository_proto_enumTypes[2].Descriptor()
}

func (GetRawChangesResponse_RawChange_Operation) Type() protoreflect.EnumType {
	return &file_repository_proto_enumTypes[2]
}

func (x GetRawChangesResponse_RawChange_Operation) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use GetRawChangesResponse_RawChange_Operation.Descriptor instead.
func (GetRawChangesResponse_RawChange_Operation) EnumDescriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{62, 0, 0}
}

// Strategy determines how the repository shall be optimized.
type OptimizeRepositoryRequest_Strategy int32

const (
	// STRATEGY_UNSPECIFIED indicates that the strategy has not been explicitly set by the
	// caller. The default will be STRATEGY_HEURISTICAL in that case.
	OptimizeRepositoryRequest_STRATEGY_UNSPECIFIED OptimizeRepositoryRequest_Strategy = 0
	// STRATEGY_HEURISTICAL performs heuristical optimizations in the repository. The server will
	// decide on a set of heuristics which parts need optimization and which ones don't to avoid
	// performing unnecessary optimization tasks.
	OptimizeRepositoryRequest_STRATEGY_HEURISTICAL OptimizeRepositoryRequest_Strategy = 1
	// STRATEGY_EAGER performs eager optimizations in the repository. The server will optimize all
	// data structures regardless of whether they are well-optimized already.
	OptimizeRepositoryRequest_STRATEGY_EAGER OptimizeRepositoryRequest_Strategy = 2
	// STRATEGY_OFFLOADING selectively moves repository objects to secondary storage.
	OptimizeRepositoryRequest_STRATEGY_OFFLOADING OptimizeRepositoryRequest_Strategy = 3
	// STRATEGY_REHYDRATION selectively revert a repository from offloading state to all local state.
	OptimizeRepositoryRequest_STRATEGY_REHYDRATION OptimizeRepositoryRequest_Strategy = 4
)

// Enum value maps for OptimizeRepositoryRequest_Strategy.
var (
	OptimizeRepositoryRequest_Strategy_name = map[int32]string{
		0: "STRATEGY_UNSPECIFIED",
		1: "STRATEGY_HEURISTICAL",
		2: "STRATEGY_EAGER",
		3: "STRATEGY_OFFLOADING",
		4: "STRATEGY_REHYDRATION",
	}
	OptimizeRepositoryRequest_Strategy_value = map[string]int32{
		"STRATEGY_UNSPECIFIED": 0,
		"STRATEGY_HEURISTICAL": 1,
		"STRATEGY_EAGER":       2,
		"STRATEGY_OFFLOADING":  3,
		"STRATEGY_REHYDRATION": 4,
	}
)

func (x OptimizeRepositoryRequest_Strategy) Enum() *OptimizeRepositoryRequest_Strategy {
	p := new(OptimizeRepositoryRequest_Strategy)
	*p = x
	return p
}

func (x OptimizeRepositoryRequest_Strategy) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (OptimizeRepositoryRequest_Strategy) Descriptor() protoreflect.EnumDescriptor {
	return file_repository_proto_enumTypes[3].Descriptor()
}

func (OptimizeRepositoryRequest_Strategy) Type() protoreflect.EnumType {
	return &file_repository_proto_enumTypes[3]
}

func (x OptimizeRepositoryRequest_Strategy) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use OptimizeRepositoryRequest_Strategy.Descriptor instead.
func (OptimizeRepositoryRequest_Strategy) EnumDescriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{74, 0}
}

// ReferenceBackend denotes the type of backend used to store references.
type MigrateReferenceBackendRequest_ReferenceBackend int32

const (
	// REFERENCE_BACKEND_UNSPECIFIED is the default value and should never be set.
	MigrateReferenceBackendRequest_REFERENCE_BACKEND_UNSPECIFIED MigrateReferenceBackendRequest_ReferenceBackend = 0
	// REFERENCE_BACKEND_FILES is the traditional backend built using files/directories.
	MigrateReferenceBackendRequest_REFERENCE_BACKEND_FILES MigrateReferenceBackendRequest_ReferenceBackend = 1
	// REFERENCE_BACKEND_REFTABLE is the new backend using customized binary file format.
	MigrateReferenceBackendRequest_REFERENCE_BACKEND_REFTABLE MigrateReferenceBackendRequest_ReferenceBackend = 2
)

// Enum value maps for MigrateReferenceBackendRequest_ReferenceBackend.
var (
	MigrateReferenceBackendRequest_ReferenceBackend_name = map[int32]string{
		0: "REFERENCE_BACKEND_UNSPECIFIED",
		1: "REFERENCE_BACKEND_FILES",
		2: "REFERENCE_BACKEND_REFTABLE",
	}
	MigrateReferenceBackendRequest_ReferenceBackend_value = map[string]int32{
		"REFERENCE_BACKEND_UNSPECIFIED": 0,
		"REFERENCE_BACKEND_FILES":       1,
		"REFERENCE_BACKEND_REFTABLE":    2,
	}
)

func (x MigrateReferenceBackendRequest_ReferenceBackend) Enum() *MigrateReferenceBackendRequest_ReferenceBackend {
	p := new(MigrateReferenceBackendRequest_ReferenceBackend)
	*p = x
	return p
}

func (x MigrateReferenceBackendRequest_ReferenceBackend) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (MigrateReferenceBackendRequest_ReferenceBackend) Descriptor() protoreflect.EnumDescriptor {
	return file_repository_proto_enumTypes[4].Descriptor()
}

func (MigrateReferenceBackendRequest_ReferenceBackend) Type() protoreflect.EnumType {
	return &file_repository_proto_enumTypes[4]
}

func (x MigrateReferenceBackendRequest_ReferenceBackend) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use MigrateReferenceBackendRequest_ReferenceBackend.Descriptor instead.
func (MigrateReferenceBackendRequest_ReferenceBackend) EnumDescriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{86, 0}
}

// RepositoryExistsRequest is a request for the RepositoryExists RPC.
type RepositoryExistsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to check. The storage_name and relative_path attributes must be provided.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepositoryExistsRequest) ProtoMessage() {}

func (x *RepositoryExistsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 RepositoryExistsRequest.ProtoReflect.Descriptor instead.
func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{0}
}

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

// RepositoryExistsResponse is a response for the RepositoryExists RPC.
type RepositoryExistsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// exists indicates whether the repo exists.
	Exists        bool `protobuf:"varint,1,opt,name=exists,proto3" json:"exists,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepositoryExistsResponse) ProtoMessage() {}

func (x *RepositoryExistsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 RepositoryExistsResponse.ProtoReflect.Descriptor instead.
func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{1}
}

func (x *RepositoryExistsResponse) GetExists() bool {
	if x != nil {
		return x.Exists
	}
	return false
}

// RepositorySizeRequest is a request for the RepositorySize RPC.
type RepositorySizeRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository for which to determine the repository size.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepositorySizeRequest) ProtoMessage() {}

func (x *RepositorySizeRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 RepositorySizeRequest.ProtoReflect.Descriptor instead.
func (*RepositorySizeRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{2}
}

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

// RepositorySizeResponse is a response for the RepositorySize RPC.
type RepositorySizeResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// size is the complete size of the on-disk repository in kilobytes. This will include all data
	// structures and is similar to `du --summarize --bytes $REPO_PATH`.
	Size          int64 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepositorySizeResponse) ProtoMessage() {}

func (x *RepositorySizeResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 RepositorySizeResponse.ProtoReflect.Descriptor instead.
func (*RepositorySizeResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{3}
}

func (x *RepositorySizeResponse) GetSize() int64 {
	if x != nil {
		return x.Size
	}
	return 0
}

// RepositoryInfoRequest is a request for the RepositoryInfo RPC.
type RepositoryInfoRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to query for information.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepositoryInfoRequest) ProtoMessage() {}

func (x *RepositoryInfoRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 RepositoryInfoRequest.ProtoReflect.Descriptor instead.
func (*RepositoryInfoRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{4}
}

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

// RepositoryInfoResponse is a response for the RepositoryInfo RPC.
type RepositoryInfoResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// size is the total size of all files part of the repository. It does not include the size of
	// directories.
	Size uint64 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"`
	// references contains information about references.
	References *RepositoryInfoResponse_ReferencesInfo `protobuf:"bytes,2,opt,name=references,proto3" json:"references,omitempty"`
	// objects contains information about objects.
	Objects *RepositoryInfoResponse_ObjectsInfo `protobuf:"bytes,3,opt,name=objects,proto3" json:"objects,omitempty"`
	// commit_graph contains information about the repository's commit-graphs.
	CommitGraph *RepositoryInfoResponse_CommitGraphInfo `protobuf:"bytes,4,opt,name=commit_graph,json=commitGraph,proto3" json:"commit_graph,omitempty"`
	// bitmap contains information about the bitmap, if any exists.
	Bitmap *RepositoryInfoResponse_BitmapInfo `protobuf:"bytes,5,opt,name=bitmap,proto3" json:"bitmap,omitempty"`
	// multi_pack_index contains information about the multi-pack-index, if any exists.
	MultiPackIndex *RepositoryInfoResponse_MultiPackIndexInfo `protobuf:"bytes,6,opt,name=multi_pack_index,json=multiPackIndex,proto3" json:"multi_pack_index,omitempty"`
	// multi_pack_index_bitmap contains information about the bitmap for the multi-pack-index.
	MultiPackIndexBitmap *RepositoryInfoResponse_BitmapInfo `protobuf:"bytes,7,opt,name=multi_pack_index_bitmap,json=multiPackIndexBitmap,proto3" json:"multi_pack_index_bitmap,omitempty"`
	// alternates contains information about alternate object directories.
	Alternates *RepositoryInfoResponse_AlternatesInfo `protobuf:"bytes,8,opt,name=alternates,proto3" json:"alternates,omitempty"`
	// is_object_pool determines whether the repository is an object pool.
	IsObjectPool bool `protobuf:"varint,9,opt,name=is_object_pool,json=isObjectPool,proto3" json:"is_object_pool,omitempty"`
	// last_full_repack indicates the last date at which a full repack has been
	// performed.
	LastFullRepack *timestamppb.Timestamp `protobuf:"bytes,10,opt,name=last_full_repack,json=lastFullRepack,proto3" json:"last_full_repack,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*RepositoryInfoResponse) ProtoMessage() {}

func (x *RepositoryInfoResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 RepositoryInfoResponse.ProtoReflect.Descriptor instead.
func (*RepositoryInfoResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{5}
}

func (x *RepositoryInfoResponse) GetSize() uint64 {
	if x != nil {
		return x.Size
	}
	return 0
}

func (x *RepositoryInfoResponse) GetReferences() *RepositoryInfoResponse_ReferencesInfo {
	if x != nil {
		return x.References
	}
	return nil
}

func (x *RepositoryInfoResponse) GetObjects() *RepositoryInfoResponse_ObjectsInfo {
	if x != nil {
		return x.Objects
	}
	return nil
}

func (x *RepositoryInfoResponse) GetCommitGraph() *RepositoryInfoResponse_CommitGraphInfo {
	if x != nil {
		return x.CommitGraph
	}
	return nil
}

func (x *RepositoryInfoResponse) GetBitmap() *RepositoryInfoResponse_BitmapInfo {
	if x != nil {
		return x.Bitmap
	}
	return nil
}

func (x *RepositoryInfoResponse) GetMultiPackIndex() *RepositoryInfoResponse_MultiPackIndexInfo {
	if x != nil {
		return x.MultiPackIndex
	}
	return nil
}

func (x *RepositoryInfoResponse) GetMultiPackIndexBitmap() *RepositoryInfoResponse_BitmapInfo {
	if x != nil {
		return x.MultiPackIndexBitmap
	}
	return nil
}

func (x *RepositoryInfoResponse) GetAlternates() *RepositoryInfoResponse_AlternatesInfo {
	if x != nil {
		return x.Alternates
	}
	return nil
}

func (x *RepositoryInfoResponse) GetIsObjectPool() bool {
	if x != nil {
		return x.IsObjectPool
	}
	return false
}

func (x *RepositoryInfoResponse) GetLastFullRepack() *timestamppb.Timestamp {
	if x != nil {
		return x.LastFullRepack
	}
	return nil
}

// ObjectsSizeRequest is a request for the ObjectsSize RPC. The RPC is defined as a streaming RPC given that a client
// may theoretically specify an unbounded number of revisions. Only the first request may have fields other than the
// revisions set.
type ObjectsSizeRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository for which to determine the object size.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revisions is the set of revisions that shall be used to compute the object size for. Supports normal revisions as
	// well as pseudo-revisions like `--not`, `--all`, `--branches[=pattern]`, `--tags[=pattern]` and `--glob=pattern`.
	// Please refer to the man pages gitrevisions(7) as well as git-rev-list(1) for more information.
	Revisions     [][]byte `protobuf:"bytes,2,rep,name=revisions,proto3" json:"revisions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObjectsSizeRequest) ProtoMessage() {}

func (x *ObjectsSizeRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 ObjectsSizeRequest.ProtoReflect.Descriptor instead.
func (*ObjectsSizeRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{6}
}

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

func (x *ObjectsSizeRequest) GetRevisions() [][]byte {
	if x != nil {
		return x.Revisions
	}
	return nil
}

// ObjectsSizeResponse is a response for the ObjectsSize RPC.
type ObjectsSizeResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// size is the total size of all objects reachable via the given set of revisions. The size is
	// specified in bytes.
	Size          uint64 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObjectsSizeResponse) ProtoMessage() {}

func (x *ObjectsSizeResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 ObjectsSizeResponse.ProtoReflect.Descriptor instead.
func (*ObjectsSizeResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{7}
}

func (x *ObjectsSizeResponse) GetSize() uint64 {
	if x != nil {
		return x.Size
	}
	return 0
}

// ObjectFormatRequest is a request for the ObjectFormat RPC.
type ObjectFormatRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository for which to determine the object format.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObjectFormatRequest) ProtoMessage() {}

func (x *ObjectFormatRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 ObjectFormatRequest.ProtoReflect.Descriptor instead.
func (*ObjectFormatRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{8}
}

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

// ObjectFormatResponse is a response for the ObjectFormat RPC.
type ObjectFormatResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// format is the object format that the repository uses.
	Format        ObjectFormat `protobuf:"varint,1,opt,name=format,proto3,enum=gitaly.ObjectFormat" json:"format,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObjectFormatResponse) ProtoMessage() {}

func (x *ObjectFormatResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 ObjectFormatResponse.ProtoReflect.Descriptor instead.
func (*ObjectFormatResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{9}
}

func (x *ObjectFormatResponse) GetFormat() ObjectFormat {
	if x != nil {
		return x.Format
	}
	return ObjectFormat_OBJECT_FORMAT_UNSPECIFIED
}

// FetchBundleRequest is a request for the FetchBundle RPC.
type FetchBundleRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository into which the reference shall be fetched.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// data is the bundle file stream.
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// update_head will update HEAD if there is a HEAD reference listed in the bundle
	UpdateHead    bool `protobuf:"varint,3,opt,name=update_head,json=updateHead,proto3" json:"update_head,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FetchBundleRequest) ProtoMessage() {}

func (x *FetchBundleRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 FetchBundleRequest.ProtoReflect.Descriptor instead.
func (*FetchBundleRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{10}
}

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

func (x *FetchBundleRequest) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

func (x *FetchBundleRequest) GetUpdateHead() bool {
	if x != nil {
		return x.UpdateHead
	}
	return false
}

// FetchBundleResponse is a response for the FetchBundle RPC.
type FetchBundleResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FetchBundleResponse) ProtoMessage() {}

func (x *FetchBundleResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 FetchBundleResponse.ProtoReflect.Descriptor instead.
func (*FetchBundleResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{11}
}

// FetchRemoteRequest is a request for the FetchRemote RPC.
type FetchRemoteRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to fetch the remote into. The storage_name
	// and relative_path attributes must be provided.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// force determines if references should be force-updated in case they have
	// diverged.
	Force bool `protobuf:"varint,3,opt,name=force,proto3" json:"force,omitempty"`
	// no_tags determines whether tags should be fetched.
	NoTags bool `protobuf:"varint,4,opt,name=no_tags,json=noTags,proto3" json:"no_tags,omitempty"`
	// timeout specifies a timeout for the fetch.
	Timeout int32 `protobuf:"varint,5,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// ssh_key is an optional SSH key to use for fetching the remote.
	SshKey string `protobuf:"bytes,6,opt,name=ssh_key,json=sshKey,proto3" json:"ssh_key,omitempty"`
	// known_hosts is the optional content of an SSH known-hosts file to use
	// for the SSH session.
	KnownHosts string `protobuf:"bytes,7,opt,name=known_hosts,json=knownHosts,proto3" json:"known_hosts,omitempty"`
	// no_prune will the fetch to not prune remote references which do not exist
	// in the remote repository anymore.
	NoPrune bool `protobuf:"varint,9,opt,name=no_prune,json=noPrune,proto3" json:"no_prune,omitempty"`
	// remote_params specifies the remote repository which should be fetched
	// from.
	RemoteParams *Remote `protobuf:"bytes,10,opt,name=remote_params,json=remoteParams,proto3" json:"remote_params,omitempty"`
	// check_tags_changed defines whether to check if any tags were modified,
	// returning the result in the tags_changed field of FetchRemoteResponse.
	CheckTagsChanged bool `protobuf:"varint,11,opt,name=check_tags_changed,json=checkTagsChanged,proto3" json:"check_tags_changed,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*FetchRemoteRequest) ProtoMessage() {}

func (x *FetchRemoteRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 FetchRemoteRequest.ProtoReflect.Descriptor instead.
func (*FetchRemoteRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{12}
}

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

func (x *FetchRemoteRequest) GetForce() bool {
	if x != nil {
		return x.Force
	}
	return false
}

func (x *FetchRemoteRequest) GetNoTags() bool {
	if x != nil {
		return x.NoTags
	}
	return false
}

func (x *FetchRemoteRequest) GetTimeout() int32 {
	if x != nil {
		return x.Timeout
	}
	return 0
}

func (x *FetchRemoteRequest) GetSshKey() string {
	if x != nil {
		return x.SshKey
	}
	return ""
}

func (x *FetchRemoteRequest) GetKnownHosts() string {
	if x != nil {
		return x.KnownHosts
	}
	return ""
}

func (x *FetchRemoteRequest) GetNoPrune() bool {
	if x != nil {
		return x.NoPrune
	}
	return false
}

func (x *FetchRemoteRequest) GetRemoteParams() *Remote {
	if x != nil {
		return x.RemoteParams
	}
	return nil
}

func (x *FetchRemoteRequest) GetCheckTagsChanged() bool {
	if x != nil {
		return x.CheckTagsChanged
	}
	return false
}

// FetchRemoteResponse is a response for the FetchRemote RPC.
type FetchRemoteResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// tags_changed is set based to true if tags were changed or cannot be determined
	// and false when no tags were change.
	TagsChanged bool `protobuf:"varint,1,opt,name=tags_changed,json=tagsChanged,proto3" json:"tags_changed,omitempty"`
	// repo_changed is set to true if the repo was changed.
	RepoChanged   bool `protobuf:"varint,2,opt,name=repo_changed,json=repoChanged,proto3" json:"repo_changed,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FetchRemoteResponse) ProtoMessage() {}

func (x *FetchRemoteResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 FetchRemoteResponse.ProtoReflect.Descriptor instead.
func (*FetchRemoteResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{13}
}

func (x *FetchRemoteResponse) GetTagsChanged() bool {
	if x != nil {
		return x.TagsChanged
	}
	return false
}

func (x *FetchRemoteResponse) GetRepoChanged() bool {
	if x != nil {
		return x.RepoChanged
	}
	return false
}

// CreateRepositoryRequest is a request for the CreateRepository RPC.
type CreateRepositoryRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository represents the repo to create. The storage_name and relative_path attributes must be provided.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// default_branch is the branch name to set as the default branch of the newly created
	// repository. Note, this will be treated as the branch name and not a
	// fully qualified reference.
	DefaultBranch []byte `protobuf:"bytes,2,opt,name=default_branch,json=defaultBranch,proto3" json:"default_branch,omitempty"`
	// object_format is the object format the repository should be created with. Note that this is
	// experimental and should not be used by callers yet. It is mostly intended for internal testing
	// purposes in Gitaly right now.
	ObjectFormat  ObjectFormat `protobuf:"varint,3,opt,name=object_format,json=objectFormat,proto3,enum=gitaly.ObjectFormat" json:"object_format,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CreateRepositoryRequest) ProtoMessage() {}

func (x *CreateRepositoryRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 CreateRepositoryRequest.ProtoReflect.Descriptor instead.
func (*CreateRepositoryRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{14}
}

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

func (x *CreateRepositoryRequest) GetDefaultBranch() []byte {
	if x != nil {
		return x.DefaultBranch
	}
	return nil
}

func (x *CreateRepositoryRequest) GetObjectFormat() ObjectFormat {
	if x != nil {
		return x.ObjectFormat
	}
	return ObjectFormat_OBJECT_FORMAT_UNSPECIFIED
}

// CreateRepositoryResponse is a response for the CreateRepository RPC. An empty
// response denotes a successful request.
type CreateRepositoryResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CreateRepositoryResponse) ProtoMessage() {}

func (x *CreateRepositoryResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 CreateRepositoryResponse.ProtoReflect.Descriptor instead.
func (*CreateRepositoryResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{15}
}

// GetArchiveRequest is a request for the GetArchive RPC.
type GetArchiveRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to archive. The storage_name and relative_path attributes must be provided.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// commit_id is the commit at which to perform the archive.
	CommitId string `protobuf:"bytes,2,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// prefix is an optional prefix to add to paths in the archive.
	Prefix string `protobuf:"bytes,3,opt,name=prefix,proto3" json:"prefix,omitempty"`
	// format is the archive format to stream in the response.
	Format GetArchiveRequest_Format `protobuf:"varint,4,opt,name=format,proto3,enum=gitaly.GetArchiveRequest_Format" json:"format,omitempty"`
	// path is the subdirectory of the repo to archive. Provide "." for the entire repo.
	Path []byte `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
	// exclude is a set of paths to exclude from the archive. The paths must exist in the
	// tree of the provided commit_id.
	Exclude [][]byte `protobuf:"bytes,6,rep,name=exclude,proto3" json:"exclude,omitempty"` // protolint:disable:this REPEATED_FIELD_NAMES_PLURALIZED
	// elide_path whether to elide subdirectories. If it is true and `path` refers
	// to a subdirectory, that subdirectory will be elided from archive entries.
	// For example, if `dir` contains `README.md`, with `elide_path = false` the
	// corresponding entry will be `dir/README.md`; with `elide_path = true`, the
	// entry will be `README.md`. `elide_path` has no effect if `path` refers to the
	// repository root. `elide_path = true` is not supported if `path` refers to a file.
	ElidePath bool `protobuf:"varint,7,opt,name=elide_path,json=elidePath,proto3" json:"elide_path,omitempty"`
	// include_lfs_blobs controls whether Git LFS Objects are included in the archive.
	IncludeLfsBlobs bool `protobuf:"varint,8,opt,name=include_lfs_blobs,json=includeLfsBlobs,proto3" json:"include_lfs_blobs,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*GetArchiveRequest) ProtoMessage() {}

func (x *GetArchiveRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 GetArchiveRequest.ProtoReflect.Descriptor instead.
func (*GetArchiveRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{16}
}

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

func (x *GetArchiveRequest) GetCommitId() string {
	if x != nil {
		return x.CommitId
	}
	return ""
}

func (x *GetArchiveRequest) GetPrefix() string {
	if x != nil {
		return x.Prefix
	}
	return ""
}

func (x *GetArchiveRequest) GetFormat() GetArchiveRequest_Format {
	if x != nil {
		return x.Format
	}
	return GetArchiveRequest_ZIP
}

func (x *GetArchiveRequest) GetPath() []byte {
	if x != nil {
		return x.Path
	}
	return nil
}

func (x *GetArchiveRequest) GetExclude() [][]byte {
	if x != nil {
		return x.Exclude
	}
	return nil
}

func (x *GetArchiveRequest) GetElidePath() bool {
	if x != nil {
		return x.ElidePath
	}
	return false
}

func (x *GetArchiveRequest) GetIncludeLfsBlobs() bool {
	if x != nil {
		return x.IncludeLfsBlobs
	}
	return false
}

// GetArchiveResponse is a response for the GetArchive RPC.
type GetArchiveResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data contains the archive in the requested format.
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetArchiveResponse) ProtoMessage() {}

func (x *GetArchiveResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_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 GetArchiveResponse.ProtoReflect.Descriptor instead.
func (*GetArchiveResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{17}
}

func (x *GetArchiveResponse) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

// HasLocalBranchesRequest is a request for the HasLocalBranches RPC.
type HasLocalBranchesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to check. The storage_name and relative_path attributes must be provided.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *HasLocalBranchesRequest) Reset() {
	*x = HasLocalBranchesRequest{}
	mi := &file_repository_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*HasLocalBranchesRequest) ProtoMessage() {}

func (x *HasLocalBranchesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[18]
	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 HasLocalBranchesRequest.ProtoReflect.Descriptor instead.
func (*HasLocalBranchesRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{18}
}

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

// HasLocalBranchesResponse is a response for the HasLocalBranches RPC.
type HasLocalBranchesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// value indicates whether branches exist in the repo.
	Value         bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *HasLocalBranchesResponse) Reset() {
	*x = HasLocalBranchesResponse{}
	mi := &file_repository_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*HasLocalBranchesResponse) ProtoMessage() {}

func (x *HasLocalBranchesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[19]
	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 HasLocalBranchesResponse.ProtoReflect.Descriptor instead.
func (*HasLocalBranchesResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{19}
}

func (x *HasLocalBranchesResponse) GetValue() bool {
	if x != nil {
		return x.Value
	}
	return false
}

// FetchSourceBranchRequest is a request for the FetchSourceBranch RPC.
type FetchSourceBranchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository into which the reference shall be fetched. After a successful
	// call, it should contain the target reference which points to the same
	// commit as the source repository's source branch.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// source_repository is the repository from which to fetch the source branch from.
	SourceRepository *Repository `protobuf:"bytes,2,opt,name=source_repository,json=sourceRepository,proto3" json:"source_repository,omitempty"`
	// source_branch is the name of the branch in the source repository which should be fetched.
	SourceBranch []byte `protobuf:"bytes,3,opt,name=source_branch,json=sourceBranch,proto3" json:"source_branch,omitempty"`
	// target_ref is the name of the reference which shall be newly created in the target
	// repository.
	TargetRef []byte `protobuf:"bytes,4,opt,name=target_ref,json=targetRef,proto3" json:"target_ref,omitempty"`
	// expected_target_old_oid is the object ID to which target_ref is expected to point.
	// This is an optional safety guard to avoid races when target_ref has been
	// concurrently updated.
	ExpectedTargetOldOid string `protobuf:"bytes,5,opt,name=expected_target_old_oid,json=expectedTargetOldOid,proto3" json:"expected_target_old_oid,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

func (x *FetchSourceBranchRequest) Reset() {
	*x = FetchSourceBranchRequest{}
	mi := &file_repository_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FetchSourceBranchRequest) ProtoMessage() {}

func (x *FetchSourceBranchRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[20]
	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 FetchSourceBranchRequest.ProtoReflect.Descriptor instead.
func (*FetchSourceBranchRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{20}
}

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

func (x *FetchSourceBranchRequest) GetSourceRepository() *Repository {
	if x != nil {
		return x.SourceRepository
	}
	return nil
}

func (x *FetchSourceBranchRequest) GetSourceBranch() []byte {
	if x != nil {
		return x.SourceBranch
	}
	return nil
}

func (x *FetchSourceBranchRequest) GetTargetRef() []byte {
	if x != nil {
		return x.TargetRef
	}
	return nil
}

func (x *FetchSourceBranchRequest) GetExpectedTargetOldOid() string {
	if x != nil {
		return x.ExpectedTargetOldOid
	}
	return ""
}

// FetchSourceBranchResponse is a response for the FetchSourceBranch RPC.
type FetchSourceBranchResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// result denotes if the source branch was successfully fetched into the target
	// repository. It is false if resolving the remote reference or fetching it failed.
	Result        bool `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FetchSourceBranchResponse) Reset() {
	*x = FetchSourceBranchResponse{}
	mi := &file_repository_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FetchSourceBranchResponse) ProtoMessage() {}

func (x *FetchSourceBranchResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[21]
	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 FetchSourceBranchResponse.ProtoReflect.Descriptor instead.
func (*FetchSourceBranchResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{21}
}

func (x *FetchSourceBranchResponse) GetResult() bool {
	if x != nil {
		return x.Result
	}
	return false
}

// FsckRequest is a request for the Fsck RPC.
type FsckRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository that shall be checked for consistency.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// repo_only when set to true, it runs `fsck` with `--no-full`,
	// which can be used to avoid checking the object pool of a repository.
	RepoOnly      bool `protobuf:"varint,2,opt,name=repo_only,json=repoOnly,proto3" json:"repo_only,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FsckRequest) Reset() {
	*x = FsckRequest{}
	mi := &file_repository_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FsckRequest) ProtoMessage() {}

func (x *FsckRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[22]
	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 FsckRequest.ProtoReflect.Descriptor instead.
func (*FsckRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{22}
}

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

func (x *FsckRequest) GetRepoOnly() bool {
	if x != nil {
		return x.RepoOnly
	}
	return false
}

// FsckResponse is a response for the Fsck RPC.
type FsckResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// error contains both stdout and stderr of git-fsck(1) in case it returned an error.
	Error         []byte `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FsckResponse) Reset() {
	*x = FsckResponse{}
	mi := &file_repository_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FsckResponse) ProtoMessage() {}

func (x *FsckResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[23]
	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 FsckResponse.ProtoReflect.Descriptor instead.
func (*FsckResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{23}
}

func (x *FsckResponse) GetError() []byte {
	if x != nil {
		return x.Error
	}
	return nil
}

// WriteRefRequest is a request for the WriteRef RPC.
type WriteRefRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo in which to write a ref. The storage_name and relative_path
	// attributes must be provided.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// ref is the ref to create or update. It should be a fully-resolved value like refs/heads/main.
	Ref []byte `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
	// revision is the new value that the ref should point to.
	Revision []byte `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
	// old_revision is the previous value of the ref, used to prevent race conditions.
	// If an all-zero object ID is provided, the ref will only be updated if it did not
	// previously exist.
	OldRevision   []byte `protobuf:"bytes,4,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WriteRefRequest) Reset() {
	*x = WriteRefRequest{}
	mi := &file_repository_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*WriteRefRequest) ProtoMessage() {}

func (x *WriteRefRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[24]
	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 WriteRefRequest.ProtoReflect.Descriptor instead.
func (*WriteRefRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{24}
}

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

func (x *WriteRefRequest) GetRef() []byte {
	if x != nil {
		return x.Ref
	}
	return nil
}

func (x *WriteRefRequest) GetRevision() []byte {
	if x != nil {
		return x.Revision
	}
	return nil
}

func (x *WriteRefRequest) GetOldRevision() []byte {
	if x != nil {
		return x.OldRevision
	}
	return nil
}

// WriteRefResponse is a response for the WriteRef RPC.
type WriteRefResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WriteRefResponse) Reset() {
	*x = WriteRefResponse{}
	mi := &file_repository_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*WriteRefResponse) ProtoMessage() {}

func (x *WriteRefResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[25]
	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 WriteRefResponse.ProtoReflect.Descriptor instead.
func (*WriteRefResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{25}
}

// FindMergeBaseRequest is a request for the FindMergeBase RPC.
type FindMergeBaseRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to find the merge base in. The storage_name and
	// relative_path attributes must be provided.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revisions is the revisions to find the merge base for.
	// We use a repeated field because rugged supports finding a base
	// for more than 2 revisions, so if we needed that in the future we don't
	// need to change the protocol.
	Revisions     [][]byte `protobuf:"bytes,2,rep,name=revisions,proto3" json:"revisions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FindMergeBaseRequest) Reset() {
	*x = FindMergeBaseRequest{}
	mi := &file_repository_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FindMergeBaseRequest) ProtoMessage() {}

func (x *FindMergeBaseRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[26]
	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 FindMergeBaseRequest.ProtoReflect.Descriptor instead.
func (*FindMergeBaseRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{26}
}

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

func (x *FindMergeBaseRequest) GetRevisions() [][]byte {
	if x != nil {
		return x.Revisions
	}
	return nil
}

// FindMergeBaseResponse is a response for the FindMergeBase RPC.
type FindMergeBaseResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// base is the commit ID of the best ancestor between the provided revisions.
	Base          string `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FindMergeBaseResponse) Reset() {
	*x = FindMergeBaseResponse{}
	mi := &file_repository_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FindMergeBaseResponse) ProtoMessage() {}

func (x *FindMergeBaseResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[27]
	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 FindMergeBaseResponse.ProtoReflect.Descriptor instead.
func (*FindMergeBaseResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{27}
}

func (x *FindMergeBaseResponse) GetBase() string {
	if x != nil {
		return x.Base
	}
	return ""
}

// CreateForkRequest is a request for the CreateFork RPC.
type CreateForkRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository that shall be created.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// source_repository is the repository that shall be forked.
	//
	// Note that the source repository is intentionally not marked as an additional repository that is
	// to be rewritten by Praefect. This is because Gitaly will use the source repository to perform a
	// gRPC call, which must use the original non-rewritten repository.
	SourceRepository *Repository `protobuf:"bytes,2,opt,name=source_repository,json=sourceRepository,proto3" json:"source_repository,omitempty"`
	// revision to create the fork from. If set, the resulting fork will only have a single branch
	// that matches the upstream revision. This revision will be the default branch of the repository.
	// This field should be set to the unqualified revision, not the full reference name.
	Revision      []byte `protobuf:"bytes,3,opt,name=revision,proto3" json:"revision,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateForkRequest) Reset() {
	*x = CreateForkRequest{}
	mi := &file_repository_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateForkRequest) ProtoMessage() {}

func (x *CreateForkRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[28]
	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 CreateForkRequest.ProtoReflect.Descriptor instead.
func (*CreateForkRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{28}
}

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

func (x *CreateForkRequest) GetSourceRepository() *Repository {
	if x != nil {
		return x.SourceRepository
	}
	return nil
}

func (x *CreateForkRequest) GetRevision() []byte {
	if x != nil {
		return x.Revision
	}
	return nil
}

// CreateForkResponse is a response for the CreateFork RPC.
type CreateForkResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateForkResponse) Reset() {
	*x = CreateForkResponse{}
	mi := &file_repository_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateForkResponse) ProtoMessage() {}

func (x *CreateForkResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[29]
	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 CreateForkResponse.ProtoReflect.Descriptor instead.
func (*CreateForkResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{29}
}

// CreateRepositoryFromURLRequest is a request for the CreateRepositoryFromURL RPC.
type CreateRepositoryFromURLRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository represents where the repo should be created. The storage_name and
	// relative_path attributes must be provided.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// url is the URL of the existing Git repository.
	Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	// http_authorization_header is the HTTP header which can be added to
	// the request in order to authenticate against the repository.
	HttpAuthorizationHeader string `protobuf:"bytes,4,opt,name=http_authorization_header,json=httpAuthorizationHeader,proto3" json:"http_authorization_header,omitempty"`
	// mirror defines whether to clone with `--mirror` flag or `--bare`. The default
	// value `false` will cause us to use `--bare`, which results in a clone that
	// contains only branches (`refs/heads/`) and tags (`refs/tags/`) of the remote
	// repository. If set to `true`, create a complete mirror-clone which maps all
	// remote references into the local repository.
	Mirror bool `protobuf:"varint,5,opt,name=mirror,proto3" json:"mirror,omitempty"`
	// resolved_address holds the resolved IP address of the remote_url. This is
	// used to avoid DNS rebinding by mapping the url to the resolved address.
	// Only IPv4 dotted decimal ("192.0.2.1"), IPv6 ("2001:db8::68"), or IPv4-mapped
	// IPv6 ("::ffff:192.0.2.1") forms are supported.
	// Works with HTTP/HTTPS/Git/SSH protocols.
	// Optional.
	ResolvedAddress string `protobuf:"bytes,6,opt,name=resolved_address,json=resolvedAddress,proto3" json:"resolved_address,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *CreateRepositoryFromURLRequest) Reset() {
	*x = CreateRepositoryFromURLRequest{}
	mi := &file_repository_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateRepositoryFromURLRequest) ProtoMessage() {}

func (x *CreateRepositoryFromURLRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[30]
	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 CreateRepositoryFromURLRequest.ProtoReflect.Descriptor instead.
func (*CreateRepositoryFromURLRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{30}
}

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

func (x *CreateRepositoryFromURLRequest) GetUrl() string {
	if x != nil {
		return x.Url
	}
	return ""
}

func (x *CreateRepositoryFromURLRequest) GetHttpAuthorizationHeader() string {
	if x != nil {
		return x.HttpAuthorizationHeader
	}
	return ""
}

func (x *CreateRepositoryFromURLRequest) GetMirror() bool {
	if x != nil {
		return x.Mirror
	}
	return false
}

func (x *CreateRepositoryFromURLRequest) GetResolvedAddress() string {
	if x != nil {
		return x.ResolvedAddress
	}
	return ""
}

// CreateRepositoryFromURLResponse is a response for the CreateRepositoryFromURL RPC.
type CreateRepositoryFromURLResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateRepositoryFromURLResponse) Reset() {
	*x = CreateRepositoryFromURLResponse{}
	mi := &file_repository_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateRepositoryFromURLResponse) ProtoMessage() {}

func (x *CreateRepositoryFromURLResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[31]
	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 CreateRepositoryFromURLResponse.ProtoReflect.Descriptor instead.
func (*CreateRepositoryFromURLResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{31}
}

// CreateRepositoryFromURLError is an error that will be returned by the CreateRepositoryFromURL RPC under specific error
// CreateRepositoryFromURLError.
type CreateRepositoryFromURLError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*CreateRepositoryFromURLError_RemoteNotFound
	Error         isCreateRepositoryFromURLError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateRepositoryFromURLError) Reset() {
	*x = CreateRepositoryFromURLError{}
	mi := &file_repository_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateRepositoryFromURLError) ProtoMessage() {}

func (x *CreateRepositoryFromURLError) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[32]
	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 CreateRepositoryFromURLError.ProtoReflect.Descriptor instead.
func (*CreateRepositoryFromURLError) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{32}
}

func (x *CreateRepositoryFromURLError) GetError() isCreateRepositoryFromURLError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *CreateRepositoryFromURLError) GetRemoteNotFound() *RemoteNotFoundError {
	if x != nil {
		if x, ok := x.Error.(*CreateRepositoryFromURLError_RemoteNotFound); ok {
			return x.RemoteNotFound
		}
	}
	return nil
}

type isCreateRepositoryFromURLError_Error interface {
	isCreateRepositoryFromURLError_Error()
}

type CreateRepositoryFromURLError_RemoteNotFound struct {
	// remote_not_found indicates that the remote repository was not found.
	RemoteNotFound *RemoteNotFoundError `protobuf:"bytes,1,opt,name=remote_not_found,json=remoteNotFound,proto3,oneof"`
}

func (*CreateRepositoryFromURLError_RemoteNotFound) isCreateRepositoryFromURLError_Error() {}

// CreateBundleRequest is a request for the CreateBundle RPC.
type CreateBundleRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to create a bundle from. The storage_name and
	// relative_path attributes must be provided.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateBundleRequest) Reset() {
	*x = CreateBundleRequest{}
	mi := &file_repository_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateBundleRequest) ProtoMessage() {}

func (x *CreateBundleRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[33]
	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 CreateBundleRequest.ProtoReflect.Descriptor instead.
func (*CreateBundleRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{33}
}

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

// CreateBundleResponse is a response for the CreateBundle RPC.
type CreateBundleResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data contains the content of the created bundle.
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateBundleResponse) Reset() {
	*x = CreateBundleResponse{}
	mi := &file_repository_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateBundleResponse) ProtoMessage() {}

func (x *CreateBundleResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[34]
	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 CreateBundleResponse.ProtoReflect.Descriptor instead.
func (*CreateBundleResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{34}
}

func (x *CreateBundleResponse) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

// CreateBundleFromRefListRequest is a request for the CreateBundleFromRefList RPC.
type CreateBundleFromRefListRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository that the bundle is created from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// patterns contains all patterns which shall be bundled. Patterns should be
	// in the format accepted by git-rev-list(1). Patterns which don't match any
	// reference will be silently ignored.
	Patterns      [][]byte `protobuf:"bytes,2,rep,name=patterns,proto3" json:"patterns,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateBundleFromRefListRequest) Reset() {
	*x = CreateBundleFromRefListRequest{}
	mi := &file_repository_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateBundleFromRefListRequest) ProtoMessage() {}

func (x *CreateBundleFromRefListRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[35]
	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 CreateBundleFromRefListRequest.ProtoReflect.Descriptor instead.
func (*CreateBundleFromRefListRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{35}
}

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

func (x *CreateBundleFromRefListRequest) GetPatterns() [][]byte {
	if x != nil {
		return x.Patterns
	}
	return nil
}

// CreateBundleFromRefListResponse is a response for the CreateBundleFromRefList RPC.
type CreateBundleFromRefListResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data contains the content of the created bundle.
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateBundleFromRefListResponse) Reset() {
	*x = CreateBundleFromRefListResponse{}
	mi := &file_repository_proto_msgTypes[36]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateBundleFromRefListResponse) ProtoMessage() {}

func (x *CreateBundleFromRefListResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[36]
	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 CreateBundleFromRefListResponse.ProtoReflect.Descriptor instead.
func (*CreateBundleFromRefListResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{36}
}

func (x *CreateBundleFromRefListResponse) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

// GenerateBundleURIRequest is a request for the GenerateBundleURI RPC.
type GenerateBundleURIRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository that the bundle is created for.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GenerateBundleURIRequest) Reset() {
	*x = GenerateBundleURIRequest{}
	mi := &file_repository_proto_msgTypes[37]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GenerateBundleURIRequest) ProtoMessage() {}

func (x *GenerateBundleURIRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[37]
	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 GenerateBundleURIRequest.ProtoReflect.Descriptor instead.
func (*GenerateBundleURIRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{37}
}

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

// GenerateBundleURIResponse is a response for the GenerateBundleURI RPC.
type GenerateBundleURIResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GenerateBundleURIResponse) Reset() {
	*x = GenerateBundleURIResponse{}
	mi := &file_repository_proto_msgTypes[38]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GenerateBundleURIResponse) ProtoMessage() {}

func (x *GenerateBundleURIResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[38]
	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 GenerateBundleURIResponse.ProtoReflect.Descriptor instead.
func (*GenerateBundleURIResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{38}
}

// GetConfigRequest is a request for the GetConfig RPC.
type GetConfigRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository from which the configuration should be read
	// from.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetConfigRequest) Reset() {
	*x = GetConfigRequest{}
	mi := &file_repository_proto_msgTypes[39]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetConfigRequest) ProtoMessage() {}

func (x *GetConfigRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[39]
	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 GetConfigRequest.ProtoReflect.Descriptor instead.
func (*GetConfigRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{39}
}

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

// GetConfigResponse is a response for the GetConfig RPC.
type GetConfigResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data contains contents of the gitconfig.
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetConfigResponse) Reset() {
	*x = GetConfigResponse{}
	mi := &file_repository_proto_msgTypes[40]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetConfigResponse) ProtoMessage() {}

func (x *GetConfigResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[40]
	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 GetConfigResponse.ProtoReflect.Descriptor instead.
func (*GetConfigResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{40}
}

func (x *GetConfigResponse) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

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

func (x *RestoreCustomHooksRequest) Reset() {
	*x = RestoreCustomHooksRequest{}
	mi := &file_repository_proto_msgTypes[41]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RestoreCustomHooksRequest) ProtoMessage() {}

func (x *RestoreCustomHooksRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[41]
	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 RestoreCustomHooksRequest.ProtoReflect.Descriptor instead.
func (*RestoreCustomHooksRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{41}
}

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

func (x *RestoreCustomHooksRequest) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

// SetCustomHooksRequest is a request for the SetCustomHooks RPC.
type SetCustomHooksRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to set the custom hooks in. The storage_name and relative_path
	// attributes must be provided. The repository can be omitted in subsequent requests.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// data is a tarball containing a `custom_hooks` directory.
	Data          []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SetCustomHooksRequest) Reset() {
	*x = SetCustomHooksRequest{}
	mi := &file_repository_proto_msgTypes[42]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SetCustomHooksRequest) ProtoMessage() {}

func (x *SetCustomHooksRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[42]
	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 SetCustomHooksRequest.ProtoReflect.Descriptor instead.
func (*SetCustomHooksRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{42}
}

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

func (x *SetCustomHooksRequest) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

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

func (x *RestoreCustomHooksResponse) Reset() {
	*x = RestoreCustomHooksResponse{}
	mi := &file_repository_proto_msgTypes[43]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RestoreCustomHooksResponse) ProtoMessage() {}

func (x *RestoreCustomHooksResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[43]
	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 RestoreCustomHooksResponse.ProtoReflect.Descriptor instead.
func (*RestoreCustomHooksResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{43}
}

// SetCustomHooksResponse is a response for the SetCustomHooks RPC.
type SetCustomHooksResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SetCustomHooksResponse) Reset() {
	*x = SetCustomHooksResponse{}
	mi := &file_repository_proto_msgTypes[44]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SetCustomHooksResponse) ProtoMessage() {}

func (x *SetCustomHooksResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[44]
	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 SetCustomHooksResponse.ProtoReflect.Descriptor instead.
func (*SetCustomHooksResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{44}
}

// BackupCustomHooksRequest ...
type BackupCustomHooksRequest 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 *BackupCustomHooksRequest) Reset() {
	*x = BackupCustomHooksRequest{}
	mi := &file_repository_proto_msgTypes[45]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BackupCustomHooksRequest) ProtoMessage() {}

func (x *BackupCustomHooksRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[45]
	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 BackupCustomHooksRequest.ProtoReflect.Descriptor instead.
func (*BackupCustomHooksRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{45}
}

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

// GetCustomHooksRequest is a request for the GetCustomHooks RPC.
type GetCustomHooksRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to retrieve custom hooks from. The storage_name and relative_path
	// attributes must be provided.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetCustomHooksRequest) Reset() {
	*x = GetCustomHooksRequest{}
	mi := &file_repository_proto_msgTypes[46]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetCustomHooksRequest) ProtoMessage() {}

func (x *GetCustomHooksRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[46]
	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 GetCustomHooksRequest.ProtoReflect.Descriptor instead.
func (*GetCustomHooksRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{46}
}

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

// BackupCustomHooksResponse ...
type BackupCustomHooksResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data ...
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BackupCustomHooksResponse) Reset() {
	*x = BackupCustomHooksResponse{}
	mi := &file_repository_proto_msgTypes[47]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BackupCustomHooksResponse) ProtoMessage() {}

func (x *BackupCustomHooksResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[47]
	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 BackupCustomHooksResponse.ProtoReflect.Descriptor instead.
func (*BackupCustomHooksResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{47}
}

func (x *BackupCustomHooksResponse) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

// GetCustomHooksResponse is a response for the GetCustomHooks RPC.
type GetCustomHooksResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data is the tarball containing the `custom_hooks` directory.
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetCustomHooksResponse) Reset() {
	*x = GetCustomHooksResponse{}
	mi := &file_repository_proto_msgTypes[48]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetCustomHooksResponse) ProtoMessage() {}

func (x *GetCustomHooksResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[48]
	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 GetCustomHooksResponse.ProtoReflect.Descriptor instead.
func (*GetCustomHooksResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{48}
}

func (x *GetCustomHooksResponse) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

// CreateRepositoryFromBundleRequest is a request for the CreateRepositoryFromBundle RPC.
type CreateRepositoryFromBundleRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to be created from the Git bundle. Repository should only be
	// present in the first message of the stream.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// data contains bytes of the Git bundle file being streamed.
	Data          []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateRepositoryFromBundleRequest) Reset() {
	*x = CreateRepositoryFromBundleRequest{}
	mi := &file_repository_proto_msgTypes[49]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateRepositoryFromBundleRequest) ProtoMessage() {}

func (x *CreateRepositoryFromBundleRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[49]
	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 CreateRepositoryFromBundleRequest.ProtoReflect.Descriptor instead.
func (*CreateRepositoryFromBundleRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{49}
}

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

func (x *CreateRepositoryFromBundleRequest) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

// CreateRepositoryFromBundleResponse is a response for the CreateRepositoryFromBundle RPC.
type CreateRepositoryFromBundleResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateRepositoryFromBundleResponse) Reset() {
	*x = CreateRepositoryFromBundleResponse{}
	mi := &file_repository_proto_msgTypes[50]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateRepositoryFromBundleResponse) ProtoMessage() {}

func (x *CreateRepositoryFromBundleResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[50]
	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 CreateRepositoryFromBundleResponse.ProtoReflect.Descriptor instead.
func (*CreateRepositoryFromBundleResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{50}
}

// FindLicenseRequest asks to detect the license for the given repository.
type FindLicenseRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is repository where to detect the license.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FindLicenseRequest) Reset() {
	*x = FindLicenseRequest{}
	mi := &file_repository_proto_msgTypes[51]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FindLicenseRequest) ProtoMessage() {}

func (x *FindLicenseRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[51]
	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 FindLicenseRequest.ProtoReflect.Descriptor instead.
func (*FindLicenseRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{51}
}

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

// FindLicenseResponse contains the result of detecting the license used in the repository.
// If there is nothing that looks like a license file, the empty response is returned.
// If there is something that looks like a license, but that license can't be found in the
// list of known licenses, we return a pre-defined response with "Other" license.
type FindLicenseResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// license_short_name is the license unique SPDX identifier or a short name.
	// It is always returned lower-cased.
	LicenseShortName string `protobuf:"bytes,1,opt,name=license_short_name,json=licenseShortName,proto3" json:"license_short_name,omitempty"`
	// license_name is the license full name.
	LicenseName string `protobuf:"bytes,2,opt,name=license_name,json=licenseName,proto3" json:"license_name,omitempty"`
	// license_url is a URL to the license on the internet.
	LicenseUrl string `protobuf:"bytes,3,opt,name=license_url,json=licenseUrl,proto3" json:"license_url,omitempty"`
	// license_path is a path to the file that contains the text of the license.
	// When a LICENSE file is found containing the filename of another file,
	// that filename will be returned, for example "mit.txt".
	LicensePath string `protobuf:"bytes,4,opt,name=license_path,json=licensePath,proto3" json:"license_path,omitempty"`
	// license_nickname is a shortened full name for better readability.
	// It exists only for a small set of licenses and an empty value is returned in most cases.
	LicenseNickname string `protobuf:"bytes,5,opt,name=license_nickname,json=licenseNickname,proto3" json:"license_nickname,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *FindLicenseResponse) Reset() {
	*x = FindLicenseResponse{}
	mi := &file_repository_proto_msgTypes[52]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FindLicenseResponse) ProtoMessage() {}

func (x *FindLicenseResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[52]
	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 FindLicenseResponse.ProtoReflect.Descriptor instead.
func (*FindLicenseResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{52}
}

func (x *FindLicenseResponse) GetLicenseShortName() string {
	if x != nil {
		return x.LicenseShortName
	}
	return ""
}

func (x *FindLicenseResponse) GetLicenseName() string {
	if x != nil {
		return x.LicenseName
	}
	return ""
}

func (x *FindLicenseResponse) GetLicenseUrl() string {
	if x != nil {
		return x.LicenseUrl
	}
	return ""
}

func (x *FindLicenseResponse) GetLicensePath() string {
	if x != nil {
		return x.LicensePath
	}
	return ""
}

func (x *FindLicenseResponse) GetLicenseNickname() string {
	if x != nil {
		return x.LicenseNickname
	}
	return ""
}

// GetInfoAttributesRequest ...
type GetInfoAttributesRequest 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 *GetInfoAttributesRequest) Reset() {
	*x = GetInfoAttributesRequest{}
	mi := &file_repository_proto_msgTypes[53]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetInfoAttributesRequest) ProtoMessage() {}

func (x *GetInfoAttributesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[53]
	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 GetInfoAttributesRequest.ProtoReflect.Descriptor instead.
func (*GetInfoAttributesRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{53}
}

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

// GetInfoAttributesResponse ...
type GetInfoAttributesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// attributes ...
	Attributes    []byte `protobuf:"bytes,1,opt,name=attributes,proto3" json:"attributes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetInfoAttributesResponse) Reset() {
	*x = GetInfoAttributesResponse{}
	mi := &file_repository_proto_msgTypes[54]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetInfoAttributesResponse) ProtoMessage() {}

func (x *GetInfoAttributesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[54]
	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 GetInfoAttributesResponse.ProtoReflect.Descriptor instead.
func (*GetInfoAttributesResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{54}
}

func (x *GetInfoAttributesResponse) GetAttributes() []byte {
	if x != nil {
		return x.Attributes
	}
	return nil
}

// CalculateChecksumRequest is a request for the CalculateChecksum RPC.
type CalculateChecksumRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to calculate the checksum for. The storage_name and relative_path
	// attributes must be provided.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CalculateChecksumRequest) Reset() {
	*x = CalculateChecksumRequest{}
	mi := &file_repository_proto_msgTypes[55]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CalculateChecksumRequest) ProtoMessage() {}

func (x *CalculateChecksumRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[55]
	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 CalculateChecksumRequest.ProtoReflect.Descriptor instead.
func (*CalculateChecksumRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{55}
}

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

// CalculateChecksumResponse is a response for the CalculateChecksum RPC.
type CalculateChecksumResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// checksum is the checksum of the repo's references.
	Checksum      string `protobuf:"bytes,1,opt,name=checksum,proto3" json:"checksum,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CalculateChecksumResponse) Reset() {
	*x = CalculateChecksumResponse{}
	mi := &file_repository_proto_msgTypes[56]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CalculateChecksumResponse) ProtoMessage() {}

func (x *CalculateChecksumResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[56]
	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 CalculateChecksumResponse.ProtoReflect.Descriptor instead.
func (*CalculateChecksumResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{56}
}

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

// GetSnapshotRequest is a request for the GetSnapshot RPC.
type GetSnapshotRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to snapshot. The storage_name and relative_path
	// attributes must be provided.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetSnapshotRequest) Reset() {
	*x = GetSnapshotRequest{}
	mi := &file_repository_proto_msgTypes[57]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetSnapshotRequest) ProtoMessage() {}

func (x *GetSnapshotRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[57]
	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 GetSnapshotRequest.ProtoReflect.Descriptor instead.
func (*GetSnapshotRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{57}
}

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

// GetSnapshotResponse is a response for the GetSnapshot RPC.
type GetSnapshotResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data is the snapshot of the repo compressed as a TAR archive.
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetSnapshotResponse) Reset() {
	*x = GetSnapshotResponse{}
	mi := &file_repository_proto_msgTypes[58]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetSnapshotResponse) ProtoMessage() {}

func (x *GetSnapshotResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[58]
	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 GetSnapshotResponse.ProtoReflect.Descriptor instead.
func (*GetSnapshotResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{58}
}

func (x *GetSnapshotResponse) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

// CreateRepositoryFromSnapshotRequest is a request for the CreateRepositoryFromSnapshot RPC.
type CreateRepositoryFromSnapshotRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository indicates where the new repo should be created. The storage_name and
	// relative_path attributes must be provided.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// http_url is the full URL of the location of the snapshot TAR.
	HttpUrl string `protobuf:"bytes,2,opt,name=http_url,json=httpUrl,proto3" json:"http_url,omitempty"`
	// http_auth is the value of the Authorization header to send to http_url.
	HttpAuth string `protobuf:"bytes,3,opt,name=http_auth,json=httpAuth,proto3" json:"http_auth,omitempty"`
	// resolved_address holds the resolved IP address of the remote_url. This is
	// used to avoid DNS rebinding by mapping the url to the resolved address.
	// Only IPv4 dotted decimal ("192.0.2.1"), IPv6 ("2001:db8::68"), or IPv4-mapped
	// IPv6 ("::ffff:192.0.2.1") forms are supported.
	// Works with HTTP/HTTPS protocols.
	// Optional.
	ResolvedAddress string `protobuf:"bytes,5,opt,name=resolved_address,json=resolvedAddress,proto3" json:"resolved_address,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *CreateRepositoryFromSnapshotRequest) Reset() {
	*x = CreateRepositoryFromSnapshotRequest{}
	mi := &file_repository_proto_msgTypes[59]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateRepositoryFromSnapshotRequest) ProtoMessage() {}

func (x *CreateRepositoryFromSnapshotRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[59]
	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 CreateRepositoryFromSnapshotRequest.ProtoReflect.Descriptor instead.
func (*CreateRepositoryFromSnapshotRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{59}
}

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

func (x *CreateRepositoryFromSnapshotRequest) GetHttpUrl() string {
	if x != nil {
		return x.HttpUrl
	}
	return ""
}

func (x *CreateRepositoryFromSnapshotRequest) GetHttpAuth() string {
	if x != nil {
		return x.HttpAuth
	}
	return ""
}

func (x *CreateRepositoryFromSnapshotRequest) GetResolvedAddress() string {
	if x != nil {
		return x.ResolvedAddress
	}
	return ""
}

// CreateRepositoryFromSnapshotResponse is a response for the CreateRepositoryFromSnapshot RPC.
type CreateRepositoryFromSnapshotResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateRepositoryFromSnapshotResponse) Reset() {
	*x = CreateRepositoryFromSnapshotResponse{}
	mi := &file_repository_proto_msgTypes[60]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CreateRepositoryFromSnapshotResponse) ProtoMessage() {}

func (x *CreateRepositoryFromSnapshotResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[60]
	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 CreateRepositoryFromSnapshotResponse.ProtoReflect.Descriptor instead.
func (*CreateRepositoryFromSnapshotResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{60}
}

// GetRawChangesRequest is a request for the GetRawChanges RPC.
type GetRawChangesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to run the diff in. The storage_name and
	// relative_path attributes must be provided.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// from_revision is the Git revision to start the diff at.
	FromRevision string `protobuf:"bytes,2,opt,name=from_revision,json=fromRevision,proto3" json:"from_revision,omitempty"`
	// to_revision is the Git revision to end the diff at.
	ToRevision    string `protobuf:"bytes,3,opt,name=to_revision,json=toRevision,proto3" json:"to_revision,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetRawChangesRequest) Reset() {
	*x = GetRawChangesRequest{}
	mi := &file_repository_proto_msgTypes[61]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetRawChangesRequest) ProtoMessage() {}

func (x *GetRawChangesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[61]
	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 GetRawChangesRequest.ProtoReflect.Descriptor instead.
func (*GetRawChangesRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{61}
}

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

func (x *GetRawChangesRequest) GetFromRevision() string {
	if x != nil {
		return x.FromRevision
	}
	return ""
}

func (x *GetRawChangesRequest) GetToRevision() string {
	if x != nil {
		return x.ToRevision
	}
	return ""
}

// GetRawChangesResponse is a response for the GetRawChanges RPC.
type GetRawChangesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// raw_changes is the set of changes between the two revisions.
	RawChanges    []*GetRawChangesResponse_RawChange `protobuf:"bytes,1,rep,name=raw_changes,json=rawChanges,proto3" json:"raw_changes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetRawChangesResponse) Reset() {
	*x = GetRawChangesResponse{}
	mi := &file_repository_proto_msgTypes[62]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetRawChangesResponse) ProtoMessage() {}

func (x *GetRawChangesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[62]
	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 GetRawChangesResponse.ProtoReflect.Descriptor instead.
func (*GetRawChangesResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{62}
}

func (x *GetRawChangesResponse) GetRawChanges() []*GetRawChangesResponse_RawChange {
	if x != nil {
		return x.RawChanges
	}
	return nil
}

// SearchFilesByNameRequest is a request for the SearchFilesByName RPC.
type SearchFilesByNameRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to execute the search in. The storage_name and
	// relative_path attributes must be provided.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// query is the search query.
	Query string `protobuf:"bytes,2,opt,name=query,proto3" json:"query,omitempty"`
	// ref is the Git reference whose tree should be searched.
	Ref []byte `protobuf:"bytes,3,opt,name=ref,proto3" json:"ref,omitempty"`
	// filter is a regular expression used to filter the result set before it is
	// transmitted. It is parsed using Go's `regexp` package, which is closely related
	// to PCRE, excluding backreferences, atomic/possesive operators, and some other
	// features. It has a maximum length of 1000 bytes.
	Filter string `protobuf:"bytes,4,opt,name=filter,proto3" json:"filter,omitempty"`
	// limit the number of returned files. Gitaly does not enforce a limit by default.
	// Clients should always set a value for this field. limit = 0 means unlimited files.
	Limit uint32 `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"`
	// offset says to skip that many files before beginning to return files.
	// offset = 0 means starting to return files from beginning.
	Offset        uint32 `protobuf:"varint,6,opt,name=offset,proto3" json:"offset,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SearchFilesByNameRequest) Reset() {
	*x = SearchFilesByNameRequest{}
	mi := &file_repository_proto_msgTypes[63]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SearchFilesByNameRequest) ProtoMessage() {}

func (x *SearchFilesByNameRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[63]
	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 SearchFilesByNameRequest.ProtoReflect.Descriptor instead.
func (*SearchFilesByNameRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{63}
}

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

func (x *SearchFilesByNameRequest) GetQuery() string {
	if x != nil {
		return x.Query
	}
	return ""
}

func (x *SearchFilesByNameRequest) GetRef() []byte {
	if x != nil {
		return x.Ref
	}
	return nil
}

func (x *SearchFilesByNameRequest) GetFilter() string {
	if x != nil {
		return x.Filter
	}
	return ""
}

func (x *SearchFilesByNameRequest) GetLimit() uint32 {
	if x != nil {
		return x.Limit
	}
	return 0
}

func (x *SearchFilesByNameRequest) GetOffset() uint32 {
	if x != nil {
		return x.Offset
	}
	return 0
}

// SearchFilesByNameResponse is a response for the SearchFilesByName RPC.
type SearchFilesByNameResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// files contains the paths of files that have been found to match the query.
	Files         [][]byte `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SearchFilesByNameResponse) Reset() {
	*x = SearchFilesByNameResponse{}
	mi := &file_repository_proto_msgTypes[64]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SearchFilesByNameResponse) ProtoMessage() {}

func (x *SearchFilesByNameResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[64]
	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 SearchFilesByNameResponse.ProtoReflect.Descriptor instead.
func (*SearchFilesByNameResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{64}
}

func (x *SearchFilesByNameResponse) GetFiles() [][]byte {
	if x != nil {
		return x.Files
	}
	return nil
}

// SearchFilesByContentRequest is a request for the SearchFilesByContent RPC.
type SearchFilesByContentRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to search. The storage_name and relative_path attributes must be provided.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// query is the grep pattern to use. Queries are case-insensitive and are compatible
	// with Perl regexp syntax.
	Query string `protobuf:"bytes,2,opt,name=query,proto3" json:"query,omitempty"`
	// ref is the reference to limit the search scope by, for example a commit or
	// branch name.
	Ref           []byte `protobuf:"bytes,3,opt,name=ref,proto3" json:"ref,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SearchFilesByContentRequest) Reset() {
	*x = SearchFilesByContentRequest{}
	mi := &file_repository_proto_msgTypes[65]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SearchFilesByContentRequest) ProtoMessage() {}

func (x *SearchFilesByContentRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[65]
	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 SearchFilesByContentRequest.ProtoReflect.Descriptor instead.
func (*SearchFilesByContentRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{65}
}

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

func (x *SearchFilesByContentRequest) GetQuery() string {
	if x != nil {
		return x.Query
	}
	return ""
}

func (x *SearchFilesByContentRequest) GetRef() []byte {
	if x != nil {
		return x.Ref
	}
	return nil
}

// SearchFilesByContentResponse is a response for the SearchFilesByContent RPC.
type SearchFilesByContentResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// match_data contains the results of the search. Data is streamed in chunks, where
	// each chunk is an individual result.
	MatchData []byte `protobuf:"bytes,2,opt,name=match_data,json=matchData,proto3" json:"match_data,omitempty"`
	// end_of_match indicates the end of an individual match results. Additional results
	// may follow in subsequent gRPC messages.
	EndOfMatch    bool `protobuf:"varint,3,opt,name=end_of_match,json=endOfMatch,proto3" json:"end_of_match,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SearchFilesByContentResponse) Reset() {
	*x = SearchFilesByContentResponse{}
	mi := &file_repository_proto_msgTypes[66]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SearchFilesByContentResponse) ProtoMessage() {}

func (x *SearchFilesByContentResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[66]
	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 SearchFilesByContentResponse.ProtoReflect.Descriptor instead.
func (*SearchFilesByContentResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{66}
}

func (x *SearchFilesByContentResponse) GetMatchData() []byte {
	if x != nil {
		return x.MatchData
	}
	return nil
}

func (x *SearchFilesByContentResponse) GetEndOfMatch() bool {
	if x != nil {
		return x.EndOfMatch
	}
	return false
}

// Remote represents a git remote repository.
type Remote struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// url is the URL of the remote repository.
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	// http_authorization_header is the HTTP header which should be added to
	// the request in order to authenticate against the repository.
	HttpAuthorizationHeader string `protobuf:"bytes,3,opt,name=http_authorization_header,json=httpAuthorizationHeader,proto3" json:"http_authorization_header,omitempty"`
	// mirror_refmaps contains the refspecs which shall be fetched. Some special
	// refspecs are accepted:
	//
	//   - "all_refs" gets translated to "+refs/*:refs/*", which mirrors all
	//     references of the source repository.
	//   - "heads" gets translated to "+refs/heads/*:refs/heads/*", which mirrors
	//     all branches of the source repository.
	//   - "tags" gets translated to "+refs/tags/*:refs/tags/*", which mirrors all
	//     tags of the source repository.
	//
	// If no refspecs are given, this defaults to "all_refs".
	MirrorRefmaps []string `protobuf:"bytes,4,rep,name=mirror_refmaps,json=mirrorRefmaps,proto3" json:"mirror_refmaps,omitempty"`
	// resolved_address holds the resolved IP address of the remote_url. This is
	// used to avoid DNS rebinding by mapping the url to the resolved address.
	// Only IPv4 dotted decimal ("192.0.2.1"), IPv6 ("2001:db8::68"), or IPv4-mapped
	// IPv6 ("::ffff:192.0.2.1") forms are supported.
	// Works with HTTP/HTTPS/Git/SSH protocols.
	// Optional.
	ResolvedAddress string `protobuf:"bytes,6,opt,name=resolved_address,json=resolvedAddress,proto3" json:"resolved_address,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *Remote) Reset() {
	*x = Remote{}
	mi := &file_repository_proto_msgTypes[67]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Remote) ProtoMessage() {}

func (x *Remote) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[67]
	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 Remote.ProtoReflect.Descriptor instead.
func (*Remote) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{67}
}

func (x *Remote) GetUrl() string {
	if x != nil {
		return x.Url
	}
	return ""
}

func (x *Remote) GetHttpAuthorizationHeader() string {
	if x != nil {
		return x.HttpAuthorizationHeader
	}
	return ""
}

func (x *Remote) GetMirrorRefmaps() []string {
	if x != nil {
		return x.MirrorRefmaps
	}
	return nil
}

func (x *Remote) GetResolvedAddress() string {
	if x != nil {
		return x.ResolvedAddress
	}
	return ""
}

// GetObjectDirectorySizeRequest is a request for the GetObjectDirectorySize RPC.
type GetObjectDirectorySizeRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to query. The storage_name and relative_path attributes
	// must be provided.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetObjectDirectorySizeRequest) Reset() {
	*x = GetObjectDirectorySizeRequest{}
	mi := &file_repository_proto_msgTypes[68]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetObjectDirectorySizeRequest) ProtoMessage() {}

func (x *GetObjectDirectorySizeRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[68]
	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 GetObjectDirectorySizeRequest.ProtoReflect.Descriptor instead.
func (*GetObjectDirectorySizeRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{68}
}

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

// GetObjectDirectorySizeResponse is a response for the GetObjectDirectorySize RPC.
type GetObjectDirectorySizeResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// size is the object directory size in kibibytes.
	Size          int64 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetObjectDirectorySizeResponse) Reset() {
	*x = GetObjectDirectorySizeResponse{}
	mi := &file_repository_proto_msgTypes[69]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetObjectDirectorySizeResponse) ProtoMessage() {}

func (x *GetObjectDirectorySizeResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[69]
	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 GetObjectDirectorySizeResponse.ProtoReflect.Descriptor instead.
func (*GetObjectDirectorySizeResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{69}
}

func (x *GetObjectDirectorySizeResponse) GetSize() int64 {
	if x != nil {
		return x.Size
	}
	return 0
}

// RemoveRepositoryRequest is a request for the RemoveRepository RPC.
type RemoveRepositoryRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to remove. The storage_name and relative_path attributes
	// must be provided.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RemoveRepositoryRequest) Reset() {
	*x = RemoveRepositoryRequest{}
	mi := &file_repository_proto_msgTypes[70]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RemoveRepositoryRequest) ProtoMessage() {}

func (x *RemoveRepositoryRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[70]
	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 RemoveRepositoryRequest.ProtoReflect.Descriptor instead.
func (*RemoveRepositoryRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{70}
}

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

// RemoveRepositoryResponse is a response for the RemoveRepository RPC.
type RemoveRepositoryResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RemoveRepositoryResponse) Reset() {
	*x = RemoveRepositoryResponse{}
	mi := &file_repository_proto_msgTypes[71]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RemoveRepositoryResponse) ProtoMessage() {}

func (x *RemoveRepositoryResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[71]
	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 RemoveRepositoryResponse.ProtoReflect.Descriptor instead.
func (*RemoveRepositoryResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{71}
}

// ReplicateRepositoryRequest is a request for the ReplicateRepository RPC.
type ReplicateRepositoryRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the target repository that the RPC replicates to.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// source is the source repository that the RPC replicates from. This repository can sit on a
	// different storage node. The information for how to connect to this storage node needs to be
	// injected into the gRPC context by the caller by setting the `gitaly-servers` metadata.
	Source        *Repository `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ReplicateRepositoryRequest) Reset() {
	*x = ReplicateRepositoryRequest{}
	mi := &file_repository_proto_msgTypes[72]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ReplicateRepositoryRequest) ProtoMessage() {}

func (x *ReplicateRepositoryRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[72]
	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 ReplicateRepositoryRequest.ProtoReflect.Descriptor instead.
func (*ReplicateRepositoryRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{72}
}

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

func (x *ReplicateRepositoryRequest) GetSource() *Repository {
	if x != nil {
		return x.Source
	}
	return nil
}

// ReplicateRepositoryResponse is a response for the ReplicateRepository RPC.
type ReplicateRepositoryResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ReplicateRepositoryResponse) Reset() {
	*x = ReplicateRepositoryResponse{}
	mi := &file_repository_proto_msgTypes[73]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ReplicateRepositoryResponse) ProtoMessage() {}

func (x *ReplicateRepositoryResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[73]
	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 ReplicateRepositoryResponse.ProtoReflect.Descriptor instead.
func (*ReplicateRepositoryResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{73}
}

// OptimizeRepositoryRequest is a request for the OptimizeRepository RPC.
type OptimizeRepositoryRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository that should be optimized.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// strategy is the strategy that determines which parts of the repository shall be optimized.
	Strategy      OptimizeRepositoryRequest_Strategy `protobuf:"varint,2,opt,name=strategy,proto3,enum=gitaly.OptimizeRepositoryRequest_Strategy" json:"strategy,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *OptimizeRepositoryRequest) Reset() {
	*x = OptimizeRepositoryRequest{}
	mi := &file_repository_proto_msgTypes[74]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OptimizeRepositoryRequest) ProtoMessage() {}

func (x *OptimizeRepositoryRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[74]
	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 OptimizeRepositoryRequest.ProtoReflect.Descriptor instead.
func (*OptimizeRepositoryRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{74}
}

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

func (x *OptimizeRepositoryRequest) GetStrategy() OptimizeRepositoryRequest_Strategy {
	if x != nil {
		return x.Strategy
	}
	return OptimizeRepositoryRequest_STRATEGY_UNSPECIFIED
}

// OptimizeRepositoryResponse is a response for the OptimizeRepository RPC.
type OptimizeRepositoryResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *OptimizeRepositoryResponse) Reset() {
	*x = OptimizeRepositoryResponse{}
	mi := &file_repository_proto_msgTypes[75]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OptimizeRepositoryResponse) ProtoMessage() {}

func (x *OptimizeRepositoryResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[75]
	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 OptimizeRepositoryResponse.ProtoReflect.Descriptor instead.
func (*OptimizeRepositoryResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{75}
}

// PruneUnreachableObjectsRequest is a request for the PruneUnreachableObjects
// RPC call.
type PruneUnreachableObjectsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repo to prune. The storage_name and relative_path
	// attributes must be provided.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PruneUnreachableObjectsRequest) Reset() {
	*x = PruneUnreachableObjectsRequest{}
	mi := &file_repository_proto_msgTypes[76]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PruneUnreachableObjectsRequest) ProtoMessage() {}

func (x *PruneUnreachableObjectsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[76]
	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 PruneUnreachableObjectsRequest.ProtoReflect.Descriptor instead.
func (*PruneUnreachableObjectsRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{76}
}

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

// PruneUnreachableObjectsResponse is a response for the
// PruneUnreachableObjects RPC call.
type PruneUnreachableObjectsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PruneUnreachableObjectsResponse) Reset() {
	*x = PruneUnreachableObjectsResponse{}
	mi := &file_repository_proto_msgTypes[77]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PruneUnreachableObjectsResponse) ProtoMessage() {}

func (x *PruneUnreachableObjectsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[77]
	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 PruneUnreachableObjectsResponse.ProtoReflect.Descriptor instead.
func (*PruneUnreachableObjectsResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{77}
}

// BackupRepositoryRequest is a request for the BackupRepository RPC.
type BackupRepositoryRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to be backed up.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// vanity_repository is used to determine the backup path.
	VanityRepository *Repository `protobuf:"bytes,2,opt,name=vanity_repository,json=vanityRepository,proto3" json:"vanity_repository,omitempty"`
	// backup_id is the label used to identify this backup when restoring.
	BackupId string `protobuf:"bytes,3,opt,name=backup_id,json=backupId,proto3" json:"backup_id,omitempty"`
	// incremental controls whether an incremental backup should be performed. An incremental
	// backup will attempt to locate a previous backup of this repository to base itself off.
	Incremental bool `protobuf:"varint,4,opt,name=incremental,proto3" json:"incremental,omitempty"`
	// latest_backup_id is populated when incremental is true to indicate which backup the
	// newly created incremental backup should be based on.
	LatestBackupId string `protobuf:"bytes,5,opt,name=latest_backup_id,json=latestBackupId,proto3" json:"latest_backup_id,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *BackupRepositoryRequest) Reset() {
	*x = BackupRepositoryRequest{}
	mi := &file_repository_proto_msgTypes[78]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BackupRepositoryRequest) ProtoMessage() {}

func (x *BackupRepositoryRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[78]
	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 BackupRepositoryRequest.ProtoReflect.Descriptor instead.
func (*BackupRepositoryRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{78}
}

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

func (x *BackupRepositoryRequest) GetVanityRepository() *Repository {
	if x != nil {
		return x.VanityRepository
	}
	return nil
}

func (x *BackupRepositoryRequest) GetBackupId() string {
	if x != nil {
		return x.BackupId
	}
	return ""
}

func (x *BackupRepositoryRequest) GetIncremental() bool {
	if x != nil {
		return x.Incremental
	}
	return false
}

func (x *BackupRepositoryRequest) GetLatestBackupId() string {
	if x != nil {
		return x.LatestBackupId
	}
	return ""
}

// BackupRepositoryResponse is a response for the BackupRepository RPC.
type BackupRepositoryResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BackupRepositoryResponse) Reset() {
	*x = BackupRepositoryResponse{}
	mi := &file_repository_proto_msgTypes[79]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BackupRepositoryResponse) ProtoMessage() {}

func (x *BackupRepositoryResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[79]
	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 BackupRepositoryResponse.ProtoReflect.Descriptor instead.
func (*BackupRepositoryResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{79}
}

// RestoreRepositoryRequest is a request for the RestoreRepository RPC.
type RestoreRepositoryRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to be restored.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// vanity_repository is used to determine the backup path.
	VanityRepository *Repository `protobuf:"bytes,2,opt,name=vanity_repository,json=vanityRepository,proto3" json:"vanity_repository,omitempty"`
	// backup_id is the label used to identify the backup to restore from. If
	// empty, the latest available backup is used.
	BackupId string `protobuf:"bytes,3,opt,name=backup_id,json=backupId,proto3" json:"backup_id,omitempty"`
	// always_create will force the repository to exist even if no bundle is
	// found. See https://gitlab.com/gitlab-org/gitlab/-/issues/357044
	AlwaysCreate bool `protobuf:"varint,4,opt,name=always_create,json=alwaysCreate,proto3" json:"always_create,omitempty"`
	// use_latest indicates if latest backup should be used if backup_id is not
	// provided.
	UseLatest     bool `protobuf:"varint,5,opt,name=use_latest,json=useLatest,proto3" json:"use_latest,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RestoreRepositoryRequest) Reset() {
	*x = RestoreRepositoryRequest{}
	mi := &file_repository_proto_msgTypes[80]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RestoreRepositoryRequest) ProtoMessage() {}

func (x *RestoreRepositoryRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[80]
	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 RestoreRepositoryRequest.ProtoReflect.Descriptor instead.
func (*RestoreRepositoryRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{80}
}

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

func (x *RestoreRepositoryRequest) GetVanityRepository() *Repository {
	if x != nil {
		return x.VanityRepository
	}
	return nil
}

func (x *RestoreRepositoryRequest) GetBackupId() string {
	if x != nil {
		return x.BackupId
	}
	return ""
}

func (x *RestoreRepositoryRequest) GetAlwaysCreate() bool {
	if x != nil {
		return x.AlwaysCreate
	}
	return false
}

func (x *RestoreRepositoryRequest) GetUseLatest() bool {
	if x != nil {
		return x.UseLatest
	}
	return false
}

// RestoreRepositoryResponse is a response for the RestoreRepository RPC.
type RestoreRepositoryResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RestoreRepositoryResponse) Reset() {
	*x = RestoreRepositoryResponse{}
	mi := &file_repository_proto_msgTypes[81]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RestoreRepositoryResponse) ProtoMessage() {}

func (x *RestoreRepositoryResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[81]
	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 RestoreRepositoryResponse.ProtoReflect.Descriptor instead.
func (*RestoreRepositoryResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{81}
}

// GetFileAttributesRequest is a request for the GetFileAttributes RPC.
type GetFileAttributesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository the file attributes shall be computed in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is the revision where the file attributes shall be computed in.
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// attributes are the attributes that will be queried for.
	Attributes []string `protobuf:"bytes,3,rep,name=attributes,proto3" json:"attributes,omitempty"`
	// paths are the file paths that will be queried for.
	Paths         []string `protobuf:"bytes,4,rep,name=paths,proto3" json:"paths,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetFileAttributesRequest) Reset() {
	*x = GetFileAttributesRequest{}
	mi := &file_repository_proto_msgTypes[82]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetFileAttributesRequest) ProtoMessage() {}

func (x *GetFileAttributesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[82]
	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 GetFileAttributesRequest.ProtoReflect.Descriptor instead.
func (*GetFileAttributesRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{82}
}

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

func (x *GetFileAttributesRequest) GetRevision() []byte {
	if x != nil {
		return x.Revision
	}
	return nil
}

func (x *GetFileAttributesRequest) GetAttributes() []string {
	if x != nil {
		return x.Attributes
	}
	return nil
}

func (x *GetFileAttributesRequest) GetPaths() []string {
	if x != nil {
		return x.Paths
	}
	return nil
}

// GetFileAttributesResponse is a response for the GetFileAttributes RPC.
type GetFileAttributesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// attribute_infos is the list of attributes that matches the given GetFileAttributesRequest
	AttributeInfos []*GetFileAttributesResponse_AttributeInfo `protobuf:"bytes,1,rep,name=attribute_infos,json=attributeInfos,proto3" json:"attribute_infos,omitempty"` // protolint:disable:this REPEATED_FIELD_NAMES_PLURALIZED
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *GetFileAttributesResponse) Reset() {
	*x = GetFileAttributesResponse{}
	mi := &file_repository_proto_msgTypes[83]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetFileAttributesResponse) ProtoMessage() {}

func (x *GetFileAttributesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[83]
	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 GetFileAttributesResponse.ProtoReflect.Descriptor instead.
func (*GetFileAttributesResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{83}
}

func (x *GetFileAttributesResponse) GetAttributeInfos() []*GetFileAttributesResponse_AttributeInfo {
	if x != nil {
		return x.AttributeInfos
	}
	return nil
}

// FastExportRequest is a request for the FastExport RPC
type FastExportRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to generate export data for.
	Repository    *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FastExportRequest) Reset() {
	*x = FastExportRequest{}
	mi := &file_repository_proto_msgTypes[84]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FastExportRequest) ProtoMessage() {}

func (x *FastExportRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[84]
	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 FastExportRequest.ProtoReflect.Descriptor instead.
func (*FastExportRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{84}
}

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

// FastExportResponse is a response for the FastExport RPC
type FastExportResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data contains the content of the export of the repository.
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FastExportResponse) Reset() {
	*x = FastExportResponse{}
	mi := &file_repository_proto_msgTypes[85]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FastExportResponse) ProtoMessage() {}

func (x *FastExportResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[85]
	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 FastExportResponse.ProtoReflect.Descriptor instead.
func (*FastExportResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{85}
}

func (x *FastExportResponse) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

// MigrateReferenceBackendRequest is a request for the MigrateReferenceBackend RPC.
type MigrateReferenceBackendRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to run migrations on.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// target_reference_backend is the backend to migrate to.
	TargetReferenceBackend MigrateReferenceBackendRequest_ReferenceBackend `protobuf:"varint,2,opt,name=target_reference_backend,json=targetReferenceBackend,proto3,enum=gitaly.MigrateReferenceBackendRequest_ReferenceBackend" json:"target_reference_backend,omitempty"`
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

func (x *MigrateReferenceBackendRequest) Reset() {
	*x = MigrateReferenceBackendRequest{}
	mi := &file_repository_proto_msgTypes[86]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MigrateReferenceBackendRequest) ProtoMessage() {}

func (x *MigrateReferenceBackendRequest) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[86]
	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 MigrateReferenceBackendRequest.ProtoReflect.Descriptor instead.
func (*MigrateReferenceBackendRequest) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{86}
}

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

func (x *MigrateReferenceBackendRequest) GetTargetReferenceBackend() MigrateReferenceBackendRequest_ReferenceBackend {
	if x != nil {
		return x.TargetReferenceBackend
	}
	return MigrateReferenceBackendRequest_REFERENCE_BACKEND_UNSPECIFIED
}

// MigrateReferenceBackendResponse is a response for the MigrateReferenceBackend RPC.
type MigrateReferenceBackendResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// time is the amount of time the migrations took.
	Time          *durationpb.Duration `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MigrateReferenceBackendResponse) Reset() {
	*x = MigrateReferenceBackendResponse{}
	mi := &file_repository_proto_msgTypes[87]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MigrateReferenceBackendResponse) ProtoMessage() {}

func (x *MigrateReferenceBackendResponse) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[87]
	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 MigrateReferenceBackendResponse.ProtoReflect.Descriptor instead.
func (*MigrateReferenceBackendResponse) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{87}
}

func (x *MigrateReferenceBackendResponse) GetTime() *durationpb.Duration {
	if x != nil {
		return x.Time
	}
	return nil
}

// ReferencesInfo hosts information about references.
type RepositoryInfoResponse_ReferencesInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// loose_count is the number of loose references that exist in the repository. These references
	// are written whenever any reference either gets updated or created. Loose references have not
	// yet been compressed into a packed format, which is an action that Gitaly performs regularly
	// during repository maintenance.
	//
	// We do not provide the total size of loose references as it is a constant factor of the count
	// anyway: `$count * $object_hash_length`.
	LooseCount uint64 `protobuf:"varint,1,opt,name=loose_count,json=looseCount,proto3" json:"loose_count,omitempty"`
	// packed_size is the size of packed references in bytes. Packed references are a more efficient
	// way to store loose references. Given that determining the exact amount of references stored
	// in packed format would require us to process the complete contents we don't provide the size
	// here. A very rough estimate would be: `$size / 100`.
	PackedSize uint64 `protobuf:"varint,2,opt,name=packed_size,json=packedSize,proto3" json:"packed_size,omitempty"`
	// reference_backend is the backend used for storing references in the repository.
	ReferenceBackend RepositoryInfoResponse_ReferencesInfo_ReferenceBackend `protobuf:"varint,3,opt,name=reference_backend,json=referenceBackend,proto3,enum=gitaly.RepositoryInfoResponse_ReferencesInfo_ReferenceBackend" json:"reference_backend,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *RepositoryInfoResponse_ReferencesInfo) Reset() {
	*x = RepositoryInfoResponse_ReferencesInfo{}
	mi := &file_repository_proto_msgTypes[88]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RepositoryInfoResponse_ReferencesInfo) ProtoMessage() {}

func (x *RepositoryInfoResponse_ReferencesInfo) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[88]
	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 RepositoryInfoResponse_ReferencesInfo.ProtoReflect.Descriptor instead.
func (*RepositoryInfoResponse_ReferencesInfo) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{5, 0}
}

func (x *RepositoryInfoResponse_ReferencesInfo) GetLooseCount() uint64 {
	if x != nil {
		return x.LooseCount
	}
	return 0
}

func (x *RepositoryInfoResponse_ReferencesInfo) GetPackedSize() uint64 {
	if x != nil {
		return x.PackedSize
	}
	return 0
}

func (x *RepositoryInfoResponse_ReferencesInfo) GetReferenceBackend() RepositoryInfoResponse_ReferencesInfo_ReferenceBackend {
	if x != nil {
		return x.ReferenceBackend
	}
	return RepositoryInfoResponse_ReferencesInfo_REFERENCE_BACKEND_UNSPECIFIED
}

// ObjectsInfo hosts info about objects contained in a repository. It tries to bridge the gap
// between the actual on-disk state that is changing over time as Git introduces new ways to
// perform repository housekeeping and specific classifications of objects.
//
// One of the distinctions is between "recent" and "stale" objects. The set of recent objects
// contains these objects that have either been recently written/accessed or those which are
// reachable via any of the references. Stale objects on the other hand are those that are older
// than a certain grace period and which are not reachable via any reference. The exact details
// when the set of stale and recent objects is updated is an internal implementation detail of
// Gitaly and subject to change. It is safe to assume though that unreachable objects will
// eventually be marked stale when repository housekeeping runs on a repository.
type RepositoryInfoResponse_ObjectsInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// size is the total size of all objects in the repository in bytes. It makes no distinction
	// between the way they are stored or whether they are pending deletion.
	Size uint64 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"`
	// recent_size is the total size of all objects in bytes that are considered to be recent. Recent
	// objects are likely reachable and will not be considered for deletion.
	RecentSize uint64 `protobuf:"varint,2,opt,name=recent_size,json=recentSize,proto3" json:"recent_size,omitempty"`
	// stale_size is the total size of all objects in bytes that are considered to be stale. Stale
	// objects are likely unreachable and will eventually be deleted after a grace period. Objects
	// which are part of cruft packs are always considered to be stale.
	StaleSize uint64 `protobuf:"varint,3,opt,name=stale_size,json=staleSize,proto3" json:"stale_size,omitempty"`
	// keep_size is the total size of all kept packfiles. Kept packfiles are packfiles that have a
	// `.keep` file accompanying them. Packfiles marked with such a file will never be deleted by
	// Git and will thus stay around forever, even if their objects are part of
	// other packfiles already.
	KeepSize uint64 `protobuf:"varint,4,opt,name=keep_size,json=keepSize,proto3" json:"keep_size,omitempty"`
	// packfile_count is the number of all packfiles, including stale and kept ones.
	PackfileCount uint64 `protobuf:"varint,5,opt,name=packfile_count,json=packfileCount,proto3" json:"packfile_count,omitempty"`
	// reverse_index_count is the number of reverse indices.
	ReverseIndexCount uint64 `protobuf:"varint,6,opt,name=reverse_index_count,json=reverseIndexCount,proto3" json:"reverse_index_count,omitempty"`
	// cruft_count is the number of cruft packfiles which have a .mtimes file.
	CruftCount uint64 `protobuf:"varint,7,opt,name=cruft_count,json=cruftCount,proto3" json:"cruft_count,omitempty"`
	// keep_count is the number of .keep packfiles.
	KeepCount uint64 `protobuf:"varint,8,opt,name=keep_count,json=keepCount,proto3" json:"keep_count,omitempty"`
	// loose_objects_count is the number of loose objects.
	LooseObjectsCount uint64 `protobuf:"varint,9,opt,name=loose_objects_count,json=looseObjectsCount,proto3" json:"loose_objects_count,omitempty"`
	// stale_loose_objects_count is the number of stale loose objects.
	StaleLooseObjectsCount uint64 `protobuf:"varint,10,opt,name=stale_loose_objects_count,json=staleLooseObjectsCount,proto3" json:"stale_loose_objects_count,omitempty"`
	// loose_objects_garbage_count is the number of garbage files in loose objects shards.
	LooseObjectsGarbageCount uint64 `protobuf:"varint,11,opt,name=loose_objects_garbage_count,json=looseObjectsGarbageCount,proto3" json:"loose_objects_garbage_count,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

func (x *RepositoryInfoResponse_ObjectsInfo) Reset() {
	*x = RepositoryInfoResponse_ObjectsInfo{}
	mi := &file_repository_proto_msgTypes[89]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RepositoryInfoResponse_ObjectsInfo) ProtoMessage() {}

func (x *RepositoryInfoResponse_ObjectsInfo) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[89]
	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 RepositoryInfoResponse_ObjectsInfo.ProtoReflect.Descriptor instead.
func (*RepositoryInfoResponse_ObjectsInfo) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{5, 1}
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetSize() uint64 {
	if x != nil {
		return x.Size
	}
	return 0
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetRecentSize() uint64 {
	if x != nil {
		return x.RecentSize
	}
	return 0
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetStaleSize() uint64 {
	if x != nil {
		return x.StaleSize
	}
	return 0
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetKeepSize() uint64 {
	if x != nil {
		return x.KeepSize
	}
	return 0
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetPackfileCount() uint64 {
	if x != nil {
		return x.PackfileCount
	}
	return 0
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetReverseIndexCount() uint64 {
	if x != nil {
		return x.ReverseIndexCount
	}
	return 0
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetCruftCount() uint64 {
	if x != nil {
		return x.CruftCount
	}
	return 0
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetKeepCount() uint64 {
	if x != nil {
		return x.KeepCount
	}
	return 0
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetLooseObjectsCount() uint64 {
	if x != nil {
		return x.LooseObjectsCount
	}
	return 0
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetStaleLooseObjectsCount() uint64 {
	if x != nil {
		return x.StaleLooseObjectsCount
	}
	return 0
}

func (x *RepositoryInfoResponse_ObjectsInfo) GetLooseObjectsGarbageCount() uint64 {
	if x != nil {
		return x.LooseObjectsGarbageCount
	}
	return 0
}

// CommitGraphInfo hosts information about the commit-graph of a repository.
type RepositoryInfoResponse_CommitGraphInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit_graph_chain_length is the length of the commit-graph chain, if it exists. If the
	// repository does not have a commit-graph chain but a monolithic commit-graph, then this
	// field will be set to 0.
	CommitGraphChainLength uint64 `protobuf:"varint,1,opt,name=commit_graph_chain_length,json=commitGraphChainLength,proto3" json:"commit_graph_chain_length,omitempty"`
	// has_bloom_filters tells whether the commit-graph has bloom filters. Bloom filters are used
	// to answer the question whether a certain path has been changed in the commit the bloom
	// filter applies to.
	HasBloomFilters bool `protobuf:"varint,2,opt,name=has_bloom_filters,json=hasBloomFilters,proto3" json:"has_bloom_filters,omitempty"`
	// has_generation_data tells whether the commit-graph has generation data. Generation
	// data is stored as the corrected committer date, which is defined as the maximum
	// of the commit's own committer date or the corrected committer date of any of its
	// parents. This data can be used to determine whether a commit A comes after a
	// certain commit B.
	HasGenerationData bool `protobuf:"varint,3,opt,name=has_generation_data,json=hasGenerationData,proto3" json:"has_generation_data,omitempty"`
	// has_generation_data_overflow stores overflow data in case the corrected committer
	// date takes more than 31 bits to represent.
	HasGenerationDataOverflow bool `protobuf:"varint,5,opt,name=has_generation_data_overflow,json=hasGenerationDataOverflow,proto3" json:"has_generation_data_overflow,omitempty"`
	unknownFields             protoimpl.UnknownFields
	sizeCache                 protoimpl.SizeCache
}

func (x *RepositoryInfoResponse_CommitGraphInfo) Reset() {
	*x = RepositoryInfoResponse_CommitGraphInfo{}
	mi := &file_repository_proto_msgTypes[90]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RepositoryInfoResponse_CommitGraphInfo) ProtoMessage() {}

func (x *RepositoryInfoResponse_CommitGraphInfo) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[90]
	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 RepositoryInfoResponse_CommitGraphInfo.ProtoReflect.Descriptor instead.
func (*RepositoryInfoResponse_CommitGraphInfo) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{5, 2}
}

func (x *RepositoryInfoResponse_CommitGraphInfo) GetCommitGraphChainLength() uint64 {
	if x != nil {
		return x.CommitGraphChainLength
	}
	return 0
}

func (x *RepositoryInfoResponse_CommitGraphInfo) GetHasBloomFilters() bool {
	if x != nil {
		return x.HasBloomFilters
	}
	return false
}

func (x *RepositoryInfoResponse_CommitGraphInfo) GetHasGenerationData() bool {
	if x != nil {
		return x.HasGenerationData
	}
	return false
}

func (x *RepositoryInfoResponse_CommitGraphInfo) GetHasGenerationDataOverflow() bool {
	if x != nil {
		return x.HasGenerationDataOverflow
	}
	return false
}

// BitmapInfo hosts information about bitmaps in a repository.
type RepositoryInfoResponse_BitmapInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// has_hash_cache indicates whether the name hash cache extension exists in the bitmap.
	HasHashCache bool `protobuf:"varint,1,opt,name=has_hash_cache,json=hasHashCache,proto3" json:"has_hash_cache,omitempty"`
	// has_lookup_table indicates whether the lookup table exists in the bitmap.
	HasLookupTable bool `protobuf:"varint,2,opt,name=has_lookup_table,json=hasLookupTable,proto3" json:"has_lookup_table,omitempty"`
	// version is the version of the bitmap (currently only version 1 is supported by Git).
	Version       uint64 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RepositoryInfoResponse_BitmapInfo) Reset() {
	*x = RepositoryInfoResponse_BitmapInfo{}
	mi := &file_repository_proto_msgTypes[91]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RepositoryInfoResponse_BitmapInfo) ProtoMessage() {}

func (x *RepositoryInfoResponse_BitmapInfo) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[91]
	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 RepositoryInfoResponse_BitmapInfo.ProtoReflect.Descriptor instead.
func (*RepositoryInfoResponse_BitmapInfo) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{5, 3}
}

func (x *RepositoryInfoResponse_BitmapInfo) GetHasHashCache() bool {
	if x != nil {
		return x.HasHashCache
	}
	return false
}

func (x *RepositoryInfoResponse_BitmapInfo) GetHasLookupTable() bool {
	if x != nil {
		return x.HasLookupTable
	}
	return false
}

func (x *RepositoryInfoResponse_BitmapInfo) GetVersion() uint64 {
	if x != nil {
		return x.Version
	}
	return 0
}

// MultiPackIndexInfo hosts information about the multi-pack-index.
type RepositoryInfoResponse_MultiPackIndexInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// packfile_count is the count of packfiles that the multi-pack-index tracks.
	PackfileCount uint64 `protobuf:"varint,1,opt,name=packfile_count,json=packfileCount,proto3" json:"packfile_count,omitempty"`
	// version is the version of the multi-pack-index (currently only version 1 is supported by Git).
	Version uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	// has_large_offsets determines whether the MIDX contains LOFF chunks. This may be required in case the indexed
	// packfiles are so large that offsets are larger than 32 bytes.
	HasLargeOffsets bool `protobuf:"varint,3,opt,name=has_large_offsets,json=hasLargeOffsets,proto3" json:"has_large_offsets,omitempty"`
	// has_bitmapped_packs determines whether the MIDX contains BTMP chunks, which are used as bitmaps for individual
	// packfiles contained in the MIDX.
	HasBitmappedPacks bool `protobuf:"varint,4,opt,name=has_bitmapped_packs,json=hasBitmappedPacks,proto3" json:"has_bitmapped_packs,omitempty"`
	// has_reverse_index determines whether the MIDX contains RIDX chunks, which are used as reverse indices for
	// individual packfiles contained in the MIDX.
	HasReverseIndex bool `protobuf:"varint,5,opt,name=has_reverse_index,json=hasReverseIndex,proto3" json:"has_reverse_index,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *RepositoryInfoResponse_MultiPackIndexInfo) Reset() {
	*x = RepositoryInfoResponse_MultiPackIndexInfo{}
	mi := &file_repository_proto_msgTypes[92]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RepositoryInfoResponse_MultiPackIndexInfo) ProtoMessage() {}

func (x *RepositoryInfoResponse_MultiPackIndexInfo) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[92]
	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 RepositoryInfoResponse_MultiPackIndexInfo.ProtoReflect.Descriptor instead.
func (*RepositoryInfoResponse_MultiPackIndexInfo) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{5, 4}
}

func (x *RepositoryInfoResponse_MultiPackIndexInfo) GetPackfileCount() uint64 {
	if x != nil {
		return x.PackfileCount
	}
	return 0
}

func (x *RepositoryInfoResponse_MultiPackIndexInfo) GetVersion() uint64 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (x *RepositoryInfoResponse_MultiPackIndexInfo) GetHasLargeOffsets() bool {
	if x != nil {
		return x.HasLargeOffsets
	}
	return false
}

func (x *RepositoryInfoResponse_MultiPackIndexInfo) GetHasBitmappedPacks() bool {
	if x != nil {
		return x.HasBitmappedPacks
	}
	return false
}

func (x *RepositoryInfoResponse_MultiPackIndexInfo) GetHasReverseIndex() bool {
	if x != nil {
		return x.HasReverseIndex
	}
	return false
}

// AlternatesInfo hosts information about alternate object directories.
type RepositoryInfoResponse_AlternatesInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// object_directories contains the list of paths to object directories that the repository is linked to.
	ObjectDirectories []string `protobuf:"bytes,1,rep,name=object_directories,json=objectDirectories,proto3" json:"object_directories,omitempty"`
	// last_modified is the time when the alternates file has last been
	// modified.
	LastModified  *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=last_modified,json=lastModified,proto3" json:"last_modified,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RepositoryInfoResponse_AlternatesInfo) Reset() {
	*x = RepositoryInfoResponse_AlternatesInfo{}
	mi := &file_repository_proto_msgTypes[93]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RepositoryInfoResponse_AlternatesInfo) ProtoMessage() {}

func (x *RepositoryInfoResponse_AlternatesInfo) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[93]
	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 RepositoryInfoResponse_AlternatesInfo.ProtoReflect.Descriptor instead.
func (*RepositoryInfoResponse_AlternatesInfo) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{5, 5}
}

func (x *RepositoryInfoResponse_AlternatesInfo) GetObjectDirectories() []string {
	if x != nil {
		return x.ObjectDirectories
	}
	return nil
}

func (x *RepositoryInfoResponse_AlternatesInfo) GetLastModified() *timestamppb.Timestamp {
	if x != nil {
		return x.LastModified
	}
	return nil
}

// RawChange represents the metadata for a single change between the two
// revisions.
type GetRawChangesResponse_RawChange struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// blob_id is the OID of the file that was changed.
	BlobId string `protobuf:"bytes,1,opt,name=blob_id,json=blobId,proto3" json:"blob_id,omitempty"`
	// size is the blob size in bytes.
	Size int64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	// operation is the change that occurred on the file.
	Operation GetRawChangesResponse_RawChange_Operation `protobuf:"varint,5,opt,name=operation,proto3,enum=gitaly.GetRawChangesResponse_RawChange_Operation" json:"operation,omitempty"`
	// old_mode is the previous mode of the file. This may be equal to new_mode.
	OldMode int32 `protobuf:"varint,7,opt,name=old_mode,json=oldMode,proto3" json:"old_mode,omitempty"`
	// new_mode is the current mode of the file. This may be equal to old_mode.
	NewMode int32 `protobuf:"varint,8,opt,name=new_mode,json=newMode,proto3" json:"new_mode,omitempty"`
	// new_path_bytes is the new file path. This may be equal to old_path_bytes.
	NewPathBytes []byte `protobuf:"bytes,9,opt,name=new_path_bytes,json=newPathBytes,proto3" json:"new_path_bytes,omitempty"`
	// old_path_bytes is the old file path. This may be equal to new_path_bytes.
	OldPathBytes  []byte `protobuf:"bytes,10,opt,name=old_path_bytes,json=oldPathBytes,proto3" json:"old_path_bytes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetRawChangesResponse_RawChange) Reset() {
	*x = GetRawChangesResponse_RawChange{}
	mi := &file_repository_proto_msgTypes[94]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetRawChangesResponse_RawChange) ProtoMessage() {}

func (x *GetRawChangesResponse_RawChange) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[94]
	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 GetRawChangesResponse_RawChange.ProtoReflect.Descriptor instead.
func (*GetRawChangesResponse_RawChange) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{62, 0}
}

func (x *GetRawChangesResponse_RawChange) GetBlobId() string {
	if x != nil {
		return x.BlobId
	}
	return ""
}

func (x *GetRawChangesResponse_RawChange) GetSize() int64 {
	if x != nil {
		return x.Size
	}
	return 0
}

func (x *GetRawChangesResponse_RawChange) GetOperation() GetRawChangesResponse_RawChange_Operation {
	if x != nil {
		return x.Operation
	}
	return GetRawChangesResponse_RawChange_UNKNOWN
}

func (x *GetRawChangesResponse_RawChange) GetOldMode() int32 {
	if x != nil {
		return x.OldMode
	}
	return 0
}

func (x *GetRawChangesResponse_RawChange) GetNewMode() int32 {
	if x != nil {
		return x.NewMode
	}
	return 0
}

func (x *GetRawChangesResponse_RawChange) GetNewPathBytes() []byte {
	if x != nil {
		return x.NewPathBytes
	}
	return nil
}

func (x *GetRawChangesResponse_RawChange) GetOldPathBytes() []byte {
	if x != nil {
		return x.OldPathBytes
	}
	return nil
}

// SkippedError is returned when the repository backup has been skipped.
type BackupRepositoryResponse_SkippedError struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BackupRepositoryResponse_SkippedError) Reset() {
	*x = BackupRepositoryResponse_SkippedError{}
	mi := &file_repository_proto_msgTypes[95]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BackupRepositoryResponse_SkippedError) ProtoMessage() {}

func (x *BackupRepositoryResponse_SkippedError) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[95]
	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 BackupRepositoryResponse_SkippedError.ProtoReflect.Descriptor instead.
func (*BackupRepositoryResponse_SkippedError) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{79, 0}
}

// SkippedError is returned when the repository restore has been skipped.
type RestoreRepositoryResponse_SkippedError struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RestoreRepositoryResponse_SkippedError) Reset() {
	*x = RestoreRepositoryResponse_SkippedError{}
	mi := &file_repository_proto_msgTypes[96]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RestoreRepositoryResponse_SkippedError) ProtoMessage() {}

func (x *RestoreRepositoryResponse_SkippedError) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[96]
	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 RestoreRepositoryResponse_SkippedError.ProtoReflect.Descriptor instead.
func (*RestoreRepositoryResponse_SkippedError) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{81, 0}
}

// AttributeInfo is a specified git attribute for a given path.
type GetFileAttributesResponse_AttributeInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// path is the file path for the current attribute value.
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// attribute is the name of the attribute.
	Attribute string `protobuf:"bytes,2,opt,name=attribute,proto3" json:"attribute,omitempty"`
	// value is the current value of the attribute.
	// "set" is used when the attribute is true, and "unset" when it's false.
	// See gitattributes(5) and git-check-attr(1) for more info.
	Value         string `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetFileAttributesResponse_AttributeInfo) Reset() {
	*x = GetFileAttributesResponse_AttributeInfo{}
	mi := &file_repository_proto_msgTypes[97]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetFileAttributesResponse_AttributeInfo) ProtoMessage() {}

func (x *GetFileAttributesResponse_AttributeInfo) ProtoReflect() protoreflect.Message {
	mi := &file_repository_proto_msgTypes[97]
	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 GetFileAttributesResponse_AttributeInfo.ProtoReflect.Descriptor instead.
func (*GetFileAttributesResponse_AttributeInfo) Descriptor() ([]byte, []int) {
	return file_repository_proto_rawDescGZIP(), []int{83, 0}
}

func (x *GetFileAttributesResponse_AttributeInfo) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (x *GetFileAttributesResponse_AttributeInfo) GetAttribute() string {
	if x != nil {
		return x.Attribute
	}
	return ""
}

func (x *GetFileAttributesResponse_AttributeInfo) GetValue() string {
	if x != nil {
		return x.Value
	}
	return ""
}

var File_repository_proto protoreflect.FileDescriptor

const file_repository_proto_rawDesc = "" +
	"\n" +
	"\x10repository.proto\x12\x06gitaly\x1a\ferrors.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\n" +
	"lint.proto\x1a\fshared.proto\"S\n" +
	"\x17RepositoryExistsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"2\n" +
	"\x18RepositoryExistsResponse\x12\x16\n" +
	"\x06exists\x18\x01 \x01(\bR\x06exists\"Q\n" +
	"\x15RepositorySizeRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\",\n" +
	"\x16RepositorySizeResponse\x12\x12\n" +
	"\x04size\x18\x01 \x01(\x03R\x04size\"Q\n" +
	"\x15RepositoryInfoRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"\x90\x11\n" +
	"\x16RepositoryInfoResponse\x12\x12\n" +
	"\x04size\x18\x01 \x01(\x04R\x04size\x12M\n" +
	"\n" +
	"references\x18\x02 \x01(\v2-.gitaly.RepositoryInfoResponse.ReferencesInfoR\n" +
	"references\x12D\n" +
	"\aobjects\x18\x03 \x01(\v2*.gitaly.RepositoryInfoResponse.ObjectsInfoR\aobjects\x12Q\n" +
	"\fcommit_graph\x18\x04 \x01(\v2..gitaly.RepositoryInfoResponse.CommitGraphInfoR\vcommitGraph\x12A\n" +
	"\x06bitmap\x18\x05 \x01(\v2).gitaly.RepositoryInfoResponse.BitmapInfoR\x06bitmap\x12[\n" +
	"\x10multi_pack_index\x18\x06 \x01(\v21.gitaly.RepositoryInfoResponse.MultiPackIndexInfoR\x0emultiPackIndex\x12`\n" +
	"\x17multi_pack_index_bitmap\x18\a \x01(\v2).gitaly.RepositoryInfoResponse.BitmapInfoR\x14multiPackIndexBitmap\x12M\n" +
	"\n" +
	"alternates\x18\b \x01(\v2-.gitaly.RepositoryInfoResponse.AlternatesInfoR\n" +
	"alternates\x12$\n" +
	"\x0eis_object_pool\x18\t \x01(\bR\fisObjectPool\x12D\n" +
	"\x10last_full_repack\x18\n" +
	" \x01(\v2\x1a.google.protobuf.TimestampR\x0elastFullRepack\x1a\xb3\x02\n" +
	"\x0eReferencesInfo\x12\x1f\n" +
	"\vloose_count\x18\x01 \x01(\x04R\n" +
	"looseCount\x12\x1f\n" +
	"\vpacked_size\x18\x02 \x01(\x04R\n" +
	"packedSize\x12k\n" +
	"\x11reference_backend\x18\x03 \x01(\x0e2>.gitaly.RepositoryInfoResponse.ReferencesInfo.ReferenceBackendR\x10referenceBackend\"r\n" +
	"\x10ReferenceBackend\x12!\n" +
	"\x1dREFERENCE_BACKEND_UNSPECIFIED\x10\x00\x12\x1b\n" +
	"\x17REFERENCE_BACKEND_FILES\x10\x01\x12\x1e\n" +
	"\x1aREFERENCE_BACKEND_REFTABLE\x10\x02\x1a\xbf\x03\n" +
	"\vObjectsInfo\x12\x12\n" +
	"\x04size\x18\x01 \x01(\x04R\x04size\x12\x1f\n" +
	"\vrecent_size\x18\x02 \x01(\x04R\n" +
	"recentSize\x12\x1d\n" +
	"\n" +
	"stale_size\x18\x03 \x01(\x04R\tstaleSize\x12\x1b\n" +
	"\tkeep_size\x18\x04 \x01(\x04R\bkeepSize\x12%\n" +
	"\x0epackfile_count\x18\x05 \x01(\x04R\rpackfileCount\x12.\n" +
	"\x13reverse_index_count\x18\x06 \x01(\x04R\x11reverseIndexCount\x12\x1f\n" +
	"\vcruft_count\x18\a \x01(\x04R\n" +
	"cruftCount\x12\x1d\n" +
	"\n" +
	"keep_count\x18\b \x01(\x04R\tkeepCount\x12.\n" +
	"\x13loose_objects_count\x18\t \x01(\x04R\x11looseObjectsCount\x129\n" +
	"\x19stale_loose_objects_count\x18\n" +
	" \x01(\x04R\x16staleLooseObjectsCount\x12=\n" +
	"\x1bloose_objects_garbage_count\x18\v \x01(\x04R\x18looseObjectsGarbageCount\x1a\xe9\x01\n" +
	"\x0fCommitGraphInfo\x129\n" +
	"\x19commit_graph_chain_length\x18\x01 \x01(\x04R\x16commitGraphChainLength\x12*\n" +
	"\x11has_bloom_filters\x18\x02 \x01(\bR\x0fhasBloomFilters\x12.\n" +
	"\x13has_generation_data\x18\x03 \x01(\bR\x11hasGenerationData\x12?\n" +
	"\x1chas_generation_data_overflow\x18\x05 \x01(\bR\x19hasGenerationDataOverflow\x1av\n" +
	"\n" +
	"BitmapInfo\x12$\n" +
	"\x0ehas_hash_cache\x18\x01 \x01(\bR\fhasHashCache\x12(\n" +
	"\x10has_lookup_table\x18\x02 \x01(\bR\x0ehasLookupTable\x12\x18\n" +
	"\aversion\x18\x03 \x01(\x04R\aversion\x1a\xdd\x01\n" +
	"\x12MultiPackIndexInfo\x12%\n" +
	"\x0epackfile_count\x18\x01 \x01(\x04R\rpackfileCount\x12\x18\n" +
	"\aversion\x18\x02 \x01(\x04R\aversion\x12*\n" +
	"\x11has_large_offsets\x18\x03 \x01(\bR\x0fhasLargeOffsets\x12.\n" +
	"\x13has_bitmapped_packs\x18\x04 \x01(\bR\x11hasBitmappedPacks\x12*\n" +
	"\x11has_reverse_index\x18\x05 \x01(\bR\x0fhasReverseIndex\x1a\x80\x01\n" +
	"\x0eAlternatesInfo\x12-\n" +
	"\x12object_directories\x18\x01 \x03(\tR\x11objectDirectories\x12?\n" +
	"\rlast_modified\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\flastModified\"l\n" +
	"\x12ObjectsSizeRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1c\n" +
	"\trevisions\x18\x02 \x03(\fR\trevisions\")\n" +
	"\x13ObjectsSizeResponse\x12\x12\n" +
	"\x04size\x18\x01 \x01(\x04R\x04size\"O\n" +
	"\x13ObjectFormatRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"D\n" +
	"\x14ObjectFormatResponse\x12,\n" +
	"\x06format\x18\x01 \x01(\x0e2\x14.gitaly.ObjectFormatR\x06format\"\x83\x01\n" +
	"\x12FetchBundleRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x12\n" +
	"\x04data\x18\x02 \x01(\fR\x04data\x12\x1f\n" +
	"\vupdate_head\x18\x03 \x01(\bR\n" +
	"updateHead\"\x15\n" +
	"\x13FetchBundleResponse\"\xe3\x02\n" +
	"\x12FetchRemoteRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x14\n" +
	"\x05force\x18\x03 \x01(\bR\x05force\x12\x17\n" +
	"\ano_tags\x18\x04 \x01(\bR\x06noTags\x12\x18\n" +
	"\atimeout\x18\x05 \x01(\x05R\atimeout\x12\x17\n" +
	"\assh_key\x18\x06 \x01(\tR\x06sshKey\x12\x1f\n" +
	"\vknown_hosts\x18\a \x01(\tR\n" +
	"knownHosts\x12\x19\n" +
	"\bno_prune\x18\t \x01(\bR\anoPrune\x123\n" +
	"\rremote_params\x18\n" +
	" \x01(\v2\x0e.gitaly.RemoteR\fremoteParams\x12,\n" +
	"\x12check_tags_changed\x18\v \x01(\bR\x10checkTagsChangedJ\x04\b\b\x10\tJ\x04\b\x02\x10\x03R\x06remote\"[\n" +
	"\x13FetchRemoteResponse\x12!\n" +
	"\ftags_changed\x18\x01 \x01(\bR\vtagsChanged\x12!\n" +
	"\frepo_changed\x18\x02 \x01(\bR\vrepoChanged\"\xb5\x01\n" +
	"\x17CreateRepositoryRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12%\n" +
	"\x0edefault_branch\x18\x02 \x01(\fR\rdefaultBranch\x129\n" +
	"\robject_format\x18\x03 \x01(\x0e2\x14.gitaly.ObjectFormatR\fobjectFormat\"\x1a\n" +
	"\x18CreateRepositoryResponse\"\xea\x02\n" +
	"\x11GetArchiveRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1b\n" +
	"\tcommit_id\x18\x02 \x01(\tR\bcommitId\x12\x16\n" +
	"\x06prefix\x18\x03 \x01(\tR\x06prefix\x128\n" +
	"\x06format\x18\x04 \x01(\x0e2 .gitaly.GetArchiveRequest.FormatR\x06format\x12\x12\n" +
	"\x04path\x18\x05 \x01(\fR\x04path\x12\x18\n" +
	"\aexclude\x18\x06 \x03(\fR\aexclude\x12\x1d\n" +
	"\n" +
	"elide_path\x18\a \x01(\bR\telidePath\x12*\n" +
	"\x11include_lfs_blobs\x18\b \x01(\bR\x0fincludeLfsBlobs\"3\n" +
	"\x06Format\x12\a\n" +
	"\x03ZIP\x10\x00\x12\a\n" +
	"\x03TAR\x10\x01\x12\n" +
	"\n" +
	"\x06TAR_GZ\x10\x02\x12\v\n" +
	"\aTAR_BZ2\x10\x03\"(\n" +
	"\x12GetArchiveResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"S\n" +
	"\x17HasLocalBranchesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"0\n" +
	"\x18HasLocalBranchesResponse\x12\x14\n" +
	"\x05value\x18\x01 \x01(\bR\x05value\"\x90\x02\n" +
	"\x18FetchSourceBranchRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12?\n" +
	"\x11source_repository\x18\x02 \x01(\v2\x12.gitaly.RepositoryR\x10sourceRepository\x12#\n" +
	"\rsource_branch\x18\x03 \x01(\fR\fsourceBranch\x12\x1d\n" +
	"\n" +
	"target_ref\x18\x04 \x01(\fR\ttargetRef\x125\n" +
	"\x17expected_target_old_oid\x18\x05 \x01(\tR\x14expectedTargetOldOid\"3\n" +
	"\x19FetchSourceBranchResponse\x12\x16\n" +
	"\x06result\x18\x01 \x01(\bR\x06result\"d\n" +
	"\vFsckRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1b\n" +
	"\trepo_only\x18\x02 \x01(\bR\brepoOnly\"$\n" +
	"\fFsckResponse\x12\x14\n" +
	"\x05error\x18\x01 \x01(\fR\x05error\"\xaf\x01\n" +
	"\x0fWriteRefRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x10\n" +
	"\x03ref\x18\x02 \x01(\fR\x03ref\x12\x1a\n" +
	"\brevision\x18\x03 \x01(\fR\brevision\x12!\n" +
	"\fold_revision\x18\x04 \x01(\fR\voldRevisionJ\x04\b\x05\x10\x06J\x04\b\x06\x10\aR\x05force\"\x18\n" +
	"\x10WriteRefResponseJ\x04\b\x01\x10\x02\"n\n" +
	"\x14FindMergeBaseRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1c\n" +
	"\trevisions\x18\x02 \x03(\fR\trevisions\"+\n" +
	"\x15FindMergeBaseResponse\x12\x12\n" +
	"\x04base\x18\x01 \x01(\tR\x04base\"\xaa\x01\n" +
	"\x11CreateForkRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12?\n" +
	"\x11source_repository\x18\x02 \x01(\v2\x12.gitaly.RepositoryR\x10sourceRepository\x12\x1a\n" +
	"\brevision\x18\x03 \x01(\fR\brevision\"\x14\n" +
	"\x12CreateForkResponse\"\xfc\x01\n" +
	"\x1eCreateRepositoryFromURLRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x10\n" +
	"\x03url\x18\x02 \x01(\tR\x03url\x12:\n" +
	"\x19http_authorization_header\x18\x04 \x01(\tR\x17httpAuthorizationHeader\x12\x16\n" +
	"\x06mirror\x18\x05 \x01(\bR\x06mirror\x12)\n" +
	"\x10resolved_address\x18\x06 \x01(\tR\x0fresolvedAddressJ\x04\b\x03\x10\x04R\thttp_host\"!\n" +
	"\x1fCreateRepositoryFromURLResponse\"p\n" +
	"\x1cCreateRepositoryFromURLError\x12G\n" +
	"\x10remote_not_found\x18\x01 \x01(\v2\x1b.gitaly.RemoteNotFoundErrorH\x00R\x0eremoteNotFoundB\a\n" +
	"\x05error\"O\n" +
	"\x13CreateBundleRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"*\n" +
	"\x14CreateBundleResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"v\n" +
	"\x1eCreateBundleFromRefListRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\bpatterns\x18\x02 \x03(\fR\bpatterns\"5\n" +
	"\x1fCreateBundleFromRefListResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"T\n" +
	"\x18GenerateBundleURIRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"\x1b\n" +
	"\x19GenerateBundleURIResponse\"L\n" +
	"\x10GetConfigRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"'\n" +
	"\x11GetConfigResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"i\n" +
	"\x19RestoreCustomHooksRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x12\n" +
	"\x04data\x18\x02 \x01(\fR\x04data\"e\n" +
	"\x15SetCustomHooksRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x12\n" +
	"\x04data\x18\x02 \x01(\fR\x04data\"\x1c\n" +
	"\x1aRestoreCustomHooksResponse\"\x18\n" +
	"\x16SetCustomHooksResponse\"T\n" +
	"\x18BackupCustomHooksRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"Q\n" +
	"\x15GetCustomHooksRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"/\n" +
	"\x19BackupCustomHooksResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\",\n" +
	"\x16GetCustomHooksResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"q\n" +
	"!CreateRepositoryFromBundleRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x12\n" +
	"\x04data\x18\x02 \x01(\fR\x04data\"$\n" +
	"\"CreateRepositoryFromBundleResponse\"N\n" +
	"\x12FindLicenseRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"\xd5\x01\n" +
	"\x13FindLicenseResponse\x12,\n" +
	"\x12license_short_name\x18\x01 \x01(\tR\x10licenseShortName\x12!\n" +
	"\flicense_name\x18\x02 \x01(\tR\vlicenseName\x12\x1f\n" +
	"\vlicense_url\x18\x03 \x01(\tR\n" +
	"licenseUrl\x12!\n" +
	"\flicense_path\x18\x04 \x01(\tR\vlicensePath\x12)\n" +
	"\x10license_nickname\x18\x05 \x01(\tR\x0flicenseNickname\"T\n" +
	"\x18GetInfoAttributesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\";\n" +
	"\x19GetInfoAttributesResponse\x12\x1e\n" +
	"\n" +
	"attributes\x18\x01 \x01(\fR\n" +
	"attributes\"T\n" +
	"\x18CalculateChecksumRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"7\n" +
	"\x19CalculateChecksumResponse\x12\x1a\n" +
	"\bchecksum\x18\x01 \x01(\tR\bchecksum\"N\n" +
	"\x12GetSnapshotRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\")\n" +
	"\x13GetSnapshotResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"\xd3\x01\n" +
	"#CreateRepositoryFromSnapshotRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x19\n" +
	"\bhttp_url\x18\x02 \x01(\tR\ahttpUrl\x12\x1b\n" +
	"\thttp_auth\x18\x03 \x01(\tR\bhttpAuth\x12)\n" +
	"\x10resolved_address\x18\x05 \x01(\tR\x0fresolvedAddressJ\x04\b\x04\x10\x05R\thttp_host\"&\n" +
	"$CreateRepositoryFromSnapshotResponse\"\x96\x01\n" +
	"\x14GetRawChangesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12#\n" +
	"\rfrom_revision\x18\x02 \x01(\tR\ffromRevision\x12\x1f\n" +
	"\vto_revision\x18\x03 \x01(\tR\n" +
	"toRevision\"\x8f\x04\n" +
	"\x15GetRawChangesResponse\x12H\n" +
	"\vraw_changes\x18\x01 \x03(\v2'.gitaly.GetRawChangesResponse.RawChangeR\n" +
	"rawChanges\x1a\xab\x03\n" +
	"\tRawChange\x12\x17\n" +
	"\ablob_id\x18\x01 \x01(\tR\x06blobId\x12\x12\n" +
	"\x04size\x18\x02 \x01(\x03R\x04size\x12O\n" +
	"\toperation\x18\x05 \x01(\x0e21.gitaly.GetRawChangesResponse.RawChange.OperationR\toperation\x12\x19\n" +
	"\bold_mode\x18\a \x01(\x05R\aoldMode\x12\x19\n" +
	"\bnew_mode\x18\b \x01(\x05R\anewMode\x12$\n" +
	"\x0enew_path_bytes\x18\t \x01(\fR\fnewPathBytes\x12$\n" +
	"\x0eold_path_bytes\x18\n" +
	" \x01(\fR\foldPathBytes\"i\n" +
	"\tOperation\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\t\n" +
	"\x05ADDED\x10\x01\x12\n" +
	"\n" +
	"\x06COPIED\x10\x02\x12\v\n" +
	"\aDELETED\x10\x03\x12\f\n" +
	"\bMODIFIED\x10\x04\x12\v\n" +
	"\aRENAMED\x10\x05\x12\x10\n" +
	"\fTYPE_CHANGED\x10\x06J\x04\b\x03\x10\x04J\x04\b\x04\x10\x05J\x04\b\x06\x10\aR\bnew_pathR\bold_pathR\rraw_operation\"\xc2\x01\n" +
	"\x18SearchFilesByNameRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x14\n" +
	"\x05query\x18\x02 \x01(\tR\x05query\x12\x10\n" +
	"\x03ref\x18\x03 \x01(\fR\x03ref\x12\x16\n" +
	"\x06filter\x18\x04 \x01(\tR\x06filter\x12\x14\n" +
	"\x05limit\x18\x05 \x01(\rR\x05limit\x12\x16\n" +
	"\x06offset\x18\x06 \x01(\rR\x06offset\"1\n" +
	"\x19SearchFilesByNameResponse\x12\x14\n" +
	"\x05files\x18\x01 \x03(\fR\x05files\"\x97\x01\n" +
	"\x1bSearchFilesByContentRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x14\n" +
	"\x05query\x18\x02 \x01(\tR\x05query\x12\x10\n" +
	"\x03ref\x18\x03 \x01(\fR\x03refJ\x04\b\x04\x10\x05R\x10chunked_response\"n\n" +
	"\x1cSearchFilesByContentResponse\x12\x1d\n" +
	"\n" +
	"match_data\x18\x02 \x01(\fR\tmatchData\x12 \n" +
	"\fend_of_match\x18\x03 \x01(\bR\n" +
	"endOfMatchJ\x04\b\x01\x10\x02R\amatches\"\xc5\x01\n" +
	"\x06Remote\x12\x10\n" +
	"\x03url\x18\x01 \x01(\tR\x03url\x12:\n" +
	"\x19http_authorization_header\x18\x03 \x01(\tR\x17httpAuthorizationHeader\x12%\n" +
	"\x0emirror_refmaps\x18\x04 \x03(\tR\rmirrorRefmaps\x12)\n" +
	"\x10resolved_address\x18\x06 \x01(\tR\x0fresolvedAddressJ\x04\b\x02\x10\x03J\x04\b\x05\x10\x06R\x04nameR\thttp_host\"Y\n" +
	"\x1dGetObjectDirectorySizeRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"4\n" +
	"\x1eGetObjectDirectorySizeResponse\x12\x12\n" +
	"\x04size\x18\x01 \x01(\x03R\x04size\"S\n" +
	"\x17RemoveRepositoryRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"\x1a\n" +
	"\x18RemoveRepositoryResponse\"\x82\x01\n" +
	"\x1aReplicateRepositoryRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12*\n" +
	"\x06source\x18\x02 \x01(\v2\x12.gitaly.RepositoryR\x06source\"\x1d\n" +
	"\x1bReplicateRepositoryResponse\"\xa5\x02\n" +
	"\x19OptimizeRepositoryRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12F\n" +
	"\bstrategy\x18\x02 \x01(\x0e2*.gitaly.OptimizeRepositoryRequest.StrategyR\bstrategy\"\x85\x01\n" +
	"\bStrategy\x12\x18\n" +
	"\x14STRATEGY_UNSPECIFIED\x10\x00\x12\x18\n" +
	"\x14STRATEGY_HEURISTICAL\x10\x01\x12\x12\n" +
	"\x0eSTRATEGY_EAGER\x10\x02\x12\x17\n" +
	"\x13STRATEGY_OFFLOADING\x10\x03\x12\x18\n" +
	"\x14STRATEGY_REHYDRATION\x10\x04\"\x1c\n" +
	"\x1aOptimizeRepositoryResponse\"Z\n" +
	"\x1ePruneUnreachableObjectsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"!\n" +
	"\x1fPruneUnreachableObjectsResponse\"\xfd\x01\n" +
	"\x17BackupRepositoryRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12?\n" +
	"\x11vanity_repository\x18\x02 \x01(\v2\x12.gitaly.RepositoryR\x10vanityRepository\x12\x1b\n" +
	"\tbackup_id\x18\x03 \x01(\tR\bbackupId\x12 \n" +
	"\vincremental\x18\x04 \x01(\bR\vincremental\x12(\n" +
	"\x10latest_backup_id\x18\x05 \x01(\tR\x0elatestBackupId\"*\n" +
	"\x18BackupRepositoryResponse\x1a\x0e\n" +
	"\fSkippedError\"\xf6\x01\n" +
	"\x18RestoreRepositoryRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12?\n" +
	"\x11vanity_repository\x18\x02 \x01(\v2\x12.gitaly.RepositoryR\x10vanityRepository\x12\x1b\n" +
	"\tbackup_id\x18\x03 \x01(\tR\bbackupId\x12#\n" +
	"\ralways_create\x18\x04 \x01(\bR\falwaysCreate\x12\x1d\n" +
	"\n" +
	"use_latest\x18\x05 \x01(\bR\tuseLatest\"+\n" +
	"\x19RestoreRepositoryResponse\x1a\x0e\n" +
	"\fSkippedError\"\xa6\x01\n" +
	"\x18GetFileAttributesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\x12\x1e\n" +
	"\n" +
	"attributes\x18\x03 \x03(\tR\n" +
	"attributes\x12\x14\n" +
	"\x05paths\x18\x04 \x03(\tR\x05paths\"\xce\x01\n" +
	"\x19GetFileAttributesResponse\x12X\n" +
	"\x0fattribute_infos\x18\x01 \x03(\v2/.gitaly.GetFileAttributesResponse.AttributeInfoR\x0eattributeInfos\x1aW\n" +
	"\rAttributeInfo\x12\x12\n" +
	"\x04path\x18\x01 \x01(\tR\x04path\x12\x1c\n" +
	"\tattribute\x18\x02 \x01(\tR\tattribute\x12\x14\n" +
	"\x05value\x18\x03 \x01(\tR\x05value\"M\n" +
	"\x11FastExportRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\"(\n" +
	"\x12FastExportResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"\xc1\x02\n" +
	"\x1eMigrateReferenceBackendRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12q\n" +
	"\x18target_reference_backend\x18\x02 \x01(\x0e27.gitaly.MigrateReferenceBackendRequest.ReferenceBackendR\x16targetReferenceBackend\"r\n" +
	"\x10ReferenceBackend\x12!\n" +
	"\x1dREFERENCE_BACKEND_UNSPECIFIED\x10\x00\x12\x1b\n" +
	"\x17REFERENCE_BACKEND_FILES\x10\x01\x12\x1e\n" +
	"\x1aREFERENCE_BACKEND_REFTABLE\x10\x02\"P\n" +
	"\x1fMigrateReferenceBackendResponse\x12-\n" +
	"\x04time\x18\x01 \x01(\v2\x19.google.protobuf.DurationR\x04time2\x83 \n" +
	"\x11RepositoryService\x12]\n" +
	"\x10RepositoryExists\x12\x1f.gitaly.RepositoryExistsRequest\x1a .gitaly.RepositoryExistsResponse\"\x06\xfa\x97(\x02\b\x02\x12W\n" +
	"\x0eRepositorySize\x12\x1d.gitaly.RepositorySizeRequest\x1a\x1e.gitaly.RepositorySizeResponse\"\x06\xfa\x97(\x02\b\x02\x12W\n" +
	"\x0eRepositoryInfo\x12\x1d.gitaly.RepositoryInfoRequest\x1a\x1e.gitaly.RepositoryInfoResponse\"\x06\xfa\x97(\x02\b\x02\x12P\n" +
	"\vObjectsSize\x12\x1a.gitaly.ObjectsSizeRequest\x1a\x1b.gitaly.ObjectsSizeResponse\"\x06\xfa\x97(\x02\b\x02(\x01\x12Q\n" +
	"\fObjectFormat\x12\x1b.gitaly.ObjectFormatRequest\x1a\x1c.gitaly.ObjectFormatResponse\"\x06\xfa\x97(\x02\b\x02\x12N\n" +
	"\vFetchRemote\x12\x1a.gitaly.FetchRemoteRequest\x1a\x1b.gitaly.FetchRemoteResponse\"\x06\xfa\x97(\x02\b\x01\x12]\n" +
	"\x10CreateRepository\x12\x1f.gitaly.CreateRepositoryRequest\x1a .gitaly.CreateRepositoryResponse\"\x06\xfa\x97(\x02\b\x01\x12M\n" +
	"\n" +
	"GetArchive\x12\x19.gitaly.GetArchiveRequest\x1a\x1a.gitaly.GetArchiveResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12]\n" +
	"\x10HasLocalBranches\x12\x1f.gitaly.HasLocalBranchesRequest\x1a .gitaly.HasLocalBranchesResponse\"\x06\xfa\x97(\x02\b\x02\x12`\n" +
	"\x11FetchSourceBranch\x12 .gitaly.FetchSourceBranchRequest\x1a!.gitaly.FetchSourceBranchResponse\"\x06\xfa\x97(\x02\b\x01\x129\n" +
	"\x04Fsck\x12\x13.gitaly.FsckRequest\x1a\x14.gitaly.FsckResponse\"\x06\xfa\x97(\x02\b\x02\x12E\n" +
	"\bWriteRef\x12\x17.gitaly.WriteRefRequest\x1a\x18.gitaly.WriteRefResponse\"\x06\xfa\x97(\x02\b\x01\x12T\n" +
	"\rFindMergeBase\x12\x1c.gitaly.FindMergeBaseRequest\x1a\x1d.gitaly.FindMergeBaseResponse\"\x06\xfa\x97(\x02\b\x02\x12K\n" +
	"\n" +
	"CreateFork\x12\x19.gitaly.CreateForkRequest\x1a\x1a.gitaly.CreateForkResponse\"\x06\xfa\x97(\x02\b\x01\x12r\n" +
	"\x17CreateRepositoryFromURL\x12&.gitaly.CreateRepositoryFromURLRequest\x1a'.gitaly.CreateRepositoryFromURLResponse\"\x06\xfa\x97(\x02\b\x01\x12S\n" +
	"\fCreateBundle\x12\x1b.gitaly.CreateBundleRequest\x1a\x1c.gitaly.CreateBundleResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12v\n" +
	"\x17CreateBundleFromRefList\x12&.gitaly.CreateBundleFromRefListRequest\x1a'.gitaly.CreateBundleFromRefListResponse\"\x06\xfa\x97(\x02\b\x02(\x010\x01\x12`\n" +
	"\x11GenerateBundleURI\x12 .gitaly.GenerateBundleURIRequest\x1a!.gitaly.GenerateBundleURIResponse\"\x06\xfa\x97(\x02\b\x02\x12P\n" +
	"\vFetchBundle\x12\x1a.gitaly.FetchBundleRequest\x1a\x1b.gitaly.FetchBundleResponse\"\x06\xfa\x97(\x02\b\x01(\x01\x12}\n" +
	"\x1aCreateRepositoryFromBundle\x12).gitaly.CreateRepositoryFromBundleRequest\x1a*.gitaly.CreateRepositoryFromBundleResponse\"\x06\xfa\x97(\x02\b\x01(\x01\x12J\n" +
	"\tGetConfig\x12\x18.gitaly.GetConfigRequest\x1a\x19.gitaly.GetConfigResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12N\n" +
	"\vFindLicense\x12\x1a.gitaly.FindLicenseRequest\x1a\x1b.gitaly.FindLicenseResponse\"\x06\xfa\x97(\x02\b\x02\x12e\n" +
	"\x11GetInfoAttributes\x12 .gitaly.GetInfoAttributesRequest\x1a!.gitaly.GetInfoAttributesResponse\"\t\xfa\x97(\x02\b\x02\x88\x02\x010\x01\x12`\n" +
	"\x11CalculateChecksum\x12 .gitaly.CalculateChecksumRequest\x1a!.gitaly.CalculateChecksumResponse\"\x06\xfa\x97(\x02\b\x02\x12P\n" +
	"\vGetSnapshot\x12\x1a.gitaly.GetSnapshotRequest\x1a\x1b.gitaly.GetSnapshotResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12\x81\x01\n" +
	"\x1cCreateRepositoryFromSnapshot\x12+.gitaly.CreateRepositoryFromSnapshotRequest\x1a,.gitaly.CreateRepositoryFromSnapshotResponse\"\x06\xfa\x97(\x02\b\x01\x12V\n" +
	"\rGetRawChanges\x12\x1c.gitaly.GetRawChangesRequest\x1a\x1d.gitaly.GetRawChangesResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12k\n" +
	"\x14SearchFilesByContent\x12#.gitaly.SearchFilesByContentRequest\x1a$.gitaly.SearchFilesByContentResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12b\n" +
	"\x11SearchFilesByName\x12 .gitaly.SearchFilesByNameRequest\x1a!.gitaly.SearchFilesByNameResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12h\n" +
	"\x12RestoreCustomHooks\x12!.gitaly.RestoreCustomHooksRequest\x1a\".gitaly.RestoreCustomHooksResponse\"\t\xfa\x97(\x02\b\x01\x88\x02\x01(\x01\x12Y\n" +
	"\x0eSetCustomHooks\x12\x1d.gitaly.SetCustomHooksRequest\x1a\x1e.gitaly.SetCustomHooksResponse\"\x06\xfa\x97(\x02\b\x01(\x01\x12e\n" +
	"\x11BackupCustomHooks\x12 .gitaly.BackupCustomHooksRequest\x1a!.gitaly.BackupCustomHooksResponse\"\t\xfa\x97(\x02\b\x02\x88\x02\x010\x01\x12Y\n" +
	"\x0eGetCustomHooks\x12\x1d.gitaly.GetCustomHooksRequest\x1a\x1e.gitaly.GetCustomHooksResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12o\n" +
	"\x16GetObjectDirectorySize\x12%.gitaly.GetObjectDirectorySizeRequest\x1a&.gitaly.GetObjectDirectorySizeResponse\"\x06\xfa\x97(\x02\b\x02\x12]\n" +
	"\x10RemoveRepository\x12\x1f.gitaly.RemoveRepositoryRequest\x1a .gitaly.RemoveRepositoryResponse\"\x06\xfa\x97(\x02\b\x01\x12f\n" +
	"\x13ReplicateRepository\x12\".gitaly.ReplicateRepositoryRequest\x1a#.gitaly.ReplicateRepositoryResponse\"\x06\xfa\x97(\x02\b\x01\x12c\n" +
	"\x12OptimizeRepository\x12!.gitaly.OptimizeRepositoryRequest\x1a\".gitaly.OptimizeRepositoryResponse\"\x06\xfa\x97(\x02\b\x03\x12r\n" +
	"\x17PruneUnreachableObjects\x12&.gitaly.PruneUnreachableObjectsRequest\x1a'.gitaly.PruneUnreachableObjectsResponse\"\x06\xfa\x97(\x02\b\x03\x12]\n" +
	"\x10BackupRepository\x12\x1f.gitaly.BackupRepositoryRequest\x1a .gitaly.BackupRepositoryResponse\"\x06\xfa\x97(\x02\b\x02\x12`\n" +
	"\x11RestoreRepository\x12 .gitaly.RestoreRepositoryRequest\x1a!.gitaly.RestoreRepositoryResponse\"\x06\xfa\x97(\x02\b\x01\x12`\n" +
	"\x11GetFileAttributes\x12 .gitaly.GetFileAttributesRequest\x1a!.gitaly.GetFileAttributesResponse\"\x06\xfa\x97(\x02\b\x02\x12M\n" +
	"\n" +
	"FastExport\x12\x19.gitaly.FastExportRequest\x1a\x1a.gitaly.FastExportResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12r\n" +
	"\x17MigrateReferenceBackend\x12&.gitaly.MigrateReferenceBackendRequest\x1a'.gitaly.MigrateReferenceBackendResponse\"\x06\xfa\x97(\x02\b\x01B4Z2gitlab.com/gitlab-org/gitaly/v18/proto/go/gitalypbb\x06proto3"

var (
	file_repository_proto_rawDescOnce sync.Once
	file_repository_proto_rawDescData []byte
)

func file_repository_proto_rawDescGZIP() []byte {
	file_repository_proto_rawDescOnce.Do(func() {
		file_repository_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_repository_proto_rawDesc), len(file_repository_proto_rawDesc)))
	})
	return file_repository_proto_rawDescData
}

var file_repository_proto_enumTypes = make([]protoimpl.EnumInfo, 5)
var file_repository_proto_msgTypes = make([]protoimpl.MessageInfo, 98)
var file_repository_proto_goTypes = []any{
	(RepositoryInfoResponse_ReferencesInfo_ReferenceBackend)(0), // 0: gitaly.RepositoryInfoResponse.ReferencesInfo.ReferenceBackend
	(GetArchiveRequest_Format)(0),                               // 1: gitaly.GetArchiveRequest.Format
	(GetRawChangesResponse_RawChange_Operation)(0),              // 2: gitaly.GetRawChangesResponse.RawChange.Operation
	(OptimizeRepositoryRequest_Strategy)(0),                     // 3: gitaly.OptimizeRepositoryRequest.Strategy
	(MigrateReferenceBackendRequest_ReferenceBackend)(0),        // 4: gitaly.MigrateReferenceBackendRequest.ReferenceBackend
	(*RepositoryExistsRequest)(nil),                             // 5: gitaly.RepositoryExistsRequest
	(*RepositoryExistsResponse)(nil),                            // 6: gitaly.RepositoryExistsResponse
	(*RepositorySizeRequest)(nil),                               // 7: gitaly.RepositorySizeRequest
	(*RepositorySizeResponse)(nil),                              // 8: gitaly.RepositorySizeResponse
	(*RepositoryInfoRequest)(nil),                               // 9: gitaly.RepositoryInfoRequest
	(*RepositoryInfoResponse)(nil),                              // 10: gitaly.RepositoryInfoResponse
	(*ObjectsSizeRequest)(nil),                                  // 11: gitaly.ObjectsSizeRequest
	(*ObjectsSizeResponse)(nil),                                 // 12: gitaly.ObjectsSizeResponse
	(*ObjectFormatRequest)(nil),                                 // 13: gitaly.ObjectFormatRequest
	(*ObjectFormatResponse)(nil),                                // 14: gitaly.ObjectFormatResponse
	(*FetchBundleRequest)(nil),                                  // 15: gitaly.FetchBundleRequest
	(*FetchBundleResponse)(nil),                                 // 16: gitaly.FetchBundleResponse
	(*FetchRemoteRequest)(nil),                                  // 17: gitaly.FetchRemoteRequest
	(*FetchRemoteResponse)(nil),                                 // 18: gitaly.FetchRemoteResponse
	(*CreateRepositoryRequest)(nil),                             // 19: gitaly.CreateRepositoryRequest
	(*CreateRepositoryResponse)(nil),                            // 20: gitaly.CreateRepositoryResponse
	(*GetArchiveRequest)(nil),                                   // 21: gitaly.GetArchiveRequest
	(*GetArchiveResponse)(nil),                                  // 22: gitaly.GetArchiveResponse
	(*HasLocalBranchesRequest)(nil),                             // 23: gitaly.HasLocalBranchesRequest
	(*HasLocalBranchesResponse)(nil),                            // 24: gitaly.HasLocalBranchesResponse
	(*FetchSourceBranchRequest)(nil),                            // 25: gitaly.FetchSourceBranchRequest
	(*FetchSourceBranchResponse)(nil),                           // 26: gitaly.FetchSourceBranchResponse
	(*FsckRequest)(nil),                                         // 27: gitaly.FsckRequest
	(*FsckResponse)(nil),                                        // 28: gitaly.FsckResponse
	(*WriteRefRequest)(nil),                                     // 29: gitaly.WriteRefRequest
	(*WriteRefResponse)(nil),                                    // 30: gitaly.WriteRefResponse
	(*FindMergeBaseRequest)(nil),                                // 31: gitaly.FindMergeBaseRequest
	(*FindMergeBaseResponse)(nil),                               // 32: gitaly.FindMergeBaseResponse
	(*CreateForkRequest)(nil),                                   // 33: gitaly.CreateForkRequest
	(*CreateForkResponse)(nil),                                  // 34: gitaly.CreateForkResponse
	(*CreateRepositoryFromURLRequest)(nil),                      // 35: gitaly.CreateRepositoryFromURLRequest
	(*CreateRepositoryFromURLResponse)(nil),                     // 36: gitaly.CreateRepositoryFromURLResponse
	(*CreateRepositoryFromURLError)(nil),                        // 37: gitaly.CreateRepositoryFromURLError
	(*CreateBundleRequest)(nil),                                 // 38: gitaly.CreateBundleRequest
	(*CreateBundleResponse)(nil),                                // 39: gitaly.CreateBundleResponse
	(*CreateBundleFromRefListRequest)(nil),                      // 40: gitaly.CreateBundleFromRefListRequest
	(*CreateBundleFromRefListResponse)(nil),                     // 41: gitaly.CreateBundleFromRefListResponse
	(*GenerateBundleURIRequest)(nil),                            // 42: gitaly.GenerateBundleURIRequest
	(*GenerateBundleURIResponse)(nil),                           // 43: gitaly.GenerateBundleURIResponse
	(*GetConfigRequest)(nil),                                    // 44: gitaly.GetConfigRequest
	(*GetConfigResponse)(nil),                                   // 45: gitaly.GetConfigResponse
	(*RestoreCustomHooksRequest)(nil),                           // 46: gitaly.RestoreCustomHooksRequest
	(*SetCustomHooksRequest)(nil),                               // 47: gitaly.SetCustomHooksRequest
	(*RestoreCustomHooksResponse)(nil),                          // 48: gitaly.RestoreCustomHooksResponse
	(*SetCustomHooksResponse)(nil),                              // 49: gitaly.SetCustomHooksResponse
	(*BackupCustomHooksRequest)(nil),                            // 50: gitaly.BackupCustomHooksRequest
	(*GetCustomHooksRequest)(nil),                               // 51: gitaly.GetCustomHooksRequest
	(*BackupCustomHooksResponse)(nil),                           // 52: gitaly.BackupCustomHooksResponse
	(*GetCustomHooksResponse)(nil),                              // 53: gitaly.GetCustomHooksResponse
	(*CreateRepositoryFromBundleRequest)(nil),                   // 54: gitaly.CreateRepositoryFromBundleRequest
	(*CreateRepositoryFromBundleResponse)(nil),                  // 55: gitaly.CreateRepositoryFromBundleResponse
	(*FindLicenseRequest)(nil),                                  // 56: gitaly.FindLicenseRequest
	(*FindLicenseResponse)(nil),                                 // 57: gitaly.FindLicenseResponse
	(*GetInfoAttributesRequest)(nil),                            // 58: gitaly.GetInfoAttributesRequest
	(*GetInfoAttributesResponse)(nil),                           // 59: gitaly.GetInfoAttributesResponse
	(*CalculateChecksumRequest)(nil),                            // 60: gitaly.CalculateChecksumRequest
	(*CalculateChecksumResponse)(nil),                           // 61: gitaly.CalculateChecksumResponse
	(*GetSnapshotRequest)(nil),                                  // 62: gitaly.GetSnapshotRequest
	(*GetSnapshotResponse)(nil),                                 // 63: gitaly.GetSnapshotResponse
	(*CreateRepositoryFromSnapshotRequest)(nil),                 // 64: gitaly.CreateRepositoryFromSnapshotRequest
	(*CreateRepositoryFromSnapshotResponse)(nil),                // 65: gitaly.CreateRepositoryFromSnapshotResponse
	(*GetRawChangesRequest)(nil),                                // 66: gitaly.GetRawChangesRequest
	(*GetRawChangesResponse)(nil),                               // 67: gitaly.GetRawChangesResponse
	(*SearchFilesByNameRequest)(nil),                            // 68: gitaly.SearchFilesByNameRequest
	(*SearchFilesByNameResponse)(nil),                           // 69: gitaly.SearchFilesByNameResponse
	(*SearchFilesByContentRequest)(nil),                         // 70: gitaly.SearchFilesByContentRequest
	(*SearchFilesByContentResponse)(nil),                        // 71: gitaly.SearchFilesByContentResponse
	(*Remote)(nil),                                              // 72: gitaly.Remote
	(*GetObjectDirectorySizeRequest)(nil),                       // 73: gitaly.GetObjectDirectorySizeRequest
	(*GetObjectDirectorySizeResponse)(nil),                      // 74: gitaly.GetObjectDirectorySizeResponse
	(*RemoveRepositoryRequest)(nil),                             // 75: gitaly.RemoveRepositoryRequest
	(*RemoveRepositoryResponse)(nil),                            // 76: gitaly.RemoveRepositoryResponse
	(*ReplicateRepositoryRequest)(nil),                          // 77: gitaly.ReplicateRepositoryRequest
	(*ReplicateRepositoryResponse)(nil),                         // 78: gitaly.ReplicateRepositoryResponse
	(*OptimizeRepositoryRequest)(nil),                           // 79: gitaly.OptimizeRepositoryRequest
	(*OptimizeRepositoryResponse)(nil),                          // 80: gitaly.OptimizeRepositoryResponse
	(*PruneUnreachableObjectsRequest)(nil),                      // 81: gitaly.PruneUnreachableObjectsRequest
	(*PruneUnreachableObjectsResponse)(nil),                     // 82: gitaly.PruneUnreachableObjectsResponse
	(*BackupRepositoryRequest)(nil),                             // 83: gitaly.BackupRepositoryRequest
	(*BackupRepositoryResponse)(nil),                            // 84: gitaly.BackupRepositoryResponse
	(*RestoreRepositoryRequest)(nil),                            // 85: gitaly.RestoreRepositoryRequest
	(*RestoreRepositoryResponse)(nil),                           // 86: gitaly.RestoreRepositoryResponse
	(*GetFileAttributesRequest)(nil),                            // 87: gitaly.GetFileAttributesRequest
	(*GetFileAttributesResponse)(nil),                           // 88: gitaly.GetFileAttributesResponse
	(*FastExportRequest)(nil),                                   // 89: gitaly.FastExportRequest
	(*FastExportResponse)(nil),                                  // 90: gitaly.FastExportResponse
	(*MigrateReferenceBackendRequest)(nil),                      // 91: gitaly.MigrateReferenceBackendRequest
	(*MigrateReferenceBackendResponse)(nil),                     // 92: gitaly.MigrateReferenceBackendResponse
	(*RepositoryInfoResponse_ReferencesInfo)(nil),               // 93: gitaly.RepositoryInfoResponse.ReferencesInfo
	(*RepositoryInfoResponse_ObjectsInfo)(nil),                  // 94: gitaly.RepositoryInfoResponse.ObjectsInfo
	(*RepositoryInfoResponse_CommitGraphInfo)(nil),              // 95: gitaly.RepositoryInfoResponse.CommitGraphInfo
	(*RepositoryInfoResponse_BitmapInfo)(nil),                   // 96: gitaly.RepositoryInfoResponse.BitmapInfo
	(*RepositoryInfoResponse_MultiPackIndexInfo)(nil),           // 97: gitaly.RepositoryInfoResponse.MultiPackIndexInfo
	(*RepositoryInfoResponse_AlternatesInfo)(nil),               // 98: gitaly.RepositoryInfoResponse.AlternatesInfo
	(*GetRawChangesResponse_RawChange)(nil),                     // 99: gitaly.GetRawChangesResponse.RawChange
	(*BackupRepositoryResponse_SkippedError)(nil),               // 100: gitaly.BackupRepositoryResponse.SkippedError
	(*RestoreRepositoryResponse_SkippedError)(nil),              // 101: gitaly.RestoreRepositoryResponse.SkippedError
	(*GetFileAttributesResponse_AttributeInfo)(nil),             // 102: gitaly.GetFileAttributesResponse.AttributeInfo
	(*Repository)(nil),                                          // 103: gitaly.Repository
	(*timestamppb.Timestamp)(nil),                               // 104: google.protobuf.Timestamp
	(ObjectFormat)(0),                                           // 105: gitaly.ObjectFormat
	(*RemoteNotFoundError)(nil),                                 // 106: gitaly.RemoteNotFoundError
	(*durationpb.Duration)(nil),                                 // 107: google.protobuf.Duration
}
var file_repository_proto_depIdxs = []int32{
	103, // 0: gitaly.RepositoryExistsRequest.repository:type_name -> gitaly.Repository
	103, // 1: gitaly.RepositorySizeRequest.repository:type_name -> gitaly.Repository
	103, // 2: gitaly.RepositoryInfoRequest.repository:type_name -> gitaly.Repository
	93,  // 3: gitaly.RepositoryInfoResponse.references:type_name -> gitaly.RepositoryInfoResponse.ReferencesInfo
	94,  // 4: gitaly.RepositoryInfoResponse.objects:type_name -> gitaly.RepositoryInfoResponse.ObjectsInfo
	95,  // 5: gitaly.RepositoryInfoResponse.commit_graph:type_name -> gitaly.RepositoryInfoResponse.CommitGraphInfo
	96,  // 6: gitaly.RepositoryInfoResponse.bitmap:type_name -> gitaly.RepositoryInfoResponse.BitmapInfo
	97,  // 7: gitaly.RepositoryInfoResponse.multi_pack_index:type_name -> gitaly.RepositoryInfoResponse.MultiPackIndexInfo
	96,  // 8: gitaly.RepositoryInfoResponse.multi_pack_index_bitmap:type_name -> gitaly.RepositoryInfoResponse.BitmapInfo
	98,  // 9: gitaly.RepositoryInfoResponse.alternates:type_name -> gitaly.RepositoryInfoResponse.AlternatesInfo
	104, // 10: gitaly.RepositoryInfoResponse.last_full_repack:type_name -> google.protobuf.Timestamp
	103, // 11: gitaly.ObjectsSizeRequest.repository:type_name -> gitaly.Repository
	103, // 12: gitaly.ObjectFormatRequest.repository:type_name -> gitaly.Repository
	105, // 13: gitaly.ObjectFormatResponse.format:type_name -> gitaly.ObjectFormat
	103, // 14: gitaly.FetchBundleRequest.repository:type_name -> gitaly.Repository
	103, // 15: gitaly.FetchRemoteRequest.repository:type_name -> gitaly.Repository
	72,  // 16: gitaly.FetchRemoteRequest.remote_params:type_name -> gitaly.Remote
	103, // 17: gitaly.CreateRepositoryRequest.repository:type_name -> gitaly.Repository
	105, // 18: gitaly.CreateRepositoryRequest.object_format:type_name -> gitaly.ObjectFormat
	103, // 19: gitaly.GetArchiveRequest.repository:type_name -> gitaly.Repository
	1,   // 20: gitaly.GetArchiveRequest.format:type_name -> gitaly.GetArchiveRequest.Format
	103, // 21: gitaly.HasLocalBranchesRequest.repository:type_name -> gitaly.Repository
	103, // 22: gitaly.FetchSourceBranchRequest.repository:type_name -> gitaly.Repository
	103, // 23: gitaly.FetchSourceBranchRequest.source_repository:type_name -> gitaly.Repository
	103, // 24: gitaly.FsckRequest.repository:type_name -> gitaly.Repository
	103, // 25: gitaly.WriteRefRequest.repository:type_name -> gitaly.Repository
	103, // 26: gitaly.FindMergeBaseRequest.repository:type_name -> gitaly.Repository
	103, // 27: gitaly.CreateForkRequest.repository:type_name -> gitaly.Repository
	103, // 28: gitaly.CreateForkRequest.source_repository:type_name -> gitaly.Repository
	103, // 29: gitaly.CreateRepositoryFromURLRequest.repository:type_name -> gitaly.Repository
	106, // 30: gitaly.CreateRepositoryFromURLError.remote_not_found:type_name -> gitaly.RemoteNotFoundError
	103, // 31: gitaly.CreateBundleRequest.repository:type_name -> gitaly.Repository
	103, // 32: gitaly.CreateBundleFromRefListRequest.repository:type_name -> gitaly.Repository
	103, // 33: gitaly.GenerateBundleURIRequest.repository:type_name -> gitaly.Repository
	103, // 34: gitaly.GetConfigRequest.repository:type_name -> gitaly.Repository
	103, // 35: gitaly.RestoreCustomHooksRequest.repository:type_name -> gitaly.Repository
	103, // 36: gitaly.SetCustomHooksRequest.repository:type_name -> gitaly.Repository
	103, // 37: gitaly.BackupCustomHooksRequest.repository:type_name -> gitaly.Repository
	103, // 38: gitaly.GetCustomHooksRequest.repository:type_name -> gitaly.Repository
	103, // 39: gitaly.CreateRepositoryFromBundleRequest.repository:type_name -> gitaly.Repository
	103, // 40: gitaly.FindLicenseRequest.repository:type_name -> gitaly.Repository
	103, // 41: gitaly.GetInfoAttributesRequest.repository:type_name -> gitaly.Repository
	103, // 42: gitaly.CalculateChecksumRequest.repository:type_name -> gitaly.Repository
	103, // 43: gitaly.GetSnapshotRequest.repository:type_name -> gitaly.Repository
	103, // 44: gitaly.CreateRepositoryFromSnapshotRequest.repository:type_name -> gitaly.Repository
	103, // 45: gitaly.GetRawChangesRequest.repository:type_name -> gitaly.Repository
	99,  // 46: gitaly.GetRawChangesResponse.raw_changes:type_name -> gitaly.GetRawChangesResponse.RawChange
	103, // 47: gitaly.SearchFilesByNameRequest.repository:type_name -> gitaly.Repository
	103, // 48: gitaly.SearchFilesByContentRequest.repository:type_name -> gitaly.Repository
	103, // 49: gitaly.GetObjectDirectorySizeRequest.repository:type_name -> gitaly.Repository
	103, // 50: gitaly.RemoveRepositoryRequest.repository:type_name -> gitaly.Repository
	103, // 51: gitaly.ReplicateRepositoryRequest.repository:type_name -> gitaly.Repository
	103, // 52: gitaly.ReplicateRepositoryRequest.source:type_name -> gitaly.Repository
	103, // 53: gitaly.OptimizeRepositoryRequest.repository:type_name -> gitaly.Repository
	3,   // 54: gitaly.OptimizeRepositoryRequest.strategy:type_name -> gitaly.OptimizeRepositoryRequest.Strategy
	103, // 55: gitaly.PruneUnreachableObjectsRequest.repository:type_name -> gitaly.Repository
	103, // 56: gitaly.BackupRepositoryRequest.repository:type_name -> gitaly.Repository
	103, // 57: gitaly.BackupRepositoryRequest.vanity_repository:type_name -> gitaly.Repository
	103, // 58: gitaly.RestoreRepositoryRequest.repository:type_name -> gitaly.Repository
	103, // 59: gitaly.RestoreRepositoryRequest.vanity_repository:type_name -> gitaly.Repository
	103, // 60: gitaly.GetFileAttributesRequest.repository:type_name -> gitaly.Repository
	102, // 61: gitaly.GetFileAttributesResponse.attribute_infos:type_name -> gitaly.GetFileAttributesResponse.AttributeInfo
	103, // 62: gitaly.FastExportRequest.repository:type_name -> gitaly.Repository
	103, // 63: gitaly.MigrateReferenceBackendRequest.repository:type_name -> gitaly.Repository
	4,   // 64: gitaly.MigrateReferenceBackendRequest.target_reference_backend:type_name -> gitaly.MigrateReferenceBackendRequest.ReferenceBackend
	107, // 65: gitaly.MigrateReferenceBackendResponse.time:type_name -> google.protobuf.Duration
	0,   // 66: gitaly.RepositoryInfoResponse.ReferencesInfo.reference_backend:type_name -> gitaly.RepositoryInfoResponse.ReferencesInfo.ReferenceBackend
	104, // 67: gitaly.RepositoryInfoResponse.AlternatesInfo.last_modified:type_name -> google.protobuf.Timestamp
	2,   // 68: gitaly.GetRawChangesResponse.RawChange.operation:type_name -> gitaly.GetRawChangesResponse.RawChange.Operation
	5,   // 69: gitaly.RepositoryService.RepositoryExists:input_type -> gitaly.RepositoryExistsRequest
	7,   // 70: gitaly.RepositoryService.RepositorySize:input_type -> gitaly.RepositorySizeRequest
	9,   // 71: gitaly.RepositoryService.RepositoryInfo:input_type -> gitaly.RepositoryInfoRequest
	11,  // 72: gitaly.RepositoryService.ObjectsSize:input_type -> gitaly.ObjectsSizeRequest
	13,  // 73: gitaly.RepositoryService.ObjectFormat:input_type -> gitaly.ObjectFormatRequest
	17,  // 74: gitaly.RepositoryService.FetchRemote:input_type -> gitaly.FetchRemoteRequest
	19,  // 75: gitaly.RepositoryService.CreateRepository:input_type -> gitaly.CreateRepositoryRequest
	21,  // 76: gitaly.RepositoryService.GetArchive:input_type -> gitaly.GetArchiveRequest
	23,  // 77: gitaly.RepositoryService.HasLocalBranches:input_type -> gitaly.HasLocalBranchesRequest
	25,  // 78: gitaly.RepositoryService.FetchSourceBranch:input_type -> gitaly.FetchSourceBranchRequest
	27,  // 79: gitaly.RepositoryService.Fsck:input_type -> gitaly.FsckRequest
	29,  // 80: gitaly.RepositoryService.WriteRef:input_type -> gitaly.WriteRefRequest
	31,  // 81: gitaly.RepositoryService.FindMergeBase:input_type -> gitaly.FindMergeBaseRequest
	33,  // 82: gitaly.RepositoryService.CreateFork:input_type -> gitaly.CreateForkRequest
	35,  // 83: gitaly.RepositoryService.CreateRepositoryFromURL:input_type -> gitaly.CreateRepositoryFromURLRequest
	38,  // 84: gitaly.RepositoryService.CreateBundle:input_type -> gitaly.CreateBundleRequest
	40,  // 85: gitaly.RepositoryService.CreateBundleFromRefList:input_type -> gitaly.CreateBundleFromRefListRequest
	42,  // 86: gitaly.RepositoryService.GenerateBundleURI:input_type -> gitaly.GenerateBundleURIRequest
	15,  // 87: gitaly.RepositoryService.FetchBundle:input_type -> gitaly.FetchBundleRequest
	54,  // 88: gitaly.RepositoryService.CreateRepositoryFromBundle:input_type -> gitaly.CreateRepositoryFromBundleRequest
	44,  // 89: gitaly.RepositoryService.GetConfig:input_type -> gitaly.GetConfigRequest
	56,  // 90: gitaly.RepositoryService.FindLicense:input_type -> gitaly.FindLicenseRequest
	58,  // 91: gitaly.RepositoryService.GetInfoAttributes:input_type -> gitaly.GetInfoAttributesRequest
	60,  // 92: gitaly.RepositoryService.CalculateChecksum:input_type -> gitaly.CalculateChecksumRequest
	62,  // 93: gitaly.RepositoryService.GetSnapshot:input_type -> gitaly.GetSnapshotRequest
	64,  // 94: gitaly.RepositoryService.CreateRepositoryFromSnapshot:input_type -> gitaly.CreateRepositoryFromSnapshotRequest
	66,  // 95: gitaly.RepositoryService.GetRawChanges:input_type -> gitaly.GetRawChangesRequest
	70,  // 96: gitaly.RepositoryService.SearchFilesByContent:input_type -> gitaly.SearchFilesByContentRequest
	68,  // 97: gitaly.RepositoryService.SearchFilesByName:input_type -> gitaly.SearchFilesByNameRequest
	46,  // 98: gitaly.RepositoryService.RestoreCustomHooks:input_type -> gitaly.RestoreCustomHooksRequest
	47,  // 99: gitaly.RepositoryService.SetCustomHooks:input_type -> gitaly.SetCustomHooksRequest
	50,  // 100: gitaly.RepositoryService.BackupCustomHooks:input_type -> gitaly.BackupCustomHooksRequest
	51,  // 101: gitaly.RepositoryService.GetCustomHooks:input_type -> gitaly.GetCustomHooksRequest
	73,  // 102: gitaly.RepositoryService.GetObjectDirectorySize:input_type -> gitaly.GetObjectDirectorySizeRequest
	75,  // 103: gitaly.RepositoryService.RemoveRepository:input_type -> gitaly.RemoveRepositoryRequest
	77,  // 104: gitaly.RepositoryService.ReplicateRepository:input_type -> gitaly.ReplicateRepositoryRequest
	79,  // 105: gitaly.RepositoryService.OptimizeRepository:input_type -> gitaly.OptimizeRepositoryRequest
	81,  // 106: gitaly.RepositoryService.PruneUnreachableObjects:input_type -> gitaly.PruneUnreachableObjectsRequest
	83,  // 107: gitaly.RepositoryService.BackupRepository:input_type -> gitaly.BackupRepositoryRequest
	85,  // 108: gitaly.RepositoryService.RestoreRepository:input_type -> gitaly.RestoreRepositoryRequest
	87,  // 109: gitaly.RepositoryService.GetFileAttributes:input_type -> gitaly.GetFileAttributesRequest
	89,  // 110: gitaly.RepositoryService.FastExport:input_type -> gitaly.FastExportRequest
	91,  // 111: gitaly.RepositoryService.MigrateReferenceBackend:input_type -> gitaly.MigrateReferenceBackendRequest
	6,   // 112: gitaly.RepositoryService.RepositoryExists:output_type -> gitaly.RepositoryExistsResponse
	8,   // 113: gitaly.RepositoryService.RepositorySize:output_type -> gitaly.RepositorySizeResponse
	10,  // 114: gitaly.RepositoryService.RepositoryInfo:output_type -> gitaly.RepositoryInfoResponse
	12,  // 115: gitaly.RepositoryService.ObjectsSize:output_type -> gitaly.ObjectsSizeResponse
	14,  // 116: gitaly.RepositoryService.ObjectFormat:output_type -> gitaly.ObjectFormatResponse
	18,  // 117: gitaly.RepositoryService.FetchRemote:output_type -> gitaly.FetchRemoteResponse
	20,  // 118: gitaly.RepositoryService.CreateRepository:output_type -> gitaly.CreateRepositoryResponse
	22,  // 119: gitaly.RepositoryService.GetArchive:output_type -> gitaly.GetArchiveResponse
	24,  // 120: gitaly.RepositoryService.HasLocalBranches:output_type -> gitaly.HasLocalBranchesResponse
	26,  // 121: gitaly.RepositoryService.FetchSourceBranch:output_type -> gitaly.FetchSourceBranchResponse
	28,  // 122: gitaly.RepositoryService.Fsck:output_type -> gitaly.FsckResponse
	30,  // 123: gitaly.RepositoryService.WriteRef:output_type -> gitaly.WriteRefResponse
	32,  // 124: gitaly.RepositoryService.FindMergeBase:output_type -> gitaly.FindMergeBaseResponse
	34,  // 125: gitaly.RepositoryService.CreateFork:output_type -> gitaly.CreateForkResponse
	36,  // 126: gitaly.RepositoryService.CreateRepositoryFromURL:output_type -> gitaly.CreateRepositoryFromURLResponse
	39,  // 127: gitaly.RepositoryService.CreateBundle:output_type -> gitaly.CreateBundleResponse
	41,  // 128: gitaly.RepositoryService.CreateBundleFromRefList:output_type -> gitaly.CreateBundleFromRefListResponse
	43,  // 129: gitaly.RepositoryService.GenerateBundleURI:output_type -> gitaly.GenerateBundleURIResponse
	16,  // 130: gitaly.RepositoryService.FetchBundle:output_type -> gitaly.FetchBundleResponse
	55,  // 131: gitaly.RepositoryService.CreateRepositoryFromBundle:output_type -> gitaly.CreateRepositoryFromBundleResponse
	45,  // 132: gitaly.RepositoryService.GetConfig:output_type -> gitaly.GetConfigResponse
	57,  // 133: gitaly.RepositoryService.FindLicense:output_type -> gitaly.FindLicenseResponse
	59,  // 134: gitaly.RepositoryService.GetInfoAttributes:output_type -> gitaly.GetInfoAttributesResponse
	61,  // 135: gitaly.RepositoryService.CalculateChecksum:output_type -> gitaly.CalculateChecksumResponse
	63,  // 136: gitaly.RepositoryService.GetSnapshot:output_type -> gitaly.GetSnapshotResponse
	65,  // 137: gitaly.RepositoryService.CreateRepositoryFromSnapshot:output_type -> gitaly.CreateRepositoryFromSnapshotResponse
	67,  // 138: gitaly.RepositoryService.GetRawChanges:output_type -> gitaly.GetRawChangesResponse
	71,  // 139: gitaly.RepositoryService.SearchFilesByContent:output_type -> gitaly.SearchFilesByContentResponse
	69,  // 140: gitaly.RepositoryService.SearchFilesByName:output_type -> gitaly.SearchFilesByNameResponse
	48,  // 141: gitaly.RepositoryService.RestoreCustomHooks:output_type -> gitaly.RestoreCustomHooksResponse
	49,  // 142: gitaly.RepositoryService.SetCustomHooks:output_type -> gitaly.SetCustomHooksResponse
	52,  // 143: gitaly.RepositoryService.BackupCustomHooks:output_type -> gitaly.BackupCustomHooksResponse
	53,  // 144: gitaly.RepositoryService.GetCustomHooks:output_type -> gitaly.GetCustomHooksResponse
	74,  // 145: gitaly.RepositoryService.GetObjectDirectorySize:output_type -> gitaly.GetObjectDirectorySizeResponse
	76,  // 146: gitaly.RepositoryService.RemoveRepository:output_type -> gitaly.RemoveRepositoryResponse
	78,  // 147: gitaly.RepositoryService.ReplicateRepository:output_type -> gitaly.ReplicateRepositoryResponse
	80,  // 148: gitaly.RepositoryService.OptimizeRepository:output_type -> gitaly.OptimizeRepositoryResponse
	82,  // 149: gitaly.RepositoryService.PruneUnreachableObjects:output_type -> gitaly.PruneUnreachableObjectsResponse
	84,  // 150: gitaly.RepositoryService.BackupRepository:output_type -> gitaly.BackupRepositoryResponse
	86,  // 151: gitaly.RepositoryService.RestoreRepository:output_type -> gitaly.RestoreRepositoryResponse
	88,  // 152: gitaly.RepositoryService.GetFileAttributes:output_type -> gitaly.GetFileAttributesResponse
	90,  // 153: gitaly.RepositoryService.FastExport:output_type -> gitaly.FastExportResponse
	92,  // 154: gitaly.RepositoryService.MigrateReferenceBackend:output_type -> gitaly.MigrateReferenceBackendResponse
	112, // [112:155] is the sub-list for method output_type
	69,  // [69:112] is the sub-list for method input_type
	69,  // [69:69] is the sub-list for extension type_name
	69,  // [69:69] is the sub-list for extension extendee
	0,   // [0:69] is the sub-list for field type_name
}

func init() { file_repository_proto_init() }
func file_repository_proto_init() {
	if File_repository_proto != nil {
		return
	}
	file_errors_proto_init()
	file_lint_proto_init()
	file_shared_proto_init()
	file_repository_proto_msgTypes[32].OneofWrappers = []any{
		(*CreateRepositoryFromURLError_RemoteNotFound)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_repository_proto_rawDesc), len(file_repository_proto_rawDesc)),
			NumEnums:      5,
			NumMessages:   98,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_repository_proto_goTypes,
		DependencyIndexes: file_repository_proto_depIdxs,
		EnumInfos:         file_repository_proto_enumTypes,
		MessageInfos:      file_repository_proto_msgTypes,
	}.Build()
	File_repository_proto = out.File
	file_repository_proto_goTypes = nil
	file_repository_proto_depIdxs = nil
}
