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

package gitalypb

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

// SortBy defines the allowed field names which references can be sorted by.
// https://git-scm.com/docs/git-for-each-ref#Documentation/git-for-each-ref.txt---sortltkeygt
type FindLocalBranchesRequest_SortBy int32

const (
	// NAME is for the `--sort=refname` option and is the default option.
	FindLocalBranchesRequest_NAME FindLocalBranchesRequest_SortBy = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// UPDATED_ASC is for the `--sort=committerdate` option.
	FindLocalBranchesRequest_UPDATED_ASC FindLocalBranchesRequest_SortBy = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// UPDATED_DESC is for the `--sort=-committerdate` option.
	FindLocalBranchesRequest_UPDATED_DESC FindLocalBranchesRequest_SortBy = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for FindLocalBranchesRequest_SortBy.
var (
	FindLocalBranchesRequest_SortBy_name = map[int32]string{
		0: "NAME",
		1: "UPDATED_ASC",
		2: "UPDATED_DESC",
	}
	FindLocalBranchesRequest_SortBy_value = map[string]int32{
		"NAME":         0,
		"UPDATED_ASC":  1,
		"UPDATED_DESC": 2,
	}
)

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

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

func (FindLocalBranchesRequest_SortBy) Descriptor() protoreflect.EnumDescriptor {
	return file_ref_proto_enumTypes[0].Descriptor()
}

func (FindLocalBranchesRequest_SortBy) Type() protoreflect.EnumType {
	return &file_ref_proto_enumTypes[0]
}

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

// Deprecated: Use FindLocalBranchesRequest_SortBy.Descriptor instead.
func (FindLocalBranchesRequest_SortBy) EnumDescriptor() ([]byte, []int) {
	return file_ref_proto_rawDescGZIP(), []int{2, 0}
}

// Key is a key used for sorting.
type FindAllTagsRequest_SortBy_Key int32

const (
	// REFNAME is for the `refname` field and is the default option.
	FindAllTagsRequest_SortBy_REFNAME FindAllTagsRequest_SortBy_Key = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// CREATORDATE is for the `creatordate` field.
	FindAllTagsRequest_SortBy_CREATORDATE FindAllTagsRequest_SortBy_Key = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// VERSION_REFNAME sorts tags by their semantic versions (https://semver.org/).
	// tag names that are not semantic versions are sorted lexicographically. They come before
	// the semantic versions if the direction is ascending and after the semantic versions if
	// the direction is descending.
	FindAllTagsRequest_SortBy_VERSION_REFNAME FindAllTagsRequest_SortBy_Key = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for FindAllTagsRequest_SortBy_Key.
var (
	FindAllTagsRequest_SortBy_Key_name = map[int32]string{
		0: "REFNAME",
		1: "CREATORDATE",
		2: "VERSION_REFNAME",
	}
	FindAllTagsRequest_SortBy_Key_value = map[string]int32{
		"REFNAME":         0,
		"CREATORDATE":     1,
		"VERSION_REFNAME": 2,
	}
)

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

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

func (FindAllTagsRequest_SortBy_Key) Descriptor() protoreflect.EnumDescriptor {
	return file_ref_proto_enumTypes[1].Descriptor()
}

func (FindAllTagsRequest_SortBy_Key) Type() protoreflect.EnumType {
	return &file_ref_proto_enumTypes[1]
}

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

// Deprecated: Use FindAllTagsRequest_SortBy_Key.Descriptor instead.
func (FindAllTagsRequest_SortBy_Key) EnumDescriptor() ([]byte, []int) {
	return file_ref_proto_rawDescGZIP(), []int{9, 0, 0}
}

// Key is a key used for sorting.
// https://git-scm.com/docs/git-for-each-ref#Documentation/git-for-each-ref.txt---sortltkeygt
type ListRefsRequest_SortBy_Key int32

const (
	// REFNAME is for the `refname` field and is the default option.
	ListRefsRequest_SortBy_REFNAME ListRefsRequest_SortBy_Key = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// CREATORDATE is for the `creatordate` field.
	ListRefsRequest_SortBy_CREATORDATE ListRefsRequest_SortBy_Key = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// AUTHORDATE is for the `authordate` field.
	ListRefsRequest_SortBy_AUTHORDATE ListRefsRequest_SortBy_Key = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// COMMITTERDATE is for the `committerdate` field.
	ListRefsRequest_SortBy_COMMITTERDATE ListRefsRequest_SortBy_Key = 3 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for ListRefsRequest_SortBy_Key.
var (
	ListRefsRequest_SortBy_Key_name = map[int32]string{
		0: "REFNAME",
		1: "CREATORDATE",
		2: "AUTHORDATE",
		3: "COMMITTERDATE",
	}
	ListRefsRequest_SortBy_Key_value = map[string]int32{
		"REFNAME":       0,
		"CREATORDATE":   1,
		"AUTHORDATE":    2,
		"COMMITTERDATE": 3,
	}
)

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

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

func (ListRefsRequest_SortBy_Key) Descriptor() protoreflect.EnumDescriptor {
	return file_ref_proto_enumTypes[2].Descriptor()
}

func (ListRefsRequest_SortBy_Key) Type() protoreflect.EnumType {
	return &file_ref_proto_enumTypes[2]
}

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

// Deprecated: Use ListRefsRequest_SortBy_Key.Descriptor instead.
func (ListRefsRequest_SortBy_Key) EnumDescriptor() ([]byte, []int) {
	return file_ref_proto_rawDescGZIP(), []int{31, 0, 0}
}

// FindDefaultBranchNameRequest is a request for the FindDefaultBranchName RPC.
type FindDefaultBranchNameRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to find the default branch from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// head_only when true will determine the default branch using HEAD only
	// instead of using the heuristic. The returned reference may not exist.
	HeadOnly      bool `protobuf:"varint,2,opt,name=head_only,json=headOnly,proto3" json:"head_only,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindDefaultBranchNameRequest) ProtoMessage() {}

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

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

func (x *FindDefaultBranchNameRequest) GetHeadOnly() bool {
	if x != nil {
		return x.HeadOnly
	}
	return false
}

// FindDefaultBranchNameResponse is a response for the FindDefaultBranchName RPC.
type FindDefaultBranchNameResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// name is the fully qualified default branch name.
	Name          []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindDefaultBranchNameResponse) ProtoMessage() {}

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

func (x *FindDefaultBranchNameResponse) GetName() []byte {
	if x != nil {
		return x.Name
	}
	return nil
}

// FindLocalBranchesRequest is a request for the FindLocalBranches RPC.
type FindLocalBranchesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to find the branch in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// sort_by sets which field the returned branches are sorted by.
	SortBy FindLocalBranchesRequest_SortBy `protobuf:"varint,2,opt,name=sort_by,json=sortBy,proto3,enum=gitaly.FindLocalBranchesRequest_SortBy" json:"sort_by,omitempty"`
	// pagination_params controls paging. Refer to PaginationParameter documentation for
	// further info.
	PaginationParams *PaginationParameter `protobuf:"bytes,3,opt,name=pagination_params,json=paginationParams,proto3" json:"pagination_params,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*FindLocalBranchesRequest) ProtoMessage() {}

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

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

func (x *FindLocalBranchesRequest) GetSortBy() FindLocalBranchesRequest_SortBy {
	if x != nil {
		return x.SortBy
	}
	return FindLocalBranchesRequest_NAME
}

func (x *FindLocalBranchesRequest) GetPaginationParams() *PaginationParameter {
	if x != nil {
		return x.PaginationParams
	}
	return nil
}

// FindLocalBranchesResponse is a response for the FindLocalBranches RPC.
type FindLocalBranchesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// local_branches is a list of local branches found in the repository.
	LocalBranches []*Branch `protobuf:"bytes,2,rep,name=local_branches,json=localBranches,proto3" json:"local_branches,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindLocalBranchesResponse) ProtoMessage() {}

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

func (x *FindLocalBranchesResponse) GetLocalBranches() []*Branch {
	if x != nil {
		return x.LocalBranches
	}
	return nil
}

// FindAllBranchesRequest is a request for the FindAllBranches RPC.
type FindAllBranchesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to find the branch in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// merged_only if set, will only return branches that are merged into root ref.
	MergedOnly bool `protobuf:"varint,2,opt,name=merged_only,json=mergedOnly,proto3" json:"merged_only,omitempty"`
	// merged_branches is the list of branches from which we return those merged into
	// the root ref. Used only when merged_only is set to true.
	MergedBranches [][]byte `protobuf:"bytes,3,rep,name=merged_branches,json=mergedBranches,proto3" json:"merged_branches,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*FindAllBranchesRequest) ProtoMessage() {}

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

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

func (x *FindAllBranchesRequest) GetMergedOnly() bool {
	if x != nil {
		return x.MergedOnly
	}
	return false
}

func (x *FindAllBranchesRequest) GetMergedBranches() [][]byte {
	if x != nil {
		return x.MergedBranches
	}
	return nil
}

// FindAllBranchesResponse is a response for the FindAllBranches RPC.
type FindAllBranchesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// branches is a list of branches found in the repository.
	Branches      []*FindAllBranchesResponse_Branch `protobuf:"bytes,1,rep,name=branches,proto3" json:"branches,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindAllBranchesResponse) ProtoMessage() {}

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

func (x *FindAllBranchesResponse) GetBranches() []*FindAllBranchesResponse_Branch {
	if x != nil {
		return x.Branches
	}
	return nil
}

// FindTagRequest is a request for the FindTag RPC.
type FindTagRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to look up the tag in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// tag_name is the name of the tag that should be looked up. The caller is supposed to pass in the
	// tag name only, so if e.g. a tag `refs/tags/v1.0.0` exists, then the caller should pass `v1.0.0`
	// as argument.
	TagName       []byte `protobuf:"bytes,2,opt,name=tag_name,json=tagName,proto3" json:"tag_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindTagRequest) ProtoMessage() {}

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

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

func (x *FindTagRequest) GetTagName() []byte {
	if x != nil {
		return x.TagName
	}
	return nil
}

// FindTagResponse is a response for the FindTag RPC.
type FindTagResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// tag is the tag that was found.
	Tag           *Tag `protobuf:"bytes,1,opt,name=tag,proto3" json:"tag,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindTagResponse) ProtoMessage() {}

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

func (x *FindTagResponse) GetTag() *Tag {
	if x != nil {
		return x.Tag
	}
	return nil
}

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

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

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

func (*FindTagError) ProtoMessage() {}

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

func (x *FindTagError) GetError() isFindTagError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *FindTagError) GetTagNotFound() *ReferenceNotFoundError {
	if x != nil {
		if x, ok := x.Error.(*FindTagError_TagNotFound); ok {
			return x.TagNotFound
		}
	}
	return nil
}

type isFindTagError_Error interface {
	isFindTagError_Error()
}

type FindTagError_TagNotFound struct {
	// tag_not_found indicates that the tag was not found.
	TagNotFound *ReferenceNotFoundError `protobuf:"bytes,1,opt,name=tag_not_found,json=tagNotFound,proto3,oneof"`
}

func (*FindTagError_TagNotFound) isFindTagError_Error() {}

// FindAllTagsRequest is a request for the FindAllTags RPC.
type FindAllTagsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to look up the tags in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// sort_by allows to request tags in particular order.
	SortBy *FindAllTagsRequest_SortBy `protobuf:"bytes,2,opt,name=sort_by,json=sortBy,proto3" json:"sort_by,omitempty"`
	// pagination_params controls paging. Refer to PaginationParameter documentation for
	// further info.
	PaginationParams *PaginationParameter `protobuf:"bytes,3,opt,name=pagination_params,json=paginationParams,proto3" json:"pagination_params,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*FindAllTagsRequest) ProtoMessage() {}

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

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

func (x *FindAllTagsRequest) GetSortBy() *FindAllTagsRequest_SortBy {
	if x != nil {
		return x.SortBy
	}
	return nil
}

func (x *FindAllTagsRequest) GetPaginationParams() *PaginationParameter {
	if x != nil {
		return x.PaginationParams
	}
	return nil
}

// FindAllTagsResponse is a response for the FindAllTags RPC.
type FindAllTagsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// tags is a list of the found tags.
	Tags          []*Tag `protobuf:"bytes,1,rep,name=tags,proto3" json:"tags,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindAllTagsResponse) ProtoMessage() {}

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

func (x *FindAllTagsResponse) GetTags() []*Tag {
	if x != nil {
		return x.Tags
	}
	return nil
}

// RefExistsRequest is a request for the RefExists RPC.
type RefExistsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to check if the reference exists in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// ref denotes any ref, e.g. 'refs/heads/master' or 'refs/tags/v1.0.1'.
	// Must start with 'refs/'.
	Ref           []byte `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RefExistsRequest) ProtoMessage() {}

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

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

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

// RefExistsResponse is a response for the RefExists RPC.
type RefExistsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// value represents if the reference exists.
	Value         bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RefExistsResponse) ProtoMessage() {}

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

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

// FindBranchRequest is a request for the FindBranch RPC.
type FindBranchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which the branch should be looked up.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// name is the name of the branch which should be looked up. This must be the
	// branch name only, it must not have the "refs/heads/" prefix.
	Name          []byte `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindBranchRequest) ProtoMessage() {}

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

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

func (x *FindBranchRequest) GetName() []byte {
	if x != nil {
		return x.Name
	}
	return nil
}

// FindBranchResponse is a response for the FindBranch RPC.
type FindBranchResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// branch is the found branch.
	Branch        *Branch `protobuf:"bytes,1,opt,name=branch,proto3" json:"branch,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindBranchResponse) ProtoMessage() {}

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

func (x *FindBranchResponse) GetBranch() *Branch {
	if x != nil {
		return x.Branch
	}
	return nil
}

// UpdateReferencesRequest is a request for the UpdateReferences RPC.
type UpdateReferencesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository where references shall be updated in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// updates is the set of reference updates that shall be performed.
	Updates       []*UpdateReferencesRequest_Update `protobuf:"bytes,2,rep,name=updates,proto3" json:"updates,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateReferencesRequest) ProtoMessage() {}

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

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

func (x *UpdateReferencesRequest) GetUpdates() []*UpdateReferencesRequest_Update {
	if x != nil {
		return x.Updates
	}
	return nil
}

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

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

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

func (*UpdateReferencesResponse) ProtoMessage() {}

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

// UpdateReferencesError is returned when UpdateReferences fails to update references in some specific well-defined
// cases.
type UpdateReferencesError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UpdateReferencesError_InvalidFormat
	//	*UpdateReferencesError_ReferencesLocked
	//	*UpdateReferencesError_ReferenceStateMismatch
	Error         isUpdateReferencesError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateReferencesError) ProtoMessage() {}

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

func (x *UpdateReferencesError) GetError() isUpdateReferencesError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UpdateReferencesError) GetInvalidFormat() *InvalidRefFormatError {
	if x != nil {
		if x, ok := x.Error.(*UpdateReferencesError_InvalidFormat); ok {
			return x.InvalidFormat
		}
	}
	return nil
}

func (x *UpdateReferencesError) GetReferencesLocked() *ReferencesLockedError {
	if x != nil {
		if x, ok := x.Error.(*UpdateReferencesError_ReferencesLocked); ok {
			return x.ReferencesLocked
		}
	}
	return nil
}

func (x *UpdateReferencesError) GetReferenceStateMismatch() *ReferenceStateMismatchError {
	if x != nil {
		if x, ok := x.Error.(*UpdateReferencesError_ReferenceStateMismatch); ok {
			return x.ReferenceStateMismatch
		}
	}
	return nil
}

type isUpdateReferencesError_Error interface {
	isUpdateReferencesError_Error()
}

type UpdateReferencesError_InvalidFormat struct {
	// invalid_format is returned when one or more of the refs to be deleted
	// have an invalid format.
	InvalidFormat *InvalidRefFormatError `protobuf:"bytes,1,opt,name=invalid_format,json=invalidFormat,proto3,oneof"`
}

type UpdateReferencesError_ReferencesLocked struct {
	// references_locked is returned when the references to be deleted are already
	// locked by another process.
	ReferencesLocked *ReferencesLockedError `protobuf:"bytes,2,opt,name=references_locked,json=referencesLocked,proto3,oneof"`
}

type UpdateReferencesError_ReferenceStateMismatch struct {
	// reference_state_mismatch is return for unforced reference updates when the expected object ID does not match
	// the actual object ID of the reference. This indicates either mismatching expectations or a race with another
	// client that has updated the reference concurrently.
	ReferenceStateMismatch *ReferenceStateMismatchError `protobuf:"bytes,3,opt,name=reference_state_mismatch,json=referenceStateMismatch,proto3,oneof"`
}

func (*UpdateReferencesError_InvalidFormat) isUpdateReferencesError_Error() {}

func (*UpdateReferencesError_ReferencesLocked) isUpdateReferencesError_Error() {}

func (*UpdateReferencesError_ReferenceStateMismatch) isUpdateReferencesError_Error() {}

// DeleteRefsRequest is a request for the DeleteRefs RPC.
type DeleteRefsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository that reference is deleted from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// except_with_prefix is the prefix used to determine which references to exclude from being deleted.
	// This field can not be set in combination with the refs field. If the refs field is not set, except_with_prefix
	// must contain at least one prefix as deleting all references in not allowed.
	ExceptWithPrefix [][]byte `protobuf:"bytes,2,rep,name=except_with_prefix,json=exceptWithPrefix,proto3" json:"except_with_prefix,omitempty"` // protolint:disable:this REPEATED_FIELD_NAMES_PLURALIZED
	// refs is the list of references to be deleted. This field can not be set in combination with except_with_prefix
	// and cannot be empty if except_with_prefix is also empty.
	Refs          [][]byte `protobuf:"bytes,3,rep,name=refs,proto3" json:"refs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DeleteRefsRequest) ProtoMessage() {}

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

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

func (x *DeleteRefsRequest) GetExceptWithPrefix() [][]byte {
	if x != nil {
		return x.ExceptWithPrefix
	}
	return nil
}

func (x *DeleteRefsRequest) GetRefs() [][]byte {
	if x != nil {
		return x.Refs
	}
	return nil
}

// DeleteRefsResponse is a response for the DeleteRefs RPC.
type DeleteRefsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// git_error is a Git error returned by the RPC. Is empty if no error occurs.
	GitError      string `protobuf:"bytes,1,opt,name=git_error,json=gitError,proto3" json:"git_error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DeleteRefsResponse) ProtoMessage() {}

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

func (x *DeleteRefsResponse) GetGitError() string {
	if x != nil {
		return x.GitError
	}
	return ""
}

// DeleteRefsError is returned when DeleteRefs fails to delete refs
type DeleteRefsError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*DeleteRefsError_InvalidFormat
	//	*DeleteRefsError_ReferencesLocked
	Error         isDeleteRefsError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DeleteRefsError) ProtoMessage() {}

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

func (x *DeleteRefsError) GetError() isDeleteRefsError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *DeleteRefsError) GetInvalidFormat() *InvalidRefFormatError {
	if x != nil {
		if x, ok := x.Error.(*DeleteRefsError_InvalidFormat); ok {
			return x.InvalidFormat
		}
	}
	return nil
}

func (x *DeleteRefsError) GetReferencesLocked() *ReferencesLockedError {
	if x != nil {
		if x, ok := x.Error.(*DeleteRefsError_ReferencesLocked); ok {
			return x.ReferencesLocked
		}
	}
	return nil
}

type isDeleteRefsError_Error interface {
	isDeleteRefsError_Error()
}

type DeleteRefsError_InvalidFormat struct {
	// invalid_format is returned when one or more of the refs to be deleted
	// have an invalid format.
	InvalidFormat *InvalidRefFormatError `protobuf:"bytes,1,opt,name=invalid_format,json=invalidFormat,proto3,oneof"`
}

type DeleteRefsError_ReferencesLocked struct {
	// references_locked is returned when the references to be deleted are already
	// locked by another process.
	ReferencesLocked *ReferencesLockedError `protobuf:"bytes,2,opt,name=references_locked,json=referencesLocked,proto3,oneof"`
}

func (*DeleteRefsError_InvalidFormat) isDeleteRefsError_Error() {}

func (*DeleteRefsError_ReferencesLocked) isDeleteRefsError_Error() {}

// ListBranchNamesContainingCommitRequest is a request for the ListBranchNamesContainingCommit RPC.
type ListBranchNamesContainingCommitRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to find branches with the specified commit in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// commit_id is the commit ID used to find branches.
	CommitId string `protobuf:"bytes,2,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// limit the number of tag names to be returned
	// If the limit is set to zero, all items will be returned
	Limit         uint32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListBranchNamesContainingCommitRequest) ProtoMessage() {}

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

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

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

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

// ListBranchNamesContainingCommitResponse is a response for the ListBranchNamesContainingCommit RPC.
type ListBranchNamesContainingCommitResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// branch_names contains a list of found branch names.
	BranchNames   [][]byte `protobuf:"bytes,2,rep,name=branch_names,json=branchNames,proto3" json:"branch_names,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListBranchNamesContainingCommitResponse) ProtoMessage() {}

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

func (x *ListBranchNamesContainingCommitResponse) GetBranchNames() [][]byte {
	if x != nil {
		return x.BranchNames
	}
	return nil
}

// ListTagNamesContainingCommitRequest is a request for the ListTagNamesContainingCommit RPC.
type ListTagNamesContainingCommitRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to find tags with the specified commit in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// commit_id is the commit ID used to find tags.
	CommitId string `protobuf:"bytes,2,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// limit the number of tag names to be returned
	// If the limit is set to zero, all items will be returned
	Limit         uint32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListTagNamesContainingCommitRequest) ProtoMessage() {}

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

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

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

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

// ListTagNamesContainingCommitResponse is a response for the ListTagNamesContainingCommit RPC.
type ListTagNamesContainingCommitResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// tag_names contains a list of tag names found.
	TagNames      [][]byte `protobuf:"bytes,2,rep,name=tag_names,json=tagNames,proto3" json:"tag_names,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListTagNamesContainingCommitResponse) ProtoMessage() {}

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

func (x *ListTagNamesContainingCommitResponse) GetTagNames() [][]byte {
	if x != nil {
		return x.TagNames
	}
	return nil
}

// GetTagSignaturesRequest is a request for the GetTagSignatures RPC.
type GetTagSignaturesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which tag signatures should be looked up.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// tag_revisions is the set of revisions which that should be looked up. Revisions
	// supports the syntax as specified by gitrevisions(7). All revisions are expected
	// to resolve to annotated tag objects. At least one revision must be provided.
	TagRevisions  []string `protobuf:"bytes,2,rep,name=tag_revisions,json=tagRevisions,proto3" json:"tag_revisions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetTagSignaturesRequest) ProtoMessage() {}

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

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

func (x *GetTagSignaturesRequest) GetTagRevisions() []string {
	if x != nil {
		return x.TagRevisions
	}
	return nil
}

// GetTagSignaturesResponse is a response for a GetTagSignatures request. Each response
// may contain multiple TagSignatures. In case TagSignatures don't fit into a single
// response, signatures will be batched in multiple responses.
type GetTagSignaturesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// signatures is the set of signatures found.
	Signatures    []*GetTagSignaturesResponse_TagSignature `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetTagSignaturesResponse) ProtoMessage() {}

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

func (x *GetTagSignaturesResponse) GetSignatures() []*GetTagSignaturesResponse_TagSignature {
	if x != nil {
		return x.Signatures
	}
	return nil
}

// GetTagMessagesRequest is a request for the GetTagMessages RPC.
type GetTagMessagesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to get tag messages from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// tag_ids is the list of annotated tag IDs used to get the tag messages.
	TagIds        []string `protobuf:"bytes,3,rep,name=tag_ids,json=tagIds,proto3" json:"tag_ids,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetTagMessagesRequest) ProtoMessage() {}

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

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

func (x *GetTagMessagesRequest) GetTagIds() []string {
	if x != nil {
		return x.TagIds
	}
	return nil
}

// GetTagMessagesResponse is a response for the GetTagMessages RPC. Annotated tag messages are
// chunked and streamed back to the client across multiple response messages sequentially. Each
// series of responses for a given tag begins with a response that contains only the associated tag
// ID and is subsequently followed by responses containing the tag message contents. This is
// repeated for each annotated tag included as part of the response stream.
type GetTagMessagesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// message content from the annotated tag message.
	Message []byte `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// tag_id is the ID of the tag for which the message belongs.
	TagId         string `protobuf:"bytes,3,opt,name=tag_id,json=tagId,proto3" json:"tag_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetTagMessagesResponse) ProtoMessage() {}

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

func (x *GetTagMessagesResponse) GetMessage() []byte {
	if x != nil {
		return x.Message
	}
	return nil
}

func (x *GetTagMessagesResponse) GetTagId() string {
	if x != nil {
		return x.TagId
	}
	return ""
}

// FindAllRemoteBranchesRequest is a request for the FindAllRemoteBranches RPC.
type FindAllRemoteBranchesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to find remote branches from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// remote_name is the name of the remote repository.
	RemoteName    string `protobuf:"bytes,2,opt,name=remote_name,json=remoteName,proto3" json:"remote_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindAllRemoteBranchesRequest) ProtoMessage() {}

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

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

func (x *FindAllRemoteBranchesRequest) GetRemoteName() string {
	if x != nil {
		return x.RemoteName
	}
	return ""
}

// FindAllRemoteBranchesResponse is a request for the FindAllRemoteBranches RPC.
type FindAllRemoteBranchesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// branches contains a list of found remote branches.
	Branches      []*Branch `protobuf:"bytes,1,rep,name=branches,proto3" json:"branches,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindAllRemoteBranchesResponse) ProtoMessage() {}

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

func (x *FindAllRemoteBranchesResponse) GetBranches() []*Branch {
	if x != nil {
		return x.Branches
	}
	return nil
}

// ListRefsRequest is a request for the ListRefs RPC.
type ListRefsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which references should be listed in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// patterns contains all patterns which shall be listed. Patterns should be in the format
	// accepted by git-for-each-ref(1). At least one pattern must be given, otherwise an error
	// is returned. Patterns which don't match any reference will be silently ignored.
	Patterns [][]byte `protobuf:"bytes,2,rep,name=patterns,proto3" json:"patterns,omitempty"`
	// head determines whether the RPC should also return the HEAD reference. By default,
	// pseudo-refs are not included in the response.
	Head bool `protobuf:"varint,3,opt,name=head,proto3" json:"head,omitempty"`
	// sort_by allows to request SHAs in particular order.
	SortBy *ListRefsRequest_SortBy `protobuf:"bytes,4,opt,name=sort_by,json=sortBy,proto3" json:"sort_by,omitempty"`
	// pointing_at_oids is a list of OIDs that can optionally be passed to only return refs
	// pointing at the given OIDs. This corresponds to the --points-at option of git-for-each-ref(1).
	PointingAtOids [][]byte `protobuf:"bytes,5,rep,name=pointing_at_oids,json=pointingAtOids,proto3" json:"pointing_at_oids,omitempty"`
	// peel_tags controls whether annotated tags should be peeled to their target objects so that the
	// `PeeledTarget` returned for the reference is the ID of the target object. Note that this
	// will significantly slow down the request by a factor of 3 to 4.
	PeelTags bool `protobuf:"varint,6,opt,name=peel_tags,json=peelTags,proto3" json:"peel_tags,omitempty"`
	// pagination_params controls paging. Refer to PaginationParameter documentation for
	// further info.
	PaginationParams *PaginationParameter `protobuf:"bytes,7,opt,name=pagination_params,json=paginationParams,proto3" json:"pagination_params,omitempty"`
	// ignore_case makes pattern matching and sorting case-insensitive.
	// This corresponds to the --ignore-case option of git-for-each-ref(1).
	IgnoreCase    bool `protobuf:"varint,8,opt,name=ignore_case,json=ignoreCase,proto3" json:"ignore_case,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListRefsRequest) ProtoMessage() {}

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

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

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

func (x *ListRefsRequest) GetHead() bool {
	if x != nil {
		return x.Head
	}
	return false
}

func (x *ListRefsRequest) GetSortBy() *ListRefsRequest_SortBy {
	if x != nil {
		return x.SortBy
	}
	return nil
}

func (x *ListRefsRequest) GetPointingAtOids() [][]byte {
	if x != nil {
		return x.PointingAtOids
	}
	return nil
}

func (x *ListRefsRequest) GetPeelTags() bool {
	if x != nil {
		return x.PeelTags
	}
	return false
}

func (x *ListRefsRequest) GetPaginationParams() *PaginationParameter {
	if x != nil {
		return x.PaginationParams
	}
	return nil
}

func (x *ListRefsRequest) GetIgnoreCase() bool {
	if x != nil {
		return x.IgnoreCase
	}
	return false
}

// ListRefsResponse is a response for the ListRefs RPC. The RPC can return multiple responses
// in case there are more references than fit into a single gRPC message.
type ListRefsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// references is the set of references returned by the RPC.
	References []*ListRefsResponse_Reference `protobuf:"bytes,1,rep,name=references,proto3" json:"references,omitempty"`
	// pagination_cursor contains the page token to fetch the next page of results. Refer to PaginationCursor
	// documentation for further info.
	PaginationCursor *PaginationCursor `protobuf:"bytes,2,opt,name=pagination_cursor,json=paginationCursor,proto3" json:"pagination_cursor,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*ListRefsResponse) ProtoMessage() {}

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

func (x *ListRefsResponse) GetReferences() []*ListRefsResponse_Reference {
	if x != nil {
		return x.References
	}
	return nil
}

func (x *ListRefsResponse) GetPaginationCursor() *PaginationCursor {
	if x != nil {
		return x.PaginationCursor
	}
	return nil
}

// FindRefsByOIDRequest is a request for the FindRefsByOID RPC.
type FindRefsByOIDRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which references will be looked for.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// oid is an object ID to find references for.
	Oid string `protobuf:"bytes,2,opt,name=oid,proto3" json:"oid,omitempty"`
	// ref_patterns can be one of branch name, tag name or fully qualified ref name.
	// Providing more than one pattern will yield refs that match any of the given patterns.
	// If left empty, defaults to "refs/heads/" and "refs/tags/"
	RefPatterns []string `protobuf:"bytes,3,rep,name=ref_patterns,json=refPatterns,proto3" json:"ref_patterns,omitempty"`
	// sort_field determines the sort order of the resulting refs.
	// If left empty, defaults to "refname" (lexicographic refname order)
	SortField string `protobuf:"bytes,4,opt,name=sort_field,json=sortField,proto3" json:"sort_field,omitempty"`
	// limit limits the amount of results returned. 0 means no limit.
	Limit         uint32 `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindRefsByOIDRequest) ProtoMessage() {}

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

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

func (x *FindRefsByOIDRequest) GetOid() string {
	if x != nil {
		return x.Oid
	}
	return ""
}

func (x *FindRefsByOIDRequest) GetRefPatterns() []string {
	if x != nil {
		return x.RefPatterns
	}
	return nil
}

func (x *FindRefsByOIDRequest) GetSortField() string {
	if x != nil {
		return x.SortField
	}
	return ""
}

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

// FindRefsByOIDResponse is a response for the FindRefsByOID RPC.
type FindRefsByOIDResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// refs is the set of fully-qualified references which have been found.
	Refs          []string `protobuf:"bytes,1,rep,name=refs,proto3" json:"refs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindRefsByOIDResponse) ProtoMessage() {}

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

func (x *FindRefsByOIDResponse) GetRefs() []string {
	if x != nil {
		return x.Refs
	}
	return nil
}

// Branch is a branch found in the repository.
type FindAllBranchesResponse_Branch struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// name is the name of the branch.
	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// target is the commit referenced by the branch.
	Target        *GitCommit `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindAllBranchesResponse_Branch) ProtoMessage() {}

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

func (x *FindAllBranchesResponse_Branch) GetName() []byte {
	if x != nil {
		return x.Name
	}
	return nil
}

func (x *FindAllBranchesResponse_Branch) GetTarget() *GitCommit {
	if x != nil {
		return x.Target
	}
	return nil
}

// SortBy allows to specify desired order of the elements.
type FindAllTagsRequest_SortBy struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// key is the key that tags are sorted by.
	Key FindAllTagsRequest_SortBy_Key `protobuf:"varint,1,opt,name=key,proto3,enum=gitaly.FindAllTagsRequest_SortBy_Key" json:"key,omitempty"`
	// direction is the direction that tags should be sorted in.
	Direction     SortDirection `protobuf:"varint,2,opt,name=direction,proto3,enum=gitaly.SortDirection" json:"direction,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindAllTagsRequest_SortBy) ProtoMessage() {}

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

func (x *FindAllTagsRequest_SortBy) GetKey() FindAllTagsRequest_SortBy_Key {
	if x != nil {
		return x.Key
	}
	return FindAllTagsRequest_SortBy_REFNAME
}

func (x *FindAllTagsRequest_SortBy) GetDirection() SortDirection {
	if x != nil {
		return x.Direction
	}
	return SortDirection_ASCENDING
}

// Update represents a reference update.
type UpdateReferencesRequest_Update struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// reference is the fully-qualified reference name that should be updated.
	Reference []byte `protobuf:"bytes,1,opt,name=reference,proto3" json:"reference,omitempty"`
	// old_object_id is the object ID the reference should be pointing to in order to be updated.
	// This has the intent to avoid time-of-check-time-of-use-style races when the object ID
	// has changed.
	//
	// If empty, the reference will be force-updated without any such checks. If set to the
	// all-zeroes object ID, this will verify that the branch did not exist previously.
	OldObjectId []byte `protobuf:"bytes,2,opt,name=old_object_id,json=oldObjectId,proto3" json:"old_object_id,omitempty"`
	// new_object_id is the object ID the reference should be updated to. If set to the all-zeroes
	// object ID the branch will be deleted.
	NewObjectId   []byte `protobuf:"bytes,3,opt,name=new_object_id,json=newObjectId,proto3" json:"new_object_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateReferencesRequest_Update) ProtoMessage() {}

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

func (x *UpdateReferencesRequest_Update) GetReference() []byte {
	if x != nil {
		return x.Reference
	}
	return nil
}

func (x *UpdateReferencesRequest_Update) GetOldObjectId() []byte {
	if x != nil {
		return x.OldObjectId
	}
	return nil
}

func (x *UpdateReferencesRequest_Update) GetNewObjectId() []byte {
	if x != nil {
		return x.NewObjectId
	}
	return nil
}

// TagSignature represents the signature of a signed tag.
type GetTagSignaturesResponse_TagSignature struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// tag_id is the resolved object ID of the tag.
	TagId string `protobuf:"bytes,1,opt,name=tag_id,json=tagId,proto3" json:"tag_id,omitempty"`
	// signature contains the cryptographic signature of the tag. If the tag is not
	// cryptographically signed, then the signature is unset.
	Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	// content contains the contents which are signed by the signature. Contents
	// include both the commit message, but also the commit metadata like author and
	// subject.
	Content       []byte `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetTagSignaturesResponse_TagSignature) ProtoMessage() {}

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

func (x *GetTagSignaturesResponse_TagSignature) GetTagId() string {
	if x != nil {
		return x.TagId
	}
	return ""
}

func (x *GetTagSignaturesResponse_TagSignature) GetSignature() []byte {
	if x != nil {
		return x.Signature
	}
	return nil
}

func (x *GetTagSignaturesResponse_TagSignature) GetContent() []byte {
	if x != nil {
		return x.Content
	}
	return nil
}

// SortBy defines the field to sort on and its direction.
type ListRefsRequest_SortBy struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// key is a key used for sorting.
	Key ListRefsRequest_SortBy_Key `protobuf:"varint,1,opt,name=key,proto3,enum=gitaly.ListRefsRequest_SortBy_Key" json:"key,omitempty"`
	// direction is the direction that tags should be sorted in.
	Direction     SortDirection `protobuf:"varint,2,opt,name=direction,proto3,enum=gitaly.SortDirection" json:"direction,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListRefsRequest_SortBy) ProtoMessage() {}

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

func (x *ListRefsRequest_SortBy) GetKey() ListRefsRequest_SortBy_Key {
	if x != nil {
		return x.Key
	}
	return ListRefsRequest_SortBy_REFNAME
}

func (x *ListRefsRequest_SortBy) GetDirection() SortDirection {
	if x != nil {
		return x.Direction
	}
	return SortDirection_ASCENDING
}

// Reference is a direct Git reference. No symbolic references will ever be returned by this RPC.
type ListRefsResponse_Reference struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// name is the fully qualified name of the reference.
	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// target is the object ID the reference points to.
	Target string `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	// peeled_target is the object ID an annotated tag points to. This field is only set when
	// `PeelTags=true`. This field is empty in case the object is not an annotated tag.
	PeeledTarget  string `protobuf:"bytes,3,opt,name=peeled_target,json=peeledTarget,proto3" json:"peeled_target,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListRefsResponse_Reference) ProtoMessage() {}

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

func (x *ListRefsResponse_Reference) GetName() []byte {
	if x != nil {
		return x.Name
	}
	return nil
}

func (x *ListRefsResponse_Reference) GetTarget() string {
	if x != nil {
		return x.Target
	}
	return ""
}

func (x *ListRefsResponse_Reference) GetPeeledTarget() string {
	if x != nil {
		return x.PeeledTarget
	}
	return ""
}

var File_ref_proto protoreflect.FileDescriptor

const file_ref_proto_rawDesc = "" +
	"\n" +
	"\tref.proto\x12\x06gitaly\x1a\ferrors.proto\x1a\n" +
	"lint.proto\x1a\fshared.proto\"u\n" +
	"\x1cFindDefaultBranchNameRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1b\n" +
	"\thead_only\x18\x02 \x01(\bR\bheadOnly\"3\n" +
	"\x1dFindDefaultBranchNameResponse\x12\x12\n" +
	"\x04name\x18\x01 \x01(\fR\x04name\"\x97\x02\n" +
	"\x18FindLocalBranchesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12@\n" +
	"\asort_by\x18\x02 \x01(\x0e2'.gitaly.FindLocalBranchesRequest.SortByR\x06sortBy\x12H\n" +
	"\x11pagination_params\x18\x03 \x01(\v2\x1b.gitaly.PaginationParameterR\x10paginationParams\"5\n" +
	"\x06SortBy\x12\b\n" +
	"\x04NAME\x10\x00\x12\x0f\n" +
	"\vUPDATED_ASC\x10\x01\x12\x10\n" +
	"\fUPDATED_DESC\x10\x02\"b\n" +
	"\x19FindLocalBranchesResponse\x125\n" +
	"\x0elocal_branches\x18\x02 \x03(\v2\x0e.gitaly.BranchR\rlocalBranchesJ\x04\b\x01\x10\x02R\bbranches\"\x9c\x01\n" +
	"\x16FindAllBranchesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1f\n" +
	"\vmerged_only\x18\x02 \x01(\bR\n" +
	"mergedOnly\x12'\n" +
	"\x0fmerged_branches\x18\x03 \x03(\fR\x0emergedBranches\"\xa6\x01\n" +
	"\x17FindAllBranchesResponse\x12B\n" +
	"\bbranches\x18\x01 \x03(\v2&.gitaly.FindAllBranchesResponse.BranchR\bbranches\x1aG\n" +
	"\x06Branch\x12\x12\n" +
	"\x04name\x18\x01 \x01(\fR\x04name\x12)\n" +
	"\x06target\x18\x02 \x01(\v2\x11.gitaly.GitCommitR\x06target\"e\n" +
	"\x0eFindTagRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x19\n" +
	"\btag_name\x18\x02 \x01(\fR\atagName\"0\n" +
	"\x0fFindTagResponse\x12\x1d\n" +
	"\x03tag\x18\x01 \x01(\v2\v.gitaly.TagR\x03tag\"]\n" +
	"\fFindTagError\x12D\n" +
	"\rtag_not_found\x18\x01 \x01(\v2\x1e.gitaly.ReferenceNotFoundErrorH\x00R\vtagNotFoundB\a\n" +
	"\x05error\"\x87\x03\n" +
	"\x12FindAllTagsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12:\n" +
	"\asort_by\x18\x02 \x01(\v2!.gitaly.FindAllTagsRequest.SortByR\x06sortBy\x12H\n" +
	"\x11pagination_params\x18\x03 \x01(\v2\x1b.gitaly.PaginationParameterR\x10paginationParams\x1a\xb0\x01\n" +
	"\x06SortBy\x127\n" +
	"\x03key\x18\x01 \x01(\x0e2%.gitaly.FindAllTagsRequest.SortBy.KeyR\x03key\x123\n" +
	"\tdirection\x18\x02 \x01(\x0e2\x15.gitaly.SortDirectionR\tdirection\"8\n" +
	"\x03Key\x12\v\n" +
	"\aREFNAME\x10\x00\x12\x0f\n" +
	"\vCREATORDATE\x10\x01\x12\x13\n" +
	"\x0fVERSION_REFNAME\x10\x02\"6\n" +
	"\x13FindAllTagsResponse\x12\x1f\n" +
	"\x04tags\x18\x01 \x03(\v2\v.gitaly.TagR\x04tags\"^\n" +
	"\x10RefExistsRequest\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\")\n" +
	"\x11RefExistsResponse\x12\x14\n" +
	"\x05value\x18\x01 \x01(\bR\x05value\"a\n" +
	"\x11FindBranchRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x12\n" +
	"\x04name\x18\x02 \x01(\fR\x04name\"<\n" +
	"\x12FindBranchResponse\x12&\n" +
	"\x06branch\x18\x01 \x01(\v2\x0e.gitaly.BranchR\x06branch\"\x85\x02\n" +
	"\x17UpdateReferencesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12@\n" +
	"\aupdates\x18\x02 \x03(\v2&.gitaly.UpdateReferencesRequest.UpdateR\aupdates\x1an\n" +
	"\x06Update\x12\x1c\n" +
	"\treference\x18\x01 \x01(\fR\treference\x12\"\n" +
	"\rold_object_id\x18\x02 \x01(\fR\voldObjectId\x12\"\n" +
	"\rnew_object_id\x18\x03 \x01(\fR\vnewObjectId\"\x1a\n" +
	"\x18UpdateReferencesResponse\"\x97\x02\n" +
	"\x15UpdateReferencesError\x12F\n" +
	"\x0einvalid_format\x18\x01 \x01(\v2\x1d.gitaly.InvalidRefFormatErrorH\x00R\rinvalidFormat\x12L\n" +
	"\x11references_locked\x18\x02 \x01(\v2\x1d.gitaly.ReferencesLockedErrorH\x00R\x10referencesLocked\x12_\n" +
	"\x18reference_state_mismatch\x18\x03 \x01(\v2#.gitaly.ReferenceStateMismatchErrorH\x00R\x16referenceStateMismatchB\a\n" +
	"\x05error\"\x8f\x01\n" +
	"\x11DeleteRefsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12,\n" +
	"\x12except_with_prefix\x18\x02 \x03(\fR\x10exceptWithPrefix\x12\x12\n" +
	"\x04refs\x18\x03 \x03(\fR\x04refs\"1\n" +
	"\x12DeleteRefsResponse\x12\x1b\n" +
	"\tgit_error\x18\x01 \x01(\tR\bgitError\"\xb0\x01\n" +
	"\x0fDeleteRefsError\x12F\n" +
	"\x0einvalid_format\x18\x01 \x01(\v2\x1d.gitaly.InvalidRefFormatErrorH\x00R\rinvalidFormat\x12L\n" +
	"\x11references_locked\x18\x02 \x01(\v2\x1d.gitaly.ReferencesLockedErrorH\x00R\x10referencesLockedB\a\n" +
	"\x05error\"\x95\x01\n" +
	"&ListBranchNamesContainingCommitRequest\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\x14\n" +
	"\x05limit\x18\x03 \x01(\rR\x05limit\"R\n" +
	"'ListBranchNamesContainingCommitResponse\x12!\n" +
	"\fbranch_names\x18\x02 \x03(\fR\vbranchNamesJ\x04\b\x01\x10\x02\"\x92\x01\n" +
	"#ListTagNamesContainingCommitRequest\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\x14\n" +
	"\x05limit\x18\x03 \x01(\rR\x05limit\"I\n" +
	"$ListTagNamesContainingCommitResponse\x12\x1b\n" +
	"\ttag_names\x18\x02 \x03(\fR\btagNamesJ\x04\b\x01\x10\x02\"x\n" +
	"\x17GetTagSignaturesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12#\n" +
	"\rtag_revisions\x18\x02 \x03(\tR\ftagRevisions\"\xc8\x01\n" +
	"\x18GetTagSignaturesResponse\x12M\n" +
	"\n" +
	"signatures\x18\x01 \x03(\v2-.gitaly.GetTagSignaturesResponse.TagSignatureR\n" +
	"signatures\x1a]\n" +
	"\fTagSignature\x12\x15\n" +
	"\x06tag_id\x18\x01 \x01(\tR\x05tagId\x12\x1c\n" +
	"\tsignature\x18\x02 \x01(\fR\tsignature\x12\x18\n" +
	"\acontent\x18\x03 \x01(\fR\acontent\"{\n" +
	"\x15GetTagMessagesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x17\n" +
	"\atag_ids\x18\x03 \x03(\tR\x06tagIdsJ\x04\b\x02\x10\x03R\ttag_names\"Y\n" +
	"\x16GetTagMessagesResponse\x12\x18\n" +
	"\amessage\x18\x02 \x01(\fR\amessage\x12\x15\n" +
	"\x06tag_id\x18\x03 \x01(\tR\x05tagIdJ\x04\b\x01\x10\x02R\btag_name\"y\n" +
	"\x1cFindAllRemoteBranchesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1f\n" +
	"\vremote_name\x18\x02 \x01(\tR\n" +
	"remoteName\"K\n" +
	"\x1dFindAllRemoteBranchesResponse\x12*\n" +
	"\bbranches\x18\x01 \x03(\v2\x0e.gitaly.BranchR\bbranches\"\xa4\x04\n" +
	"\x0fListRefsRequest\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\x12\x12\n" +
	"\x04head\x18\x03 \x01(\bR\x04head\x127\n" +
	"\asort_by\x18\x04 \x01(\v2\x1e.gitaly.ListRefsRequest.SortByR\x06sortBy\x12(\n" +
	"\x10pointing_at_oids\x18\x05 \x03(\fR\x0epointingAtOids\x12\x1b\n" +
	"\tpeel_tags\x18\x06 \x01(\bR\bpeelTags\x12H\n" +
	"\x11pagination_params\x18\a \x01(\v2\x1b.gitaly.PaginationParameterR\x10paginationParams\x12\x1f\n" +
	"\vignore_case\x18\b \x01(\bR\n" +
	"ignoreCase\x1a\xbb\x01\n" +
	"\x06SortBy\x124\n" +
	"\x03key\x18\x01 \x01(\x0e2\".gitaly.ListRefsRequest.SortBy.KeyR\x03key\x123\n" +
	"\tdirection\x18\x02 \x01(\x0e2\x15.gitaly.SortDirectionR\tdirection\"F\n" +
	"\x03Key\x12\v\n" +
	"\aREFNAME\x10\x00\x12\x0f\n" +
	"\vCREATORDATE\x10\x01\x12\x0e\n" +
	"\n" +
	"AUTHORDATE\x10\x02\x12\x11\n" +
	"\rCOMMITTERDATE\x10\x03\"\xfb\x01\n" +
	"\x10ListRefsResponse\x12B\n" +
	"\n" +
	"references\x18\x01 \x03(\v2\".gitaly.ListRefsResponse.ReferenceR\n" +
	"references\x12E\n" +
	"\x11pagination_cursor\x18\x02 \x01(\v2\x18.gitaly.PaginationCursorR\x10paginationCursor\x1a\\\n" +
	"\tReference\x12\x12\n" +
	"\x04name\x18\x01 \x01(\fR\x04name\x12\x16\n" +
	"\x06target\x18\x02 \x01(\tR\x06target\x12#\n" +
	"\rpeeled_target\x18\x03 \x01(\tR\fpeeledTarget\"\xba\x01\n" +
	"\x14FindRefsByOIDRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x10\n" +
	"\x03oid\x18\x02 \x01(\tR\x03oid\x12!\n" +
	"\fref_patterns\x18\x03 \x03(\tR\vrefPatterns\x12\x1d\n" +
	"\n" +
	"sort_field\x18\x04 \x01(\tR\tsortField\x12\x14\n" +
	"\x05limit\x18\x05 \x01(\rR\x05limit\"+\n" +
	"\x15FindRefsByOIDResponse\x12\x12\n" +
	"\x04refs\x18\x01 \x03(\tR\x04refs2\xf7\v\n" +
	"\n" +
	"RefService\x12l\n" +
	"\x15FindDefaultBranchName\x12$.gitaly.FindDefaultBranchNameRequest\x1a%.gitaly.FindDefaultBranchNameResponse\"\x06\xfa\x97(\x02\b\x02\x12b\n" +
	"\x11FindLocalBranches\x12 .gitaly.FindLocalBranchesRequest\x1a!.gitaly.FindLocalBranchesResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12\\\n" +
	"\x0fFindAllBranches\x12\x1e.gitaly.FindAllBranchesRequest\x1a\x1f.gitaly.FindAllBranchesResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12P\n" +
	"\vFindAllTags\x12\x1a.gitaly.FindAllTagsRequest\x1a\x1b.gitaly.FindAllTagsResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12B\n" +
	"\aFindTag\x12\x16.gitaly.FindTagRequest\x1a\x17.gitaly.FindTagResponse\"\x06\xfa\x97(\x02\b\x02\x12n\n" +
	"\x15FindAllRemoteBranches\x12$.gitaly.FindAllRemoteBranchesRequest\x1a%.gitaly.FindAllRemoteBranchesResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12H\n" +
	"\tRefExists\x12\x18.gitaly.RefExistsRequest\x1a\x19.gitaly.RefExistsResponse\"\x06\xfa\x97(\x02\b\x02\x12K\n" +
	"\n" +
	"FindBranch\x12\x19.gitaly.FindBranchRequest\x1a\x1a.gitaly.FindBranchResponse\"\x06\xfa\x97(\x02\b\x02\x12_\n" +
	"\x10UpdateReferences\x12\x1f.gitaly.UpdateReferencesRequest\x1a .gitaly.UpdateReferencesResponse\"\x06\xfa\x97(\x02\b\x01(\x01\x12K\n" +
	"\n" +
	"DeleteRefs\x12\x19.gitaly.DeleteRefsRequest\x1a\x1a.gitaly.DeleteRefsResponse\"\x06\xfa\x97(\x02\b\x01\x12\x8c\x01\n" +
	"\x1fListBranchNamesContainingCommit\x12..gitaly.ListBranchNamesContainingCommitRequest\x1a/.gitaly.ListBranchNamesContainingCommitResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12\x83\x01\n" +
	"\x1cListTagNamesContainingCommit\x12+.gitaly.ListTagNamesContainingCommitRequest\x1a,.gitaly.ListTagNamesContainingCommitResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12_\n" +
	"\x10GetTagSignatures\x12\x1f.gitaly.GetTagSignaturesRequest\x1a .gitaly.GetTagSignaturesResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12Y\n" +
	"\x0eGetTagMessages\x12\x1d.gitaly.GetTagMessagesRequest\x1a\x1e.gitaly.GetTagMessagesResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12G\n" +
	"\bListRefs\x12\x17.gitaly.ListRefsRequest\x1a\x18.gitaly.ListRefsResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12T\n" +
	"\rFindRefsByOID\x12\x1c.gitaly.FindRefsByOIDRequest\x1a\x1d.gitaly.FindRefsByOIDResponse\"\x06\xfa\x97(\x02\b\x02B4Z2gitlab.com/gitlab-org/gitaly/v18/proto/go/gitalypbb\x06proto3"

var (
	file_ref_proto_rawDescOnce sync.Once
	file_ref_proto_rawDescData []byte
)

func file_ref_proto_rawDescGZIP() []byte {
	file_ref_proto_rawDescOnce.Do(func() {
		file_ref_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_ref_proto_rawDesc), len(file_ref_proto_rawDesc)))
	})
	return file_ref_proto_rawDescData
}

var file_ref_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_ref_proto_msgTypes = make([]protoimpl.MessageInfo, 41)
var file_ref_proto_goTypes = []any{
	(FindLocalBranchesRequest_SortBy)(0),            // 0: gitaly.FindLocalBranchesRequest.SortBy
	(FindAllTagsRequest_SortBy_Key)(0),              // 1: gitaly.FindAllTagsRequest.SortBy.Key
	(ListRefsRequest_SortBy_Key)(0),                 // 2: gitaly.ListRefsRequest.SortBy.Key
	(*FindDefaultBranchNameRequest)(nil),            // 3: gitaly.FindDefaultBranchNameRequest
	(*FindDefaultBranchNameResponse)(nil),           // 4: gitaly.FindDefaultBranchNameResponse
	(*FindLocalBranchesRequest)(nil),                // 5: gitaly.FindLocalBranchesRequest
	(*FindLocalBranchesResponse)(nil),               // 6: gitaly.FindLocalBranchesResponse
	(*FindAllBranchesRequest)(nil),                  // 7: gitaly.FindAllBranchesRequest
	(*FindAllBranchesResponse)(nil),                 // 8: gitaly.FindAllBranchesResponse
	(*FindTagRequest)(nil),                          // 9: gitaly.FindTagRequest
	(*FindTagResponse)(nil),                         // 10: gitaly.FindTagResponse
	(*FindTagError)(nil),                            // 11: gitaly.FindTagError
	(*FindAllTagsRequest)(nil),                      // 12: gitaly.FindAllTagsRequest
	(*FindAllTagsResponse)(nil),                     // 13: gitaly.FindAllTagsResponse
	(*RefExistsRequest)(nil),                        // 14: gitaly.RefExistsRequest
	(*RefExistsResponse)(nil),                       // 15: gitaly.RefExistsResponse
	(*FindBranchRequest)(nil),                       // 16: gitaly.FindBranchRequest
	(*FindBranchResponse)(nil),                      // 17: gitaly.FindBranchResponse
	(*UpdateReferencesRequest)(nil),                 // 18: gitaly.UpdateReferencesRequest
	(*UpdateReferencesResponse)(nil),                // 19: gitaly.UpdateReferencesResponse
	(*UpdateReferencesError)(nil),                   // 20: gitaly.UpdateReferencesError
	(*DeleteRefsRequest)(nil),                       // 21: gitaly.DeleteRefsRequest
	(*DeleteRefsResponse)(nil),                      // 22: gitaly.DeleteRefsResponse
	(*DeleteRefsError)(nil),                         // 23: gitaly.DeleteRefsError
	(*ListBranchNamesContainingCommitRequest)(nil),  // 24: gitaly.ListBranchNamesContainingCommitRequest
	(*ListBranchNamesContainingCommitResponse)(nil), // 25: gitaly.ListBranchNamesContainingCommitResponse
	(*ListTagNamesContainingCommitRequest)(nil),     // 26: gitaly.ListTagNamesContainingCommitRequest
	(*ListTagNamesContainingCommitResponse)(nil),    // 27: gitaly.ListTagNamesContainingCommitResponse
	(*GetTagSignaturesRequest)(nil),                 // 28: gitaly.GetTagSignaturesRequest
	(*GetTagSignaturesResponse)(nil),                // 29: gitaly.GetTagSignaturesResponse
	(*GetTagMessagesRequest)(nil),                   // 30: gitaly.GetTagMessagesRequest
	(*GetTagMessagesResponse)(nil),                  // 31: gitaly.GetTagMessagesResponse
	(*FindAllRemoteBranchesRequest)(nil),            // 32: gitaly.FindAllRemoteBranchesRequest
	(*FindAllRemoteBranchesResponse)(nil),           // 33: gitaly.FindAllRemoteBranchesResponse
	(*ListRefsRequest)(nil),                         // 34: gitaly.ListRefsRequest
	(*ListRefsResponse)(nil),                        // 35: gitaly.ListRefsResponse
	(*FindRefsByOIDRequest)(nil),                    // 36: gitaly.FindRefsByOIDRequest
	(*FindRefsByOIDResponse)(nil),                   // 37: gitaly.FindRefsByOIDResponse
	(*FindAllBranchesResponse_Branch)(nil),          // 38: gitaly.FindAllBranchesResponse.Branch
	(*FindAllTagsRequest_SortBy)(nil),               // 39: gitaly.FindAllTagsRequest.SortBy
	(*UpdateReferencesRequest_Update)(nil),          // 40: gitaly.UpdateReferencesRequest.Update
	(*GetTagSignaturesResponse_TagSignature)(nil),   // 41: gitaly.GetTagSignaturesResponse.TagSignature
	(*ListRefsRequest_SortBy)(nil),                  // 42: gitaly.ListRefsRequest.SortBy
	(*ListRefsResponse_Reference)(nil),              // 43: gitaly.ListRefsResponse.Reference
	(*Repository)(nil),                              // 44: gitaly.Repository
	(*PaginationParameter)(nil),                     // 45: gitaly.PaginationParameter
	(*Branch)(nil),                                  // 46: gitaly.Branch
	(*Tag)(nil),                                     // 47: gitaly.Tag
	(*ReferenceNotFoundError)(nil),                  // 48: gitaly.ReferenceNotFoundError
	(*InvalidRefFormatError)(nil),                   // 49: gitaly.InvalidRefFormatError
	(*ReferencesLockedError)(nil),                   // 50: gitaly.ReferencesLockedError
	(*ReferenceStateMismatchError)(nil),             // 51: gitaly.ReferenceStateMismatchError
	(*PaginationCursor)(nil),                        // 52: gitaly.PaginationCursor
	(*GitCommit)(nil),                               // 53: gitaly.GitCommit
	(SortDirection)(0),                              // 54: gitaly.SortDirection
}
var file_ref_proto_depIdxs = []int32{
	44, // 0: gitaly.FindDefaultBranchNameRequest.repository:type_name -> gitaly.Repository
	44, // 1: gitaly.FindLocalBranchesRequest.repository:type_name -> gitaly.Repository
	0,  // 2: gitaly.FindLocalBranchesRequest.sort_by:type_name -> gitaly.FindLocalBranchesRequest.SortBy
	45, // 3: gitaly.FindLocalBranchesRequest.pagination_params:type_name -> gitaly.PaginationParameter
	46, // 4: gitaly.FindLocalBranchesResponse.local_branches:type_name -> gitaly.Branch
	44, // 5: gitaly.FindAllBranchesRequest.repository:type_name -> gitaly.Repository
	38, // 6: gitaly.FindAllBranchesResponse.branches:type_name -> gitaly.FindAllBranchesResponse.Branch
	44, // 7: gitaly.FindTagRequest.repository:type_name -> gitaly.Repository
	47, // 8: gitaly.FindTagResponse.tag:type_name -> gitaly.Tag
	48, // 9: gitaly.FindTagError.tag_not_found:type_name -> gitaly.ReferenceNotFoundError
	44, // 10: gitaly.FindAllTagsRequest.repository:type_name -> gitaly.Repository
	39, // 11: gitaly.FindAllTagsRequest.sort_by:type_name -> gitaly.FindAllTagsRequest.SortBy
	45, // 12: gitaly.FindAllTagsRequest.pagination_params:type_name -> gitaly.PaginationParameter
	47, // 13: gitaly.FindAllTagsResponse.tags:type_name -> gitaly.Tag
	44, // 14: gitaly.RefExistsRequest.repository:type_name -> gitaly.Repository
	44, // 15: gitaly.FindBranchRequest.repository:type_name -> gitaly.Repository
	46, // 16: gitaly.FindBranchResponse.branch:type_name -> gitaly.Branch
	44, // 17: gitaly.UpdateReferencesRequest.repository:type_name -> gitaly.Repository
	40, // 18: gitaly.UpdateReferencesRequest.updates:type_name -> gitaly.UpdateReferencesRequest.Update
	49, // 19: gitaly.UpdateReferencesError.invalid_format:type_name -> gitaly.InvalidRefFormatError
	50, // 20: gitaly.UpdateReferencesError.references_locked:type_name -> gitaly.ReferencesLockedError
	51, // 21: gitaly.UpdateReferencesError.reference_state_mismatch:type_name -> gitaly.ReferenceStateMismatchError
	44, // 22: gitaly.DeleteRefsRequest.repository:type_name -> gitaly.Repository
	49, // 23: gitaly.DeleteRefsError.invalid_format:type_name -> gitaly.InvalidRefFormatError
	50, // 24: gitaly.DeleteRefsError.references_locked:type_name -> gitaly.ReferencesLockedError
	44, // 25: gitaly.ListBranchNamesContainingCommitRequest.repository:type_name -> gitaly.Repository
	44, // 26: gitaly.ListTagNamesContainingCommitRequest.repository:type_name -> gitaly.Repository
	44, // 27: gitaly.GetTagSignaturesRequest.repository:type_name -> gitaly.Repository
	41, // 28: gitaly.GetTagSignaturesResponse.signatures:type_name -> gitaly.GetTagSignaturesResponse.TagSignature
	44, // 29: gitaly.GetTagMessagesRequest.repository:type_name -> gitaly.Repository
	44, // 30: gitaly.FindAllRemoteBranchesRequest.repository:type_name -> gitaly.Repository
	46, // 31: gitaly.FindAllRemoteBranchesResponse.branches:type_name -> gitaly.Branch
	44, // 32: gitaly.ListRefsRequest.repository:type_name -> gitaly.Repository
	42, // 33: gitaly.ListRefsRequest.sort_by:type_name -> gitaly.ListRefsRequest.SortBy
	45, // 34: gitaly.ListRefsRequest.pagination_params:type_name -> gitaly.PaginationParameter
	43, // 35: gitaly.ListRefsResponse.references:type_name -> gitaly.ListRefsResponse.Reference
	52, // 36: gitaly.ListRefsResponse.pagination_cursor:type_name -> gitaly.PaginationCursor
	44, // 37: gitaly.FindRefsByOIDRequest.repository:type_name -> gitaly.Repository
	53, // 38: gitaly.FindAllBranchesResponse.Branch.target:type_name -> gitaly.GitCommit
	1,  // 39: gitaly.FindAllTagsRequest.SortBy.key:type_name -> gitaly.FindAllTagsRequest.SortBy.Key
	54, // 40: gitaly.FindAllTagsRequest.SortBy.direction:type_name -> gitaly.SortDirection
	2,  // 41: gitaly.ListRefsRequest.SortBy.key:type_name -> gitaly.ListRefsRequest.SortBy.Key
	54, // 42: gitaly.ListRefsRequest.SortBy.direction:type_name -> gitaly.SortDirection
	3,  // 43: gitaly.RefService.FindDefaultBranchName:input_type -> gitaly.FindDefaultBranchNameRequest
	5,  // 44: gitaly.RefService.FindLocalBranches:input_type -> gitaly.FindLocalBranchesRequest
	7,  // 45: gitaly.RefService.FindAllBranches:input_type -> gitaly.FindAllBranchesRequest
	12, // 46: gitaly.RefService.FindAllTags:input_type -> gitaly.FindAllTagsRequest
	9,  // 47: gitaly.RefService.FindTag:input_type -> gitaly.FindTagRequest
	32, // 48: gitaly.RefService.FindAllRemoteBranches:input_type -> gitaly.FindAllRemoteBranchesRequest
	14, // 49: gitaly.RefService.RefExists:input_type -> gitaly.RefExistsRequest
	16, // 50: gitaly.RefService.FindBranch:input_type -> gitaly.FindBranchRequest
	18, // 51: gitaly.RefService.UpdateReferences:input_type -> gitaly.UpdateReferencesRequest
	21, // 52: gitaly.RefService.DeleteRefs:input_type -> gitaly.DeleteRefsRequest
	24, // 53: gitaly.RefService.ListBranchNamesContainingCommit:input_type -> gitaly.ListBranchNamesContainingCommitRequest
	26, // 54: gitaly.RefService.ListTagNamesContainingCommit:input_type -> gitaly.ListTagNamesContainingCommitRequest
	28, // 55: gitaly.RefService.GetTagSignatures:input_type -> gitaly.GetTagSignaturesRequest
	30, // 56: gitaly.RefService.GetTagMessages:input_type -> gitaly.GetTagMessagesRequest
	34, // 57: gitaly.RefService.ListRefs:input_type -> gitaly.ListRefsRequest
	36, // 58: gitaly.RefService.FindRefsByOID:input_type -> gitaly.FindRefsByOIDRequest
	4,  // 59: gitaly.RefService.FindDefaultBranchName:output_type -> gitaly.FindDefaultBranchNameResponse
	6,  // 60: gitaly.RefService.FindLocalBranches:output_type -> gitaly.FindLocalBranchesResponse
	8,  // 61: gitaly.RefService.FindAllBranches:output_type -> gitaly.FindAllBranchesResponse
	13, // 62: gitaly.RefService.FindAllTags:output_type -> gitaly.FindAllTagsResponse
	10, // 63: gitaly.RefService.FindTag:output_type -> gitaly.FindTagResponse
	33, // 64: gitaly.RefService.FindAllRemoteBranches:output_type -> gitaly.FindAllRemoteBranchesResponse
	15, // 65: gitaly.RefService.RefExists:output_type -> gitaly.RefExistsResponse
	17, // 66: gitaly.RefService.FindBranch:output_type -> gitaly.FindBranchResponse
	19, // 67: gitaly.RefService.UpdateReferences:output_type -> gitaly.UpdateReferencesResponse
	22, // 68: gitaly.RefService.DeleteRefs:output_type -> gitaly.DeleteRefsResponse
	25, // 69: gitaly.RefService.ListBranchNamesContainingCommit:output_type -> gitaly.ListBranchNamesContainingCommitResponse
	27, // 70: gitaly.RefService.ListTagNamesContainingCommit:output_type -> gitaly.ListTagNamesContainingCommitResponse
	29, // 71: gitaly.RefService.GetTagSignatures:output_type -> gitaly.GetTagSignaturesResponse
	31, // 72: gitaly.RefService.GetTagMessages:output_type -> gitaly.GetTagMessagesResponse
	35, // 73: gitaly.RefService.ListRefs:output_type -> gitaly.ListRefsResponse
	37, // 74: gitaly.RefService.FindRefsByOID:output_type -> gitaly.FindRefsByOIDResponse
	59, // [59:75] is the sub-list for method output_type
	43, // [43:59] is the sub-list for method input_type
	43, // [43:43] is the sub-list for extension type_name
	43, // [43:43] is the sub-list for extension extendee
	0,  // [0:43] is the sub-list for field type_name
}

func init() { file_ref_proto_init() }
func file_ref_proto_init() {
	if File_ref_proto != nil {
		return
	}
	file_errors_proto_init()
	file_lint_proto_init()
	file_shared_proto_init()
	file_ref_proto_msgTypes[8].OneofWrappers = []any{
		(*FindTagError_TagNotFound)(nil),
	}
	file_ref_proto_msgTypes[17].OneofWrappers = []any{
		(*UpdateReferencesError_InvalidFormat)(nil),
		(*UpdateReferencesError_ReferencesLocked)(nil),
		(*UpdateReferencesError_ReferenceStateMismatch)(nil),
	}
	file_ref_proto_msgTypes[20].OneofWrappers = []any{
		(*DeleteRefsError_InvalidFormat)(nil),
		(*DeleteRefsError_ReferencesLocked)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_ref_proto_rawDesc), len(file_ref_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   41,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_ref_proto_goTypes,
		DependencyIndexes: file_ref_proto_depIdxs,
		EnumInfos:         file_ref_proto_enumTypes,
		MessageInfos:      file_ref_proto_msgTypes,
	}.Build()
	File_ref_proto = out.File
	file_ref_proto_goTypes = nil
	file_ref_proto_depIdxs = nil
}
