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

package gitalypb

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

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

// Order is the order in which commits should be traversed.
type ListCommitsRequest_Order int32

const (
	// NONE defaults to reverse chronological order.
	ListCommitsRequest_NONE ListCommitsRequest_Order = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// TOPO order will cause no parents to be shown before all of its children
	// are shown. Furthermore, multiple lines of history will not be
	// intermixed.
	ListCommitsRequest_TOPO ListCommitsRequest_Order = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// DATE order will cause no parents to be shown before all of its children
	// are shown. Otherwise, commits are shown in commit timestamp order. This
	// can cause history to be shown intermixed.
	ListCommitsRequest_DATE ListCommitsRequest_Order = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for ListCommitsRequest_Order.
var (
	ListCommitsRequest_Order_name = map[int32]string{
		0: "NONE",
		1: "TOPO",
		2: "DATE",
	}
	ListCommitsRequest_Order_value = map[string]int32{
		"NONE": 0,
		"TOPO": 1,
		"DATE": 2,
	}
)

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

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

func (ListCommitsRequest_Order) Descriptor() protoreflect.EnumDescriptor {
	return file_commit_proto_enumTypes[0].Descriptor()
}

func (ListCommitsRequest_Order) Type() protoreflect.EnumType {
	return &file_commit_proto_enumTypes[0]
}

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

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

// ObjectType is the type of the returned tree entry.
//
// TODO: Replace this enum with ObjectType in shared.proto
type TreeEntryResponse_ObjectType int32

const (
	// COMMIT indicates that the tree entry is a commit, which may be the case for submodules.
	TreeEntryResponse_COMMIT TreeEntryResponse_ObjectType = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// BLOB indicates that the tree entry is a blob.
	TreeEntryResponse_BLOB TreeEntryResponse_ObjectType = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// TREE indicates that the tree entry is a tree, which may be the case for subdirectories.
	TreeEntryResponse_TREE TreeEntryResponse_ObjectType = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// TAG indicates that the tree entry is a tag. This case should never happen.
	TreeEntryResponse_TAG TreeEntryResponse_ObjectType = 3 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for TreeEntryResponse_ObjectType.
var (
	TreeEntryResponse_ObjectType_name = map[int32]string{
		0: "COMMIT",
		1: "BLOB",
		2: "TREE",
		3: "TAG",
	}
	TreeEntryResponse_ObjectType_value = map[string]int32{
		"COMMIT": 0,
		"BLOB":   1,
		"TREE":   2,
		"TAG":    3,
	}
)

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

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

func (TreeEntryResponse_ObjectType) Descriptor() protoreflect.EnumDescriptor {
	return file_commit_proto_enumTypes[1].Descriptor()
}

func (TreeEntryResponse_ObjectType) Type() protoreflect.EnumType {
	return &file_commit_proto_enumTypes[1]
}

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

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

// EntryType denotes the different types of tree entry.
type TreeEntry_EntryType int32

const (
	// BLOB indicates that the tree entry is a blob.
	TreeEntry_BLOB TreeEntry_EntryType = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// TREE indicates that the tree entry is a tree, which may be the case for subdirectories.
	TreeEntry_TREE TreeEntry_EntryType = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// COMMIT indicates that the tree entry is a commit, which may be the case for submodules.
	TreeEntry_COMMIT TreeEntry_EntryType = 3 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for TreeEntry_EntryType.
var (
	TreeEntry_EntryType_name = map[int32]string{
		0: "BLOB",
		1: "TREE",
		3: "COMMIT",
	}
	TreeEntry_EntryType_value = map[string]int32{
		"BLOB":   0,
		"TREE":   1,
		"COMMIT": 3,
	}
)

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

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

func (TreeEntry_EntryType) Descriptor() protoreflect.EnumDescriptor {
	return file_commit_proto_enumTypes[2].Descriptor()
}

func (TreeEntry_EntryType) Type() protoreflect.EnumType {
	return &file_commit_proto_enumTypes[2]
}

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

// Deprecated: Use TreeEntry_EntryType.Descriptor instead.
func (TreeEntry_EntryType) EnumDescriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{14, 0}
}

// SortBy provides the sorting parameters.
type GetTreeEntriesRequest_SortBy int32

const (
	// DEFAULT preserves the order of git ls-tree.
	GetTreeEntriesRequest_DEFAULT GetTreeEntriesRequest_SortBy = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// TREES_FIRST sorts the entries by trees, blobs and submodules.
	GetTreeEntriesRequest_TREES_FIRST GetTreeEntriesRequest_SortBy = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// FILESYSTEM sorts the tree entries lexicographically, mirroring the `ls` command.
	GetTreeEntriesRequest_FILESYSTEM GetTreeEntriesRequest_SortBy = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for GetTreeEntriesRequest_SortBy.
var (
	GetTreeEntriesRequest_SortBy_name = map[int32]string{
		0: "DEFAULT",
		1: "TREES_FIRST",
		2: "FILESYSTEM",
	}
	GetTreeEntriesRequest_SortBy_value = map[string]int32{
		"DEFAULT":     0,
		"TREES_FIRST": 1,
		"FILESYSTEM":  2,
	}
)

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

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

func (GetTreeEntriesRequest_SortBy) Descriptor() protoreflect.EnumDescriptor {
	return file_commit_proto_enumTypes[3].Descriptor()
}

func (GetTreeEntriesRequest_SortBy) Type() protoreflect.EnumType {
	return &file_commit_proto_enumTypes[3]
}

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

// Deprecated: Use GetTreeEntriesRequest_SortBy.Descriptor instead.
func (GetTreeEntriesRequest_SortBy) EnumDescriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{15, 0}
}

// Order is the order in which commits should be traversed.
type FindAllCommitsRequest_Order int32

const (
	// NONE denotes the default ordering where the commits are shown in
	// reverse chronological order.
	FindAllCommitsRequest_NONE FindAllCommitsRequest_Order = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// TOPO order will cause no parents to be shown before all of its children
	// are shown. Furthermore, multiple lines of history will not be
	// intermixed.
	FindAllCommitsRequest_TOPO FindAllCommitsRequest_Order = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// DATE order will cause no parents to be shown before all of its children
	// are shown. Otherwise, commits are shown in commit timestamp order. This
	// can cause history to be shown intermixed.
	FindAllCommitsRequest_DATE FindAllCommitsRequest_Order = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for FindAllCommitsRequest_Order.
var (
	FindAllCommitsRequest_Order_name = map[int32]string{
		0: "NONE",
		1: "TOPO",
		2: "DATE",
	}
	FindAllCommitsRequest_Order_value = map[string]int32{
		"NONE": 0,
		"TOPO": 1,
		"DATE": 2,
	}
)

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

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

func (FindAllCommitsRequest_Order) Descriptor() protoreflect.EnumDescriptor {
	return file_commit_proto_enumTypes[4].Descriptor()
}

func (FindAllCommitsRequest_Order) Type() protoreflect.EnumType {
	return &file_commit_proto_enumTypes[4]
}

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

// Deprecated: Use FindAllCommitsRequest_Order.Descriptor instead.
func (FindAllCommitsRequest_Order) EnumDescriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{26, 0}
}

// Order is the order in which commits should be traversed.
type FindCommitsRequest_Order int32

const (
	// NONE defaults to reverse chronological order.
	FindCommitsRequest_NONE FindCommitsRequest_Order = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// TOPO order will cause no parents to be shown before all of its children
	// are shown. Furthermore, multiple lines of history will not be
	// intermixed.
	FindCommitsRequest_TOPO FindCommitsRequest_Order = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for FindCommitsRequest_Order.
var (
	FindCommitsRequest_Order_name = map[int32]string{
		0: "NONE",
		1: "TOPO",
	}
	FindCommitsRequest_Order_value = map[string]int32{
		"NONE": 0,
		"TOPO": 1,
	}
)

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

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

func (FindCommitsRequest_Order) Descriptor() protoreflect.EnumDescriptor {
	return file_commit_proto_enumTypes[5].Descriptor()
}

func (FindCommitsRequest_Order) Type() protoreflect.EnumType {
	return &file_commit_proto_enumTypes[5]
}

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

// Deprecated: Use FindCommitsRequest_Order.Descriptor instead.
func (FindCommitsRequest_Order) EnumDescriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{28, 0}
}

// Signer of the commit. A commit can be signed either by a user or by Gitaly itself.
type GetCommitSignaturesResponse_Signer int32

const (
	// SIGNER_UNSPECIFIED indicates that the signer has not been specified.
	GetCommitSignaturesResponse_SIGNER_UNSPECIFIED GetCommitSignaturesResponse_Signer = 0
	// SIGNER_USER indicates that the commit has been signed by a user.
	GetCommitSignaturesResponse_SIGNER_USER GetCommitSignaturesResponse_Signer = 1
	// SIGNER_SYSTEM indicates that the commit has been signed by Gitaly itself.
	GetCommitSignaturesResponse_SIGNER_SYSTEM GetCommitSignaturesResponse_Signer = 2
)

// Enum value maps for GetCommitSignaturesResponse_Signer.
var (
	GetCommitSignaturesResponse_Signer_name = map[int32]string{
		0: "SIGNER_UNSPECIFIED",
		1: "SIGNER_USER",
		2: "SIGNER_SYSTEM",
	}
	GetCommitSignaturesResponse_Signer_value = map[string]int32{
		"SIGNER_UNSPECIFIED": 0,
		"SIGNER_USER":        1,
		"SIGNER_SYSTEM":      2,
	}
)

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

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

func (GetCommitSignaturesResponse_Signer) Descriptor() protoreflect.EnumDescriptor {
	return file_commit_proto_enumTypes[6].Descriptor()
}

func (GetCommitSignaturesResponse_Signer) Type() protoreflect.EnumType {
	return &file_commit_proto_enumTypes[6]
}

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

// Deprecated: Use GetCommitSignaturesResponse_Signer.Descriptor instead.
func (GetCommitSignaturesResponse_Signer) EnumDescriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{45, 0}
}

// ListCommitsRequest is a request for the ListCommits RPC.
type ListCommitsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which commits should be searched for.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revisions is the set of revisions which should be walked to enumerate
	// commits. Accepts all notation as documented in gitrevisions(7) as well as
	// the pseudo-revisions `--not` and `--all` as documented in git-rev-list(1).
	// Must not be empty.
	Revisions []string `protobuf:"bytes,2,rep,name=revisions,proto3" json:"revisions,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"`
	// order is the order in which commits should be traversed. Please refer to
	// the enum's documentation for further information.
	Order ListCommitsRequest_Order `protobuf:"varint,4,opt,name=order,proto3,enum=gitaly.ListCommitsRequest_Order" json:"order,omitempty"`
	// max_parents will skip all commits which have more than the specified number
	// of parents. If set to `0`, no filtering by parents will happen. If set to
	// `1`, all merge commits will be omitted.
	MaxParents uint32 `protobuf:"varint,5,opt,name=max_parents,json=maxParents,proto3" json:"max_parents,omitempty"`
	// disable_walk will disable walking the graph. As a result, only commits
	// which are immediately referenced by Revisions will be returned.
	DisableWalk bool `protobuf:"varint,6,opt,name=disable_walk,json=disableWalk,proto3" json:"disable_walk,omitempty"`
	// first_parent will cause the graph walk to only go down the first-parent
	// chain of commits. Merge commits will thus only cause the mainline to be
	// enumerated.
	FirstParent bool `protobuf:"varint,7,opt,name=first_parent,json=firstParent,proto3" json:"first_parent,omitempty"`
	// after will only list commits which are more recent than the specified date.
	After *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=after,proto3" json:"after,omitempty"`
	// before will only list commits which are older than the specified date.
	Before *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=before,proto3" json:"before,omitempty"`
	// author will only list commits whose author matches the given pattern,
	// which is a regular expression.
	Author []byte `protobuf:"bytes,10,opt,name=author,proto3" json:"author,omitempty"`
	// reverse will cause all commits to be listed in reverse.
	Reverse bool `protobuf:"varint,11,opt,name=reverse,proto3" json:"reverse,omitempty"`
	// ignore_case will apply case-sensitive behaviour while regex matching.
	IgnoreCase bool `protobuf:"varint,12,opt,name=ignore_case,json=ignoreCase,proto3" json:"ignore_case,omitempty"`
	// commit_message_patterns will only list commits whose commit message matches
	// any of the given patterns.
	CommitMessagePatterns [][]byte `protobuf:"bytes,13,rep,name=commit_message_patterns,json=commitMessagePatterns,proto3" json:"commit_message_patterns,omitempty"`
	// skip will skip a number commits before starting to show the commit output.
	Skip uint32 `protobuf:"varint,14,opt,name=skip,proto3" json:"skip,omitempty"`
	// paths allows filtering the results by paths. This field supports glob
	// patterns.
	Paths [][]byte `protobuf:"bytes,15,rep,name=paths,proto3" json:"paths,omitempty"`
	// global_options contains the global options used to modify the behaviour of
	// Git. For example, this can be used to enable literal pathspec matching
	// via `literal_pathspecs`.
	GlobalOptions *GlobalOptions `protobuf:"bytes,16,opt,name=global_options,json=globalOptions,proto3" json:"global_options,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListCommitsRequest) ProtoMessage() {}

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

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

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

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

func (x *ListCommitsRequest) GetOrder() ListCommitsRequest_Order {
	if x != nil {
		return x.Order
	}
	return ListCommitsRequest_NONE
}

func (x *ListCommitsRequest) GetMaxParents() uint32 {
	if x != nil {
		return x.MaxParents
	}
	return 0
}

func (x *ListCommitsRequest) GetDisableWalk() bool {
	if x != nil {
		return x.DisableWalk
	}
	return false
}

func (x *ListCommitsRequest) GetFirstParent() bool {
	if x != nil {
		return x.FirstParent
	}
	return false
}

func (x *ListCommitsRequest) GetAfter() *timestamppb.Timestamp {
	if x != nil {
		return x.After
	}
	return nil
}

func (x *ListCommitsRequest) GetBefore() *timestamppb.Timestamp {
	if x != nil {
		return x.Before
	}
	return nil
}

func (x *ListCommitsRequest) GetAuthor() []byte {
	if x != nil {
		return x.Author
	}
	return nil
}

func (x *ListCommitsRequest) GetReverse() bool {
	if x != nil {
		return x.Reverse
	}
	return false
}

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

func (x *ListCommitsRequest) GetCommitMessagePatterns() [][]byte {
	if x != nil {
		return x.CommitMessagePatterns
	}
	return nil
}

func (x *ListCommitsRequest) GetSkip() uint32 {
	if x != nil {
		return x.Skip
	}
	return 0
}

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

func (x *ListCommitsRequest) GetGlobalOptions() *GlobalOptions {
	if x != nil {
		return x.GlobalOptions
	}
	return nil
}

// ListCommitsResponse is a response for the ListCommits RPC. The response will be
// chunked into multiple message if the returned data exceeds gRPC message limits.
type ListCommitsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commits is the list of commits found.
	Commits []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	// pagination_cursor defines the offset for subsequent requests. 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 *ListCommitsResponse) Reset() {
	*x = ListCommitsResponse{}
	mi := &file_commit_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListCommitsResponse) ProtoMessage() {}

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

func (x *ListCommitsResponse) GetCommits() []*GitCommit {
	if x != nil {
		return x.Commits
	}
	return nil
}

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

// ListAllCommitsRequest is a request for the ListAllCommits RPC.
type ListAllCommitsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which commits should be searched for.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// pagination_params controls paging. Refer to PaginationParameter documentation for
	// further info.
	PaginationParams *PaginationParameter `protobuf:"bytes,2,opt,name=pagination_params,json=paginationParams,proto3" json:"pagination_params,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*ListAllCommitsRequest) ProtoMessage() {}

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

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

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

// ListAllCommitsResponse is a response for the ListAllCommits RPC. The response will be
// chunked into multiple message if the returned data exceeds gRPC message limits.
type ListAllCommitsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commits is the list of commits found.
	Commits       []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListAllCommitsResponse) ProtoMessage() {}

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

func (x *ListAllCommitsResponse) GetCommits() []*GitCommit {
	if x != nil {
		return x.Commits
	}
	return nil
}

// CommitStatsRequest is the request for the CommitStats RPC.
type CommitStatsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which the commit is present.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is a commitish for which we want to get the stats.
	Revision      []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitStatsRequest) ProtoMessage() {}

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

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

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

// CommitStatsResponse is the request for the CommitStats RPC.
type CommitStatsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// oid is the commit object ID. It is empty if the commit is not found.
	Oid string `protobuf:"bytes,1,opt,name=oid,proto3" json:"oid,omitempty"`
	// additions refers to the number of lines added in the commit.
	Additions int32 `protobuf:"varint,2,opt,name=additions,proto3" json:"additions,omitempty"`
	// deletions refers to the number of lines deleted in the commit.
	Deletions int32 `protobuf:"varint,3,opt,name=deletions,proto3" json:"deletions,omitempty"`
	// files refers to the number of files changed in the commit.
	Files         int32 `protobuf:"varint,4,opt,name=files,proto3" json:"files,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitStatsResponse) ProtoMessage() {}

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

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

func (x *CommitStatsResponse) GetAdditions() int32 {
	if x != nil {
		return x.Additions
	}
	return 0
}

func (x *CommitStatsResponse) GetDeletions() int32 {
	if x != nil {
		return x.Deletions
	}
	return 0
}

func (x *CommitStatsResponse) GetFiles() int32 {
	if x != nil {
		return x.Files
	}
	return 0
}

// CommitIsAncestorRequest is the request for the CommitIsAncestor RPC.
type CommitIsAncestorRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository for which we need to check the ancestry.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// ancestor_id is the object ID of the commit which needs to be checked as ancestor.
	AncestorId string `protobuf:"bytes,2,opt,name=ancestor_id,json=ancestorId,proto3" json:"ancestor_id,omitempty"`
	// child_id is the object ID of the commit whose ancestor needs to be confirmed.
	ChildId       string `protobuf:"bytes,3,opt,name=child_id,json=childId,proto3" json:"child_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitIsAncestorRequest) ProtoMessage() {}

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

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

func (x *CommitIsAncestorRequest) GetAncestorId() string {
	if x != nil {
		return x.AncestorId
	}
	return ""
}

func (x *CommitIsAncestorRequest) GetChildId() string {
	if x != nil {
		return x.ChildId
	}
	return ""
}

// CommitIsAncestorResponse is the response for the CommitIsAncestor RPC.
type CommitIsAncestorResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// value denotes whether the provided commit is the ancestor or not.
	Value         bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitIsAncestorResponse) ProtoMessage() {}

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

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

// TreeEntryRequest is a request for the TreeEntry RPC.
type TreeEntryRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository for which to read the tree entry.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is the commitish at which the tree entry is to be read.
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// path is the path of the entry that shall be read, relative to the tree of the specified revision.
	Path []byte `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	// limit is the maximum number of bytes to fetch. If object is bigger, remaining bytes are not sent
	// 0 means there is no limit.
	Limit int64 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	// max_size is the maximum allowed object size. If bigger, a FailedPrecondition error is returned
	// 0 means there is no maximum size.
	MaxSize       int64 `protobuf:"varint,5,opt,name=max_size,json=maxSize,proto3" json:"max_size,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TreeEntryRequest) ProtoMessage() {}

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

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

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

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

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

func (x *TreeEntryRequest) GetMaxSize() int64 {
	if x != nil {
		return x.MaxSize
	}
	return 0
}

// TreeEntryResponse is a response for the TreeEntry RPC. The response will be
// chunked into multiple message if the returned data exceeds gRPC message limits.
type TreeEntryResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// type is the object type of the tree entry.
	Type TreeEntryResponse_ObjectType `protobuf:"varint,1,opt,name=type,proto3,enum=gitaly.TreeEntryResponse_ObjectType" json:"type,omitempty"`
	// oid is the object ID of the tree entry. In case of submodules, it contains the commit ID that the submodule
	// currently refers to.
	Oid string `protobuf:"bytes,2,opt,name=oid,proto3" json:"oid,omitempty"`
	// size is the size of the tree entry.
	Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	// mode is the mode of the tree entry.
	Mode int32 `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"`
	// data contains the raw object contents. This data may be split up across multiple messages.
	Data          []byte `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TreeEntryResponse) ProtoMessage() {}

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

func (x *TreeEntryResponse) GetType() TreeEntryResponse_ObjectType {
	if x != nil {
		return x.Type
	}
	return TreeEntryResponse_COMMIT
}

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

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

func (x *TreeEntryResponse) GetMode() int32 {
	if x != nil {
		return x.Mode
	}
	return 0
}

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

// CountCommitsRequest is the request for the CountCommits RPC.
type CountCommitsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which we want to count the number of commits.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is a commitish which is the start point for the traversal of commits.
	// Deprecated: Use the 'revisions' field instead. See https://gitlab.com/gitlab-org/gitlab/-/issues/588471
	//
	// Deprecated: Marked as deprecated in commit.proto.
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// after is used to filter commits more recent than a specific date.
	After *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=after,proto3" json:"after,omitempty"`
	// before is used to filter commits older than a specific date.
	Before *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=before,proto3" json:"before,omitempty"`
	// path is used to filter commits which modify the provided path.
	Path []byte `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
	// max_count is used to cap the number of commits.
	MaxCount int32 `protobuf:"varint,6,opt,name=max_count,json=maxCount,proto3" json:"max_count,omitempty"`
	// all is used to consider all refs (including HEAD) as the start point for the traversal.
	// all and Revision options are mutually exclusive.
	// Deprecated: Use revisions with '--all' pseudo-revision instead. See https://gitlab.com/gitlab-org/gitlab/-/issues/588471
	//
	// Deprecated: Marked as deprecated in commit.proto.
	All bool `protobuf:"varint,7,opt,name=all,proto3" json:"all,omitempty"`
	// first_parent ensures that only the first parent commit is followed in the traversal.
	FirstParent bool `protobuf:"varint,8,opt,name=first_parent,json=firstParent,proto3" json:"first_parent,omitempty"`
	// global_options contains the global options used to modify the behaviour of Git.
	GlobalOptions *GlobalOptions `protobuf:"bytes,9,opt,name=global_options,json=globalOptions,proto3" json:"global_options,omitempty"`
	// revisions is the set of revisions which should be walked to enumerate
	// commits. Accepts all notation as documented in gitrevisions(7) as well as
	// the pseudo-revisions `--not` and `--all` as documented in git-rev-list(1).
	// This is the preferred way to specify revisions; the 'revision' and 'all'
	// fields are deprecated.
	Revisions     [][]byte `protobuf:"bytes,10,rep,name=revisions,proto3" json:"revisions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CountCommitsRequest) ProtoMessage() {}

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

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

// Deprecated: Marked as deprecated in commit.proto.
func (x *CountCommitsRequest) GetRevision() []byte {
	if x != nil {
		return x.Revision
	}
	return nil
}

func (x *CountCommitsRequest) GetAfter() *timestamppb.Timestamp {
	if x != nil {
		return x.After
	}
	return nil
}

func (x *CountCommitsRequest) GetBefore() *timestamppb.Timestamp {
	if x != nil {
		return x.Before
	}
	return nil
}

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

func (x *CountCommitsRequest) GetMaxCount() int32 {
	if x != nil {
		return x.MaxCount
	}
	return 0
}

// Deprecated: Marked as deprecated in commit.proto.
func (x *CountCommitsRequest) GetAll() bool {
	if x != nil {
		return x.All
	}
	return false
}

func (x *CountCommitsRequest) GetFirstParent() bool {
	if x != nil {
		return x.FirstParent
	}
	return false
}

func (x *CountCommitsRequest) GetGlobalOptions() *GlobalOptions {
	if x != nil {
		return x.GlobalOptions
	}
	return nil
}

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

// CountCommitsResponse is the response for the CountCommits RPC.
type CountCommitsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// count denotes the number of commits found as per the given filters.
	Count         int32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CountCommitsResponse) ProtoMessage() {}

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

func (x *CountCommitsResponse) GetCount() int32 {
	if x != nil {
		return x.Count
	}
	return 0
}

// CountDivergingCommitsRequest is the request for the CountDivergingCommits RPC.
type CountDivergingCommitsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which we want to find the number of diverging commits.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// from is the object ID of one of the commits against which we want to check the
	// number of diverging commits. The From and To fields are interchangeable.
	From []byte `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
	// to is the object ID of one of the commits against which we want to check the
	// number of diverging commits. The To and From fields are interchangeable.
	To []byte `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
	// max_count denotes the cap for the number of diverging commits to be reported.
	MaxCount      int32 `protobuf:"varint,7,opt,name=max_count,json=maxCount,proto3" json:"max_count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CountDivergingCommitsRequest) ProtoMessage() {}

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

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

func (x *CountDivergingCommitsRequest) GetFrom() []byte {
	if x != nil {
		return x.From
	}
	return nil
}

func (x *CountDivergingCommitsRequest) GetTo() []byte {
	if x != nil {
		return x.To
	}
	return nil
}

func (x *CountDivergingCommitsRequest) GetMaxCount() int32 {
	if x != nil {
		return x.MaxCount
	}
	return 0
}

// CountDivergingCommitsResponse is the response for the CountDivergingCommits RPC.
type CountDivergingCommitsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// left_count denotes the number of diverging commits present in the 'From' commit provided.
	LeftCount int32 `protobuf:"varint,1,opt,name=left_count,json=leftCount,proto3" json:"left_count,omitempty"`
	// right_count denotes the number of diverging commits present in the 'To' commit provided.
	RightCount    int32 `protobuf:"varint,2,opt,name=right_count,json=rightCount,proto3" json:"right_count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CountDivergingCommitsResponse) ProtoMessage() {}

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

func (x *CountDivergingCommitsResponse) GetLeftCount() int32 {
	if x != nil {
		return x.LeftCount
	}
	return 0
}

func (x *CountDivergingCommitsResponse) GetRightCount() int32 {
	if x != nil {
		return x.RightCount
	}
	return 0
}

// TreeEntry denotes a single tree entry.
type TreeEntry struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// oid of the object this tree entry points to.
	Oid string `protobuf:"bytes,1,opt,name=oid,proto3" json:"oid,omitempty"`
	// path is the path of the entry relative to the tree of the specified revision.
	Path []byte `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	// type denotes the type of the tree entry.
	Type TreeEntry_EntryType `protobuf:"varint,4,opt,name=type,proto3,enum=gitaly.TreeEntry_EntryType" json:"type,omitempty"`
	// mode is the mode of the tree entry.
	Mode int32 `protobuf:"varint,5,opt,name=mode,proto3" json:"mode,omitempty"`
	// commit_oid is the commit object via which this entry was retrieved.
	CommitOid string `protobuf:"bytes,6,opt,name=commit_oid,json=commitOid,proto3" json:"commit_oid,omitempty"`
	// flat_path is the relative path of the first subdir that doesn't have only one directory descendant.
	FlatPath      []byte `protobuf:"bytes,7,opt,name=flat_path,json=flatPath,proto3" json:"flat_path,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TreeEntry) ProtoMessage() {}

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

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

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

func (x *TreeEntry) GetType() TreeEntry_EntryType {
	if x != nil {
		return x.Type
	}
	return TreeEntry_BLOB
}

func (x *TreeEntry) GetMode() int32 {
	if x != nil {
		return x.Mode
	}
	return 0
}

func (x *TreeEntry) GetCommitOid() string {
	if x != nil {
		return x.CommitOid
	}
	return ""
}

func (x *TreeEntry) GetFlatPath() []byte {
	if x != nil {
		return x.FlatPath
	}
	return nil
}

// GetTreeEntriesRequest is the request for the GetTreeEntries RPC.
type GetTreeEntriesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to get the tree entries from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is the commitish at which the tree entries is to be read.
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// path is the path of the entry that shall be read, relative to the tree of the specified revision.
	Path []byte `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	// recursive denotes wether to recursively fetch sub-trees.
	Recursive bool `protobuf:"varint,4,opt,name=recursive,proto3" json:"recursive,omitempty"`
	// sort defines the sorting parameter.
	Sort GetTreeEntriesRequest_SortBy `protobuf:"varint,5,opt,name=sort,proto3,enum=gitaly.GetTreeEntriesRequest_SortBy" json:"sort,omitempty"`
	// pagination_params controls paging. Refer to PaginationParameter documentation for
	// further info.
	PaginationParams *PaginationParameter `protobuf:"bytes,6,opt,name=pagination_params,json=paginationParams,proto3" json:"pagination_params,omitempty"`
	// skip_flat_paths is an option to skip the expensive operation of populating flat paths.
	SkipFlatPaths bool `protobuf:"varint,7,opt,name=skip_flat_paths,json=skipFlatPaths,proto3" json:"skip_flat_paths,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetTreeEntriesRequest) ProtoMessage() {}

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

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

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

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

func (x *GetTreeEntriesRequest) GetRecursive() bool {
	if x != nil {
		return x.Recursive
	}
	return false
}

func (x *GetTreeEntriesRequest) GetSort() GetTreeEntriesRequest_SortBy {
	if x != nil {
		return x.Sort
	}
	return GetTreeEntriesRequest_DEFAULT
}

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

func (x *GetTreeEntriesRequest) GetSkipFlatPaths() bool {
	if x != nil {
		return x.SkipFlatPaths
	}
	return false
}

// GetTreeEntriesResponse is the response for the GetTreeEntries RPC. The response will be
// chunked into multiple message if the returned data exceeds gRPC message limits.
type GetTreeEntriesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// entries denotes a list of tree entries.
	Entries []*TreeEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	// pagination_cursor defines the offset for subsequent requests. 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 *GetTreeEntriesResponse) Reset() {
	*x = GetTreeEntriesResponse{}
	mi := &file_commit_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetTreeEntriesResponse) ProtoMessage() {}

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

func (x *GetTreeEntriesResponse) GetEntries() []*TreeEntry {
	if x != nil {
		return x.Entries
	}
	return nil
}

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

// GetTreeEntriesError may be returned when GetTreeEntries fails with a specific root
// cause.
type GetTreeEntriesError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*GetTreeEntriesError_ResolveTree
	//	*GetTreeEntriesError_Path
	Error         isGetTreeEntriesError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetTreeEntriesError) ProtoMessage() {}

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

func (x *GetTreeEntriesError) GetError() isGetTreeEntriesError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *GetTreeEntriesError) GetResolveTree() *ResolveRevisionError {
	if x != nil {
		if x, ok := x.Error.(*GetTreeEntriesError_ResolveTree); ok {
			return x.ResolveTree
		}
	}
	return nil
}

func (x *GetTreeEntriesError) GetPath() *PathError {
	if x != nil {
		if x, ok := x.Error.(*GetTreeEntriesError_Path); ok {
			return x.Path
		}
	}
	return nil
}

type isGetTreeEntriesError_Error interface {
	isGetTreeEntriesError_Error()
}

type GetTreeEntriesError_ResolveTree struct {
	// resolve_tree is set when the provided revision ID could not be resolved.
	ResolveTree *ResolveRevisionError `protobuf:"bytes,1,opt,name=resolve_tree,json=resolveTree,proto3,oneof"`
}

type GetTreeEntriesError_Path struct {
	// path is set when the provided path is not valid.
	Path *PathError `protobuf:"bytes,2,opt,name=path,proto3,oneof"`
}

func (*GetTreeEntriesError_ResolveTree) isGetTreeEntriesError_Error() {}

func (*GetTreeEntriesError_Path) isGetTreeEntriesError_Error() {}

// ListFilesRequest is the request for the ListFiles RPC.
type ListFilesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to list the files from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is a commitish against which we list all files.
	Revision      []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListFilesRequest) ProtoMessage() {}

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

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

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

// ListFilesResponse is the response for the ListFiles RPC. The response will be
// chunked into multiple message if the returned data exceeds gRPC message limits.
type ListFilesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// paths is the list of paths found for the requested revision. Clients must
	// remember to force utf-8 encoding.
	Paths         [][]byte `protobuf:"bytes,1,rep,name=paths,proto3" json:"paths,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListFilesResponse) ProtoMessage() {}

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

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

// FindCommitRequest is the request for the FindCommit RPC.
type FindCommitRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which we want to find the commit.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is a commitish which is to be resolved to a commit.
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// trailers if set, parses and adds the trailing information of the commit.
	Trailers      bool `protobuf:"varint,3,opt,name=trailers,proto3" json:"trailers,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindCommitRequest) ProtoMessage() {}

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

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

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

func (x *FindCommitRequest) GetTrailers() bool {
	if x != nil {
		return x.Trailers
	}
	return false
}

// FindCommitResponse is the request for the FindCommit RPC. Returns empty response
// if the commit is not found.
type FindCommitResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit is the requested commit, it is nil when the commit was not found.
	Commit        *GitCommit `protobuf:"bytes,1,opt,name=commit,proto3" json:"commit,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindCommitResponse) ProtoMessage() {}

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

func (x *FindCommitResponse) GetCommit() *GitCommit {
	if x != nil {
		return x.Commit
	}
	return nil
}

// ListCommitsByOidRequest is the request for the ListCommitsByOid RPC.
type ListCommitsByOidRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to list commits from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// oid is a set of commitish object IDs to list commits for.
	// If there is no commit against a provided object ID, no error is thrown. It is simply ignored.
	Oid           []string `protobuf:"bytes,2,rep,name=oid,proto3" json:"oid,omitempty"` // protolint:disable:this REPEATED_FIELD_NAMES_PLURALIZED
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListCommitsByOidRequest) ProtoMessage() {}

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

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

func (x *ListCommitsByOidRequest) GetOid() []string {
	if x != nil {
		return x.Oid
	}
	return nil
}

// ListCommitsByOidResponse is the response for the ListCommitsByOid RPC.
type ListCommitsByOidResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commits are the list of commits for the provided object IDs from the request.
	Commits       []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListCommitsByOidResponse) ProtoMessage() {}

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

func (x *ListCommitsByOidResponse) GetCommits() []*GitCommit {
	if x != nil {
		return x.Commits
	}
	return nil
}

// ListCommitsByRefNameRequest is the request for the ListCommitsByRefName RPC.
type ListCommitsByRefNameRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to list commits from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// ref_names is a set of references to obtain commits for.
	// If there is no commit against a provided reference, no error is thrown. It is simply ignored.
	RefNames      [][]byte `protobuf:"bytes,2,rep,name=ref_names,json=refNames,proto3" json:"ref_names,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListCommitsByRefNameRequest) ProtoMessage() {}

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

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

func (x *ListCommitsByRefNameRequest) GetRefNames() [][]byte {
	if x != nil {
		return x.RefNames
	}
	return nil
}

// ListCommitsByRefNameResponse is the response for the ListCommitsByRefName RPC.
type ListCommitsByRefNameResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit_refs is a list of CommitForRef objects which provides the commits
	// against the requested references.
	CommitRefs    []*ListCommitsByRefNameResponse_CommitForRef `protobuf:"bytes,2,rep,name=commit_refs,json=commitRefs,proto3" json:"commit_refs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListCommitsByRefNameResponse) ProtoMessage() {}

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

func (x *ListCommitsByRefNameResponse) GetCommitRefs() []*ListCommitsByRefNameResponse_CommitForRef {
	if x != nil {
		return x.CommitRefs
	}
	return nil
}

// FindAllCommitsRequest is the request for the FindAllCommits RPC.
type FindAllCommitsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository from which we will list the commits.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is the commitish which is the starting point for the traversal. When nil,
	// return all commits reachable by any branch in the repo.
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// max_count is the maximum number of commits to list.
	MaxCount int32 `protobuf:"varint,3,opt,name=max_count,json=maxCount,proto3" json:"max_count,omitempty"`
	// skip is the number of commits to skip before starting to show the
	// commit output.
	Skip int32 `protobuf:"varint,4,opt,name=skip,proto3" json:"skip,omitempty"`
	// order is the order in which commits should be traversed. Refer to
	// the enum's documentation for further information.
	Order         FindAllCommitsRequest_Order `protobuf:"varint,5,opt,name=order,proto3,enum=gitaly.FindAllCommitsRequest_Order" json:"order,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindAllCommitsRequest) ProtoMessage() {}

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

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

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

func (x *FindAllCommitsRequest) GetMaxCount() int32 {
	if x != nil {
		return x.MaxCount
	}
	return 0
}

func (x *FindAllCommitsRequest) GetSkip() int32 {
	if x != nil {
		return x.Skip
	}
	return 0
}

func (x *FindAllCommitsRequest) GetOrder() FindAllCommitsRequest_Order {
	if x != nil {
		return x.Order
	}
	return FindAllCommitsRequest_NONE
}

// FindAllCommitsResponse is the response for the FindAllCommits RPC. The response will be
// chunked into multiple message if the returned data exceeds gRPC message limits.
type FindAllCommitsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commits is a list of commits produced as per the request.
	Commits       []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindAllCommitsResponse) ProtoMessage() {}

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

func (x *FindAllCommitsResponse) GetCommits() []*GitCommit {
	if x != nil {
		return x.Commits
	}
	return nil
}

// FindCommitsRequest is the request for the FindCommits RPC.
type FindCommitsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository from which the commits are listed.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is a commitish against which the commits for the provided
	// paths are listed. If there is no revision provided, the default branch
	// is considered. It is mutually exclusive with the `All` option.
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// limit is maximum number of commits to list.
	Limit int32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	// offset is the number of commits to skip before starting the traversal.
	Offset int32 `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"`
	// paths is a list of non-empty paths for which we want to list commits.
	Paths [][]byte `protobuf:"bytes,5,rep,name=paths,proto3" json:"paths,omitempty"`
	// follow is used to list the history of a file beyond renames (works only for
	// a single file).
	Follow bool `protobuf:"varint,6,opt,name=follow,proto3" json:"follow,omitempty"`
	// skip_merges is used to skip merge commits.
	SkipMerges bool `protobuf:"varint,7,opt,name=skip_merges,json=skipMerges,proto3" json:"skip_merges,omitempty"`
	// disable_walk is no longer supported.
	//
	// Deprecated: Marked as deprecated in commit.proto.
	DisableWalk bool `protobuf:"varint,8,opt,name=disable_walk,json=disableWalk,proto3" json:"disable_walk,omitempty"`
	// after will only list commits which are more recent than the specified date.
	After *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=after,proto3" json:"after,omitempty"`
	// before will only list commits which are older than the specified date.
	Before *timestamppb.Timestamp `protobuf:"bytes,10,opt,name=before,proto3" json:"before,omitempty"`
	// all is used to consider all refs (including HEAD) as the start point for the traversal.
	// `all` and `revision` options are mutually exclusive.
	All bool `protobuf:"varint,11,opt,name=all,proto3" json:"all,omitempty"`
	// first_parent ensures that only the first parent commit is followed in the traversal.
	FirstParent bool `protobuf:"varint,12,opt,name=first_parent,json=firstParent,proto3" json:"first_parent,omitempty"`
	// author will only list commits whose author matches the given pattern,
	// which is a regular expression.
	Author []byte `protobuf:"bytes,13,opt,name=author,proto3" json:"author,omitempty"`
	// order is the order in which commits should be traversed. Please refer to
	// the enum's documentation for further information.
	Order FindCommitsRequest_Order `protobuf:"varint,14,opt,name=order,proto3,enum=gitaly.FindCommitsRequest_Order" json:"order,omitempty"`
	// global_options contains the global options used to modify the behaviour of Git.
	GlobalOptions *GlobalOptions `protobuf:"bytes,15,opt,name=global_options,json=globalOptions,proto3" json:"global_options,omitempty"`
	// trailers if set, parses and adds the trailing information of the commit.
	Trailers bool `protobuf:"varint,16,opt,name=trailers,proto3" json:"trailers,omitempty"`
	// include_shortstat determines whether to include the number of lines and files
	// changed in the commits. Populates the `ShortStats` field.
	IncludeShortstat bool `protobuf:"varint,17,opt,name=include_shortstat,json=includeShortstat,proto3" json:"include_shortstat,omitempty"`
	// include_referenced_by determines whether to include references that point to a
	// commit in the response. The field contains patterns that are matched against
	// references. Only matching references are included in the response. For
	// example, one can get tags pointing to a commit with `refs/tags`, or branches
	// respectively with `refs/heads`. By sending both, the response will include all
	// references that match either pattern.
	IncludeReferencedBy [][]byte `protobuf:"bytes,18,rep,name=include_referenced_by,json=includeReferencedBy,proto3" json:"include_referenced_by,omitempty"` // protolint:disable:this REPEATED_FIELD_NAMES_PLURALIZED
	// message_regex is used to select only commits with messages matching the provided pattern.
	// The pattern is a case-insensitive basic Posix regular expression.
	MessageRegex  string `protobuf:"bytes,19,opt,name=message_regex,json=messageRegex,proto3" json:"message_regex,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindCommitsRequest) ProtoMessage() {}

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

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

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

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

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

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

func (x *FindCommitsRequest) GetFollow() bool {
	if x != nil {
		return x.Follow
	}
	return false
}

func (x *FindCommitsRequest) GetSkipMerges() bool {
	if x != nil {
		return x.SkipMerges
	}
	return false
}

// Deprecated: Marked as deprecated in commit.proto.
func (x *FindCommitsRequest) GetDisableWalk() bool {
	if x != nil {
		return x.DisableWalk
	}
	return false
}

func (x *FindCommitsRequest) GetAfter() *timestamppb.Timestamp {
	if x != nil {
		return x.After
	}
	return nil
}

func (x *FindCommitsRequest) GetBefore() *timestamppb.Timestamp {
	if x != nil {
		return x.Before
	}
	return nil
}

func (x *FindCommitsRequest) GetAll() bool {
	if x != nil {
		return x.All
	}
	return false
}

func (x *FindCommitsRequest) GetFirstParent() bool {
	if x != nil {
		return x.FirstParent
	}
	return false
}

func (x *FindCommitsRequest) GetAuthor() []byte {
	if x != nil {
		return x.Author
	}
	return nil
}

func (x *FindCommitsRequest) GetOrder() FindCommitsRequest_Order {
	if x != nil {
		return x.Order
	}
	return FindCommitsRequest_NONE
}

func (x *FindCommitsRequest) GetGlobalOptions() *GlobalOptions {
	if x != nil {
		return x.GlobalOptions
	}
	return nil
}

func (x *FindCommitsRequest) GetTrailers() bool {
	if x != nil {
		return x.Trailers
	}
	return false
}

func (x *FindCommitsRequest) GetIncludeShortstat() bool {
	if x != nil {
		return x.IncludeShortstat
	}
	return false
}

func (x *FindCommitsRequest) GetIncludeReferencedBy() [][]byte {
	if x != nil {
		return x.IncludeReferencedBy
	}
	return nil
}

func (x *FindCommitsRequest) GetMessageRegex() string {
	if x != nil {
		return x.MessageRegex
	}
	return ""
}

// FindCommitsResponse is the response for the FindCommits RPC. The response will be
// chunked into multiple message if the returned data exceeds gRPC message limits.
type FindCommitsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commits is a list of commits produced as per the request.
	Commits       []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindCommitsResponse) ProtoMessage() {}

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

func (x *FindCommitsResponse) GetCommits() []*GitCommit {
	if x != nil {
		return x.Commits
	}
	return nil
}

// FindCommitsError is an error returned by the FindCommits RPC when no commit is found.
type FindCommitsError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// error denotes the type of error encountered.
	//
	// Types that are valid to be assigned to Error:
	//
	//	*FindCommitsError_BadObject
	//	*FindCommitsError_AmbiguousRef
	//	*FindCommitsError_InvalidRange
	Error         isFindCommitsError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindCommitsError) ProtoMessage() {}

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

func (x *FindCommitsError) GetError() isFindCommitsError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *FindCommitsError) GetBadObject() *BadObjectError {
	if x != nil {
		if x, ok := x.Error.(*FindCommitsError_BadObject); ok {
			return x.BadObject
		}
	}
	return nil
}

func (x *FindCommitsError) GetAmbiguousRef() *AmbiguousReferenceError {
	if x != nil {
		if x, ok := x.Error.(*FindCommitsError_AmbiguousRef); ok {
			return x.AmbiguousRef
		}
	}
	return nil
}

func (x *FindCommitsError) GetInvalidRange() *InvalidRevisionRange {
	if x != nil {
		if x, ok := x.Error.(*FindCommitsError_InvalidRange); ok {
			return x.InvalidRange
		}
	}
	return nil
}

type isFindCommitsError_Error interface {
	isFindCommitsError_Error()
}

type FindCommitsError_BadObject struct {
	// bad_object is returned when the revision cannot be found in the git repository.
	BadObject *BadObjectError `protobuf:"bytes,1,opt,name=bad_object,json=badObject,proto3,oneof"`
}

type FindCommitsError_AmbiguousRef struct {
	// ambiguous_ref is returned when the given revision cannot be found.
	AmbiguousRef *AmbiguousReferenceError `protobuf:"bytes,2,opt,name=ambiguous_ref,json=ambiguousRef,proto3,oneof"`
}

type FindCommitsError_InvalidRange struct {
	// invalid_range is returned when the provided revision-range cannot be found in the git repository.
	InvalidRange *InvalidRevisionRange `protobuf:"bytes,3,opt,name=invalid_range,json=invalidRange,proto3,oneof"`
}

func (*FindCommitsError_BadObject) isFindCommitsError_Error() {}

func (*FindCommitsError_AmbiguousRef) isFindCommitsError_Error() {}

func (*FindCommitsError_InvalidRange) isFindCommitsError_Error() {}

// CommitLanguagesRequest requests to detect the source code languages.
type CommitLanguagesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository where to detect the languages in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision tells for which commitish the languages should be detected. If it's
	// omitted, the HEAD commit of the default branch is used.
	Revision      []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitLanguagesRequest) ProtoMessage() {}

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

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

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

// CommitLanguagesResponse returns the language statistics.
type CommitLanguagesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// languages is a set of all the detected languages and their statistics.
	Languages     []*CommitLanguagesResponse_Language `protobuf:"bytes,1,rep,name=languages,proto3" json:"languages,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitLanguagesResponse) ProtoMessage() {}

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

func (x *CommitLanguagesResponse) GetLanguages() []*CommitLanguagesResponse_Language {
	if x != nil {
		return x.Languages
	}
	return nil
}

// RawBlameRequest is a request for the RawBlame RPC.
type RawBlameRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to perform the blame on.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is the commitish at which to start the blame.
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// path is the path of the blob that should be blamed.
	Path []byte `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	// range is the comma-separated range of line numbers to perform the blame on, e.g. "1,1000". Optional - if no range
	// is provided, the whole file will be blamed.
	Range []byte `protobuf:"bytes,4,opt,name=range,proto3" json:"range,omitempty"`
	// ignore_revisions_blob contains a revision like `refs/heads/master:.git-ignore-revs-file` that resolves
	// to a blob. If set, the file will be used as input to git-blame(1) to ignore certain commits during
	// blame. Please refer to the git-blame(1), more specifically the `--ignore-revs-file` parameter, for
	// more information.
	//
	// If unset, no commits will be ignored. If set, it must resolve to a valid blob or otherwise the RPC
	// call will fail.
	IgnoreRevisionsBlob []byte `protobuf:"bytes,5,opt,name=ignore_revisions_blob,json=ignoreRevisionsBlob,proto3" json:"ignore_revisions_blob,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*RawBlameRequest) ProtoMessage() {}

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

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

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

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

func (x *RawBlameRequest) GetRange() []byte {
	if x != nil {
		return x.Range
	}
	return nil
}

func (x *RawBlameRequest) GetIgnoreRevisionsBlob() []byte {
	if x != nil {
		return x.IgnoreRevisionsBlob
	}
	return nil
}

// RawBlameResponse is a response for the RawBlame RPC. The response will be
// chunked into multiple message if the returned data exceeds gRPC message limits.
type RawBlameResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data is the raw data as generated by git-blame(1).
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RawBlameResponse) ProtoMessage() {}

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

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

// RawBlameError is used as error detail when the RawBlame RPC fails in a specific way.
type RawBlameError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// error denotes the type of error encountered.
	//
	// Types that are valid to be assigned to Error:
	//
	//	*RawBlameError_PathNotFound
	//	*RawBlameError_OutOfRange
	//	*RawBlameError_ResolveIgnoreRevs
	//	*RawBlameError_InvalidIgnoreRevsFormat
	Error         isRawBlameError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RawBlameError) ProtoMessage() {}

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

func (x *RawBlameError) GetError() isRawBlameError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *RawBlameError) GetPathNotFound() *PathNotFoundError {
	if x != nil {
		if x, ok := x.Error.(*RawBlameError_PathNotFound); ok {
			return x.PathNotFound
		}
	}
	return nil
}

func (x *RawBlameError) GetOutOfRange() *RawBlameError_OutOfRangeError {
	if x != nil {
		if x, ok := x.Error.(*RawBlameError_OutOfRange); ok {
			return x.OutOfRange
		}
	}
	return nil
}

func (x *RawBlameError) GetResolveIgnoreRevs() *RawBlameError_ResolveIgnoreRevsError {
	if x != nil {
		if x, ok := x.Error.(*RawBlameError_ResolveIgnoreRevs); ok {
			return x.ResolveIgnoreRevs
		}
	}
	return nil
}

func (x *RawBlameError) GetInvalidIgnoreRevsFormat() *RawBlameError_InvalidIgnoreRevsFormatError {
	if x != nil {
		if x, ok := x.Error.(*RawBlameError_InvalidIgnoreRevsFormat); ok {
			return x.InvalidIgnoreRevsFormat
		}
	}
	return nil
}

type isRawBlameError_Error interface {
	isRawBlameError_Error()
}

type RawBlameError_PathNotFound struct {
	// path_not_found is returned when the blamed path cannot be found in the revision.
	PathNotFound *PathNotFoundError `protobuf:"bytes,1,opt,name=path_not_found,json=pathNotFound,proto3,oneof"`
}

type RawBlameError_OutOfRange struct {
	// out_of_range is returned when the specified blamed range exceeds the file length.
	OutOfRange *RawBlameError_OutOfRangeError `protobuf:"bytes,2,opt,name=out_of_range,json=outOfRange,proto3,oneof"`
}

type RawBlameError_ResolveIgnoreRevs struct {
	// resolve_ignore_revs indicates that resolving the specified file containing
	// ignored revisions has failed.
	ResolveIgnoreRevs *RawBlameError_ResolveIgnoreRevsError `protobuf:"bytes,3,opt,name=resolve_ignore_revs,json=resolveIgnoreRevs,proto3,oneof"`
}

type RawBlameError_InvalidIgnoreRevsFormat struct {
	// invalid_ignore_revs_format indicates that the specified file containing ignored
	// revisions has an invalid format.
	InvalidIgnoreRevsFormat *RawBlameError_InvalidIgnoreRevsFormatError `protobuf:"bytes,4,opt,name=invalid_ignore_revs_format,json=invalidIgnoreRevsFormat,proto3,oneof"`
}

func (*RawBlameError_PathNotFound) isRawBlameError_Error() {}

func (*RawBlameError_OutOfRange) isRawBlameError_Error() {}

func (*RawBlameError_ResolveIgnoreRevs) isRawBlameError_Error() {}

func (*RawBlameError_InvalidIgnoreRevsFormat) isRawBlameError_Error() {}

// LastCommitForPathRequest is a request for the LastCommitForPath RPC.
type LastCommitForPathRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to run the query in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is the commitish that is used as the start commit to perform the search.
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// path is the path for which the last commit should be searched. This path can either point to a blob or to a
	// tree. The path must be relative and must not escape the repository root. If the path is empty or "/", then the
	// repository root will be searched instead.
	Path []byte `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	// literal_pathspec will treat the path literally. No globbing or pathspec magic is performed. This option is
	// deprecated in favor of GlobalOptions.
	LiteralPathspec bool `protobuf:"varint,4,opt,name=literal_pathspec,json=literalPathspec,proto3" json:"literal_pathspec,omitempty"`
	// global_options contains the global options used to modify the behaviour of Git.
	GlobalOptions *GlobalOptions `protobuf:"bytes,5,opt,name=global_options,json=globalOptions,proto3" json:"global_options,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LastCommitForPathRequest) ProtoMessage() {}

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

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

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

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

func (x *LastCommitForPathRequest) GetLiteralPathspec() bool {
	if x != nil {
		return x.LiteralPathspec
	}
	return false
}

func (x *LastCommitForPathRequest) GetGlobalOptions() *GlobalOptions {
	if x != nil {
		return x.GlobalOptions
	}
	return nil
}

// LastCommitForPathResponse is a response for the LastCommitForPath RPC.
type LastCommitForPathResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit is the commit that has last modified the given path. Unset in case the path could not be found.
	Commit        *GitCommit `protobuf:"bytes,1,opt,name=commit,proto3" json:"commit,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LastCommitForPathResponse) ProtoMessage() {}

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

func (x *LastCommitForPathResponse) GetCommit() *GitCommit {
	if x != nil {
		return x.Commit
	}
	return nil
}

// ListLastCommitsForTreeRequest is the request for the ListLastCommitsForTree RPC.
type ListLastCommitsForTreeRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to run the query in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is the treeish to retrieve commits against.
	Revision string `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// path is the relative path to further filter against the treeish revision. This path can either point to a blob
	// or to a tree. The path must be relative and must not escape the repository root. If the path is empty or "/", then
	// it will be replaced with the root of of the repository.
	Path []byte `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	// limit is the number of tree entries to limit the response to.
	Limit int32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	// offset is the offset of the tree entries from which to start the response.
	Offset int32 `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"`
	// literal_pathspec is deprecated.
	//
	// Deprecated: Marked as deprecated in commit.proto.
	LiteralPathspec bool `protobuf:"varint,6,opt,name=literal_pathspec,json=literalPathspec,proto3" json:"literal_pathspec,omitempty"`
	// global_options contains the global options used to modify the behaviour of Git.
	GlobalOptions *GlobalOptions `protobuf:"bytes,7,opt,name=global_options,json=globalOptions,proto3" json:"global_options,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListLastCommitsForTreeRequest) ProtoMessage() {}

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

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

func (x *ListLastCommitsForTreeRequest) GetRevision() string {
	if x != nil {
		return x.Revision
	}
	return ""
}

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

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

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

// Deprecated: Marked as deprecated in commit.proto.
func (x *ListLastCommitsForTreeRequest) GetLiteralPathspec() bool {
	if x != nil {
		return x.LiteralPathspec
	}
	return false
}

func (x *ListLastCommitsForTreeRequest) GetGlobalOptions() *GlobalOptions {
	if x != nil {
		return x.GlobalOptions
	}
	return nil
}

// ListLastCommitsForTreeResponse is the response for the ListLastCommitsForTree RPC.
type ListLastCommitsForTreeResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commits is a set of CommitForTree objects.
	Commits       []*ListLastCommitsForTreeResponse_CommitForTree `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListLastCommitsForTreeResponse) ProtoMessage() {}

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

func (x *ListLastCommitsForTreeResponse) GetCommits() []*ListLastCommitsForTreeResponse_CommitForTree {
	if x != nil {
		return x.Commits
	}
	return nil
}

// CommitsByMessageRequest is the request for the CommitsByMessage RPC.
type CommitsByMessageRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to run the query in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revision is the commitish to retrieve commits against.
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// offset is the offset from which to list commits.
	Offset int32 `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	// limit is the maximum number of commits to list.
	Limit int32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	// path is the relative path to filter the commits to.
	Path []byte `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
	// query is the search param to search commit messages against.
	Query string `protobuf:"bytes,6,opt,name=query,proto3" json:"query,omitempty"`
	// global_options contains the global options used to modify the behaviour of Git.
	GlobalOptions *GlobalOptions `protobuf:"bytes,7,opt,name=global_options,json=globalOptions,proto3" json:"global_options,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitsByMessageRequest) ProtoMessage() {}

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

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

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

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

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

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

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

func (x *CommitsByMessageRequest) GetGlobalOptions() *GlobalOptions {
	if x != nil {
		return x.GlobalOptions
	}
	return nil
}

// CommitsByMessageResponse is the response for the CommitsByMessage RPC.
// One 'page' of the paginated response of CommitsByMessage.
type CommitsByMessageResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commits is the list of commits which match the query from the request.
	Commits       []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitsByMessageResponse) ProtoMessage() {}

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

// Deprecated: Use CommitsByMessageResponse.ProtoReflect.Descriptor instead.
func (*CommitsByMessageResponse) Descriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{41}
}

func (x *CommitsByMessageResponse) GetCommits() []*GitCommit {
	if x != nil {
		return x.Commits
	}
	return nil
}

// FilterShasWithSignaturesRequest is the request for the FilterShasWithSignatures RPC.
type FilterShasWithSignaturesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to retrieve the commits from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// shas is a set of commitish object IDs. If there is no corresponding commit for a
	// provided sha, no error will be thrown. Only signed commits will be returned in the
	// response.
	Shas          [][]byte `protobuf:"bytes,2,rep,name=shas,proto3" json:"shas,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FilterShasWithSignaturesRequest) ProtoMessage() {}

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

// Deprecated: Use FilterShasWithSignaturesRequest.ProtoReflect.Descriptor instead.
func (*FilterShasWithSignaturesRequest) Descriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{42}
}

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

func (x *FilterShasWithSignaturesRequest) GetShas() [][]byte {
	if x != nil {
		return x.Shas
	}
	return nil
}

// FilterShasWithSignaturesResponse is the response for the FilterShasWithSignatures RPC.
type FilterShasWithSignaturesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// shas is the filtered list of shas from the request which have an associated signed
	// commit.
	Shas          [][]byte `protobuf:"bytes,1,rep,name=shas,proto3" json:"shas,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FilterShasWithSignaturesResponse) ProtoMessage() {}

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

// Deprecated: Use FilterShasWithSignaturesResponse.ProtoReflect.Descriptor instead.
func (*FilterShasWithSignaturesResponse) Descriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{43}
}

func (x *FilterShasWithSignaturesResponse) GetShas() [][]byte {
	if x != nil {
		return x.Shas
	}
	return nil
}

// GetCommitSignaturesRequest is the request for the GetCommitSignatures RPC.
type GetCommitSignaturesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to retrieve the commits from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// commit_ids is the list of commitish object IDs for whom we want to retrieve
	// signature information. If a commit doesn't have associated signature information
	// it will be omitted from the results.
	CommitIds     []string `protobuf:"bytes,2,rep,name=commit_ids,json=commitIds,proto3" json:"commit_ids,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetCommitSignaturesRequest) ProtoMessage() {}

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

// Deprecated: Use GetCommitSignaturesRequest.ProtoReflect.Descriptor instead.
func (*GetCommitSignaturesRequest) Descriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{44}
}

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

func (x *GetCommitSignaturesRequest) GetCommitIds() []string {
	if x != nil {
		return x.CommitIds
	}
	return nil
}

// GetCommitSignaturesResponse is the response for the GetCommitSignatures RPC.
type GetCommitSignaturesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit_id of the signature.
	CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// signature of the commit (GPG or SSH).
	Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	// signed_text is text that is used to verify the signature.
	SignedText []byte `protobuf:"bytes,3,opt,name=signed_text,json=signedText,proto3" json:"signed_text,omitempty"`
	// signer of the commit
	Signer GetCommitSignaturesResponse_Signer `protobuf:"varint,4,opt,name=signer,proto3,enum=gitaly.GetCommitSignaturesResponse_Signer" json:"signer,omitempty"`
	// author provides the original commit author information without 'mailmap'.
	Author *CommitAuthor `protobuf:"bytes,5,opt,name=author,proto3" json:"author,omitempty"`
	// committer provides the original commit committer information without 'mailmap'.
	// Uses CommitAuthor type as committer has the same structure.
	Committer     *CommitAuthor `protobuf:"bytes,6,opt,name=committer,proto3" json:"committer,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetCommitSignaturesResponse) Reset() {
	*x = GetCommitSignaturesResponse{}
	mi := &file_commit_proto_msgTypes[45]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetCommitSignaturesResponse) ProtoMessage() {}

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

// Deprecated: Use GetCommitSignaturesResponse.ProtoReflect.Descriptor instead.
func (*GetCommitSignaturesResponse) Descriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{45}
}

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

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

func (x *GetCommitSignaturesResponse) GetSignedText() []byte {
	if x != nil {
		return x.SignedText
	}
	return nil
}

func (x *GetCommitSignaturesResponse) GetSigner() GetCommitSignaturesResponse_Signer {
	if x != nil {
		return x.Signer
	}
	return GetCommitSignaturesResponse_SIGNER_UNSPECIFIED
}

func (x *GetCommitSignaturesResponse) GetAuthor() *CommitAuthor {
	if x != nil {
		return x.Author
	}
	return nil
}

func (x *GetCommitSignaturesResponse) GetCommitter() *CommitAuthor {
	if x != nil {
		return x.Committer
	}
	return nil
}

// GetCommitMessagesRequest is the request for the GetCommitMessages RPC.
type GetCommitMessagesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to retrieve the commits from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// commit_ids is the list of commitish object IDs for whom we want to retrieve
	// the commit message.
	CommitIds     []string `protobuf:"bytes,2,rep,name=commit_ids,json=commitIds,proto3" json:"commit_ids,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetCommitMessagesRequest) ProtoMessage() {}

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

// Deprecated: Use GetCommitMessagesRequest.ProtoReflect.Descriptor instead.
func (*GetCommitMessagesRequest) Descriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{46}
}

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

func (x *GetCommitMessagesRequest) GetCommitIds() []string {
	if x != nil {
		return x.CommitIds
	}
	return nil
}

// GetCommitMessagesResponse is the response for the GetCommitMessages RPC.
type GetCommitMessagesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit_id is the commit object ID. A response with commit_id set, will be followed with
	// response with the message field set with the commit message for that commit.
	CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// message is the commit message for the commit.
	Message       []byte `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetCommitMessagesResponse) ProtoMessage() {}

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

// Deprecated: Use GetCommitMessagesResponse.ProtoReflect.Descriptor instead.
func (*GetCommitMessagesResponse) Descriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{47}
}

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

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

// CheckObjectsExistRequest is a request for the CheckObjectsExist RPC.
type CheckObjectsExistRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which existence of objects and refs
	// are checked. Only the initial request must contain a repository, the repository of all
	// subsequent requests will be ignored.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// revisions contains the revisions that shall be checked for existence. This accepts all revisions
	// as documented in gitrevisions(7).
	Revisions     [][]byte `protobuf:"bytes,2,rep,name=revisions,proto3" json:"revisions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CheckObjectsExistRequest) ProtoMessage() {}

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

// Deprecated: Use CheckObjectsExistRequest.ProtoReflect.Descriptor instead.
func (*CheckObjectsExistRequest) Descriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{48}
}

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

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

// CheckObjectsExistResponse is a response for the CheckObjectsExist RPC.
type CheckObjectsExistResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// revisions is the list of RevisionExistence objects used to indicate which
	// revisions exist.
	Revisions     []*CheckObjectsExistResponse_RevisionExistence `protobuf:"bytes,1,rep,name=revisions,proto3" json:"revisions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CheckObjectsExistResponse) ProtoMessage() {}

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

// Deprecated: Use CheckObjectsExistResponse.ProtoReflect.Descriptor instead.
func (*CheckObjectsExistResponse) Descriptor() ([]byte, []int) {
	return file_commit_proto_rawDescGZIP(), []int{49}
}

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

// CommitForRef holds the commit for a given reference.
type ListCommitsByRefNameResponse_CommitForRef struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit is the commit object against the reference.
	Commit *GitCommit `protobuf:"bytes,1,opt,name=commit,proto3" json:"commit,omitempty"`
	// ref_name is a reference from the repository.
	RefName       []byte `protobuf:"bytes,2,opt,name=ref_name,json=refName,proto3" json:"ref_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListCommitsByRefNameResponse_CommitForRef) ProtoMessage() {}

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

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

func (x *ListCommitsByRefNameResponse_CommitForRef) GetCommit() *GitCommit {
	if x != nil {
		return x.Commit
	}
	return nil
}

func (x *ListCommitsByRefNameResponse_CommitForRef) GetRefName() []byte {
	if x != nil {
		return x.RefName
	}
	return nil
}

// Language specifies the statistics for one language.
type CommitLanguagesResponse_Language struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// name is the name of the detected language, for example: Ruby, Go, HTML
	// A full list of language names can be found at:
	// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// share is the percentual share (value between 0 and 100) of this language
	// in relation to other languages that exist in the given revision.
	Share float32 `protobuf:"fixed32,2,opt,name=share,proto3" json:"share,omitempty"`
	// color specifies the associated color for this language, for example #3fd5e0.
	Color string `protobuf:"bytes,3,opt,name=color,proto3" json:"color,omitempty"`
	// bytes is the total amount of bytes written in this language
	Bytes uint64 `protobuf:"varint,5,opt,name=bytes,proto3" json:"bytes,omitempty"`
	// language_id is a unique ID of the language from https://github.com/github-linguist/linguist/blob/main/lib/linguist/languages.yml
	LanguageId    int64 `protobuf:"varint,6,opt,name=language_id,json=languageId,proto3" json:"language_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitLanguagesResponse_Language) ProtoMessage() {}

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

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

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

func (x *CommitLanguagesResponse_Language) GetShare() float32 {
	if x != nil {
		return x.Share
	}
	return 0
}

func (x *CommitLanguagesResponse_Language) GetColor() string {
	if x != nil {
		return x.Color
	}
	return ""
}

func (x *CommitLanguagesResponse_Language) GetBytes() uint64 {
	if x != nil {
		return x.Bytes
	}
	return 0
}

func (x *CommitLanguagesResponse_Language) GetLanguageId() int64 {
	if x != nil {
		return x.LanguageId
	}
	return 0
}

// OutOfRangeError indicates that the specified file range that is to be blamed exceeds the length of the blamed
// file.
type RawBlameError_OutOfRangeError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// actual_lines contains the actual number of lines that can be blamed in the file.
	ActualLines   uint64 `protobuf:"varint,1,opt,name=actual_lines,json=actualLines,proto3" json:"actual_lines,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RawBlameError_OutOfRangeError) ProtoMessage() {}

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

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

func (x *RawBlameError_OutOfRangeError) GetActualLines() uint64 {
	if x != nil {
		return x.ActualLines
	}
	return 0
}

// InvalidIgnoreRevsFormatError indicates that the file containing ignored
// revisions has an invalid format.
type RawBlameError_InvalidIgnoreRevsFormatError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// content is the content of the line that is invalid. May be truncated.
	Content       []byte `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RawBlameError_InvalidIgnoreRevsFormatError) Reset() {
	*x = RawBlameError_InvalidIgnoreRevsFormatError{}
	mi := &file_commit_proto_msgTypes[53]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RawBlameError_InvalidIgnoreRevsFormatError) ProtoMessage() {}

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

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

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

// ResolveIgnoreRevsError indicates that a file could not be found for the provided revision
type RawBlameError_ResolveIgnoreRevsError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// ignore_revisions_blob is provided revision that does not refer to a blob
	IgnoreRevisionsBlob []byte `protobuf:"bytes,1,opt,name=ignore_revisions_blob,json=ignoreRevisionsBlob,proto3" json:"ignore_revisions_blob,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*RawBlameError_ResolveIgnoreRevsError) ProtoMessage() {}

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

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

func (x *RawBlameError_ResolveIgnoreRevsError) GetIgnoreRevisionsBlob() []byte {
	if x != nil {
		return x.IgnoreRevisionsBlob
	}
	return nil
}

// CommitForTree denotes the last commit for associated path.
type ListLastCommitsForTreeResponse_CommitForTree struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit is the commit that has last modified the path.
	Commit *GitCommit `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"`
	// path_bytes is the path associated with the commit.
	PathBytes     []byte `protobuf:"bytes,4,opt,name=path_bytes,json=pathBytes,proto3" json:"path_bytes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListLastCommitsForTreeResponse_CommitForTree) ProtoMessage() {}

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

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

func (x *ListLastCommitsForTreeResponse_CommitForTree) GetCommit() *GitCommit {
	if x != nil {
		return x.Commit
	}
	return nil
}

func (x *ListLastCommitsForTreeResponse_CommitForTree) GetPathBytes() []byte {
	if x != nil {
		return x.PathBytes
	}
	return nil
}

// RevisionExistence lists a revision with information about its existence.
type CheckObjectsExistResponse_RevisionExistence struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// name refers to the revision.
	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// exists is true if the revision exists in the repository.
	Exists        bool `protobuf:"varint,2,opt,name=exists,proto3" json:"exists,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CheckObjectsExistResponse_RevisionExistence) ProtoMessage() {}

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

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

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

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

var File_commit_proto protoreflect.FileDescriptor

const file_commit_proto_rawDesc = "" +
	"\n" +
	"\fcommit.proto\x12\x06gitaly\x1a\ferrors.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\n" +
	"lint.proto\x1a\fshared.proto\"\xd5\x05\n" +
	"\x12ListCommitsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1c\n" +
	"\trevisions\x18\x02 \x03(\tR\trevisions\x12H\n" +
	"\x11pagination_params\x18\x03 \x01(\v2\x1b.gitaly.PaginationParameterR\x10paginationParams\x126\n" +
	"\x05order\x18\x04 \x01(\x0e2 .gitaly.ListCommitsRequest.OrderR\x05order\x12\x1f\n" +
	"\vmax_parents\x18\x05 \x01(\rR\n" +
	"maxParents\x12!\n" +
	"\fdisable_walk\x18\x06 \x01(\bR\vdisableWalk\x12!\n" +
	"\ffirst_parent\x18\a \x01(\bR\vfirstParent\x120\n" +
	"\x05after\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\x05after\x122\n" +
	"\x06before\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\x06before\x12\x16\n" +
	"\x06author\x18\n" +
	" \x01(\fR\x06author\x12\x18\n" +
	"\areverse\x18\v \x01(\bR\areverse\x12\x1f\n" +
	"\vignore_case\x18\f \x01(\bR\n" +
	"ignoreCase\x126\n" +
	"\x17commit_message_patterns\x18\r \x03(\fR\x15commitMessagePatterns\x12\x12\n" +
	"\x04skip\x18\x0e \x01(\rR\x04skip\x12\x14\n" +
	"\x05paths\x18\x0f \x03(\fR\x05paths\x12<\n" +
	"\x0eglobal_options\x18\x10 \x01(\v2\x15.gitaly.GlobalOptionsR\rglobalOptions\"%\n" +
	"\x05Order\x12\b\n" +
	"\x04NONE\x10\x00\x12\b\n" +
	"\x04TOPO\x10\x01\x12\b\n" +
	"\x04DATE\x10\x02\"\x89\x01\n" +
	"\x13ListCommitsResponse\x12+\n" +
	"\acommits\x18\x01 \x03(\v2\x11.gitaly.GitCommitR\acommits\x12E\n" +
	"\x11pagination_cursor\x18\x02 \x01(\v2\x18.gitaly.PaginationCursorR\x10paginationCursor\"\x9b\x01\n" +
	"\x15ListAllCommitsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12H\n" +
	"\x11pagination_params\x18\x02 \x01(\v2\x1b.gitaly.PaginationParameterR\x10paginationParams\"E\n" +
	"\x16ListAllCommitsResponse\x12+\n" +
	"\acommits\x18\x01 \x03(\v2\x11.gitaly.GitCommitR\acommits\"j\n" +
	"\x12CommitStatsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\"y\n" +
	"\x13CommitStatsResponse\x12\x10\n" +
	"\x03oid\x18\x01 \x01(\tR\x03oid\x12\x1c\n" +
	"\tadditions\x18\x02 \x01(\x05R\tadditions\x12\x1c\n" +
	"\tdeletions\x18\x03 \x01(\x05R\tdeletions\x12\x14\n" +
	"\x05files\x18\x04 \x01(\x05R\x05files\"\x8f\x01\n" +
	"\x17CommitIsAncestorRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1f\n" +
	"\vancestor_id\x18\x02 \x01(\tR\n" +
	"ancestorId\x12\x19\n" +
	"\bchild_id\x18\x03 \x01(\tR\achildId\"0\n" +
	"\x18CommitIsAncestorResponse\x12\x14\n" +
	"\x05value\x18\x01 \x01(\bR\x05value\"\xad\x01\n" +
	"\x10TreeEntryRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\x12\x12\n" +
	"\x04path\x18\x03 \x01(\fR\x04path\x12\x14\n" +
	"\x05limit\x18\x04 \x01(\x03R\x05limit\x12\x19\n" +
	"\bmax_size\x18\x05 \x01(\x03R\amaxSize\"\xd2\x01\n" +
	"\x11TreeEntryResponse\x128\n" +
	"\x04type\x18\x01 \x01(\x0e2$.gitaly.TreeEntryResponse.ObjectTypeR\x04type\x12\x10\n" +
	"\x03oid\x18\x02 \x01(\tR\x03oid\x12\x12\n" +
	"\x04size\x18\x03 \x01(\x03R\x04size\x12\x12\n" +
	"\x04mode\x18\x04 \x01(\x05R\x04mode\x12\x12\n" +
	"\x04data\x18\x05 \x01(\fR\x04data\"5\n" +
	"\n" +
	"ObjectType\x12\n" +
	"\n" +
	"\x06COMMIT\x10\x00\x12\b\n" +
	"\x04BLOB\x10\x01\x12\b\n" +
	"\x04TREE\x10\x02\x12\a\n" +
	"\x03TAG\x10\x03\"\x9b\x03\n" +
	"\x13CountCommitsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1e\n" +
	"\brevision\x18\x02 \x01(\fB\x02\x18\x01R\brevision\x120\n" +
	"\x05after\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\x05after\x122\n" +
	"\x06before\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\x06before\x12\x12\n" +
	"\x04path\x18\x05 \x01(\fR\x04path\x12\x1b\n" +
	"\tmax_count\x18\x06 \x01(\x05R\bmaxCount\x12\x14\n" +
	"\x03all\x18\a \x01(\bB\x02\x18\x01R\x03all\x12!\n" +
	"\ffirst_parent\x18\b \x01(\bR\vfirstParent\x12<\n" +
	"\x0eglobal_options\x18\t \x01(\v2\x15.gitaly.GlobalOptionsR\rglobalOptions\x12\x1c\n" +
	"\trevisions\x18\n" +
	" \x03(\fR\trevisions\",\n" +
	"\x14CountCommitsResponse\x12\x14\n" +
	"\x05count\x18\x01 \x01(\x05R\x05count\"\xab\x01\n" +
	"\x1cCountDivergingCommitsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x12\n" +
	"\x04from\x18\x02 \x01(\fR\x04from\x12\x0e\n" +
	"\x02to\x18\x03 \x01(\fR\x02to\x12\x1b\n" +
	"\tmax_count\x18\a \x01(\x05R\bmaxCountJ\x04\b\x04\x10\x05J\x04\b\x05\x10\x06J\x04\b\x06\x10\a\"_\n" +
	"\x1dCountDivergingCommitsResponse\x12\x1d\n" +
	"\n" +
	"left_count\x18\x01 \x01(\x05R\tleftCount\x12\x1f\n" +
	"\vright_count\x18\x02 \x01(\x05R\n" +
	"rightCount\"\xef\x01\n" +
	"\tTreeEntry\x12\x10\n" +
	"\x03oid\x18\x01 \x01(\tR\x03oid\x12\x12\n" +
	"\x04path\x18\x03 \x01(\fR\x04path\x12/\n" +
	"\x04type\x18\x04 \x01(\x0e2\x1b.gitaly.TreeEntry.EntryTypeR\x04type\x12\x12\n" +
	"\x04mode\x18\x05 \x01(\x05R\x04mode\x12\x1d\n" +
	"\n" +
	"commit_oid\x18\x06 \x01(\tR\tcommitOid\x12\x1b\n" +
	"\tflat_path\x18\a \x01(\fR\bflatPath\"+\n" +
	"\tEntryType\x12\b\n" +
	"\x04BLOB\x10\x00\x12\b\n" +
	"\x04TREE\x10\x01\x12\n" +
	"\n" +
	"\x06COMMIT\x10\x03J\x04\b\x02\x10\x03R\broot_oid\"\x83\x03\n" +
	"\x15GetTreeEntriesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\x12\x12\n" +
	"\x04path\x18\x03 \x01(\fR\x04path\x12\x1c\n" +
	"\trecursive\x18\x04 \x01(\bR\trecursive\x128\n" +
	"\x04sort\x18\x05 \x01(\x0e2$.gitaly.GetTreeEntriesRequest.SortByR\x04sort\x12H\n" +
	"\x11pagination_params\x18\x06 \x01(\v2\x1b.gitaly.PaginationParameterR\x10paginationParams\x12&\n" +
	"\x0fskip_flat_paths\x18\a \x01(\bR\rskipFlatPaths\"6\n" +
	"\x06SortBy\x12\v\n" +
	"\aDEFAULT\x10\x00\x12\x0f\n" +
	"\vTREES_FIRST\x10\x01\x12\x0e\n" +
	"\n" +
	"FILESYSTEM\x10\x02\"\x8c\x01\n" +
	"\x16GetTreeEntriesResponse\x12+\n" +
	"\aentries\x18\x01 \x03(\v2\x11.gitaly.TreeEntryR\aentries\x12E\n" +
	"\x11pagination_cursor\x18\x02 \x01(\v2\x18.gitaly.PaginationCursorR\x10paginationCursor\"\x8a\x01\n" +
	"\x13GetTreeEntriesError\x12A\n" +
	"\fresolve_tree\x18\x01 \x01(\v2\x1c.gitaly.ResolveRevisionErrorH\x00R\vresolveTree\x12'\n" +
	"\x04path\x18\x02 \x01(\v2\x11.gitaly.PathErrorH\x00R\x04pathB\a\n" +
	"\x05error\"h\n" +
	"\x10ListFilesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\")\n" +
	"\x11ListFilesResponse\x12\x14\n" +
	"\x05paths\x18\x01 \x03(\fR\x05paths\"\x85\x01\n" +
	"\x11FindCommitRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\x12\x1a\n" +
	"\btrailers\x18\x03 \x01(\bR\btrailers\"?\n" +
	"\x12FindCommitResponse\x12)\n" +
	"\x06commit\x18\x01 \x01(\v2\x11.gitaly.GitCommitR\x06commit\"e\n" +
	"\x17ListCommitsByOidRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x10\n" +
	"\x03oid\x18\x02 \x03(\tR\x03oid\"G\n" +
	"\x18ListCommitsByOidResponse\x12+\n" +
	"\acommits\x18\x01 \x03(\v2\x11.gitaly.GitCommitR\acommits\"t\n" +
	"\x1bListCommitsByRefNameRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1b\n" +
	"\tref_names\x18\x02 \x03(\fR\brefNames\"\xce\x01\n" +
	"\x1cListCommitsByRefNameResponse\x12R\n" +
	"\vcommit_refs\x18\x02 \x03(\v21.gitaly.ListCommitsByRefNameResponse.CommitForRefR\n" +
	"commitRefs\x1aT\n" +
	"\fCommitForRef\x12)\n" +
	"\x06commit\x18\x01 \x01(\v2\x11.gitaly.GitCommitR\x06commit\x12\x19\n" +
	"\bref_name\x18\x02 \x01(\fR\arefNameJ\x04\b\x01\x10\x02\"\x80\x02\n" +
	"\x15FindAllCommitsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\x12\x1b\n" +
	"\tmax_count\x18\x03 \x01(\x05R\bmaxCount\x12\x12\n" +
	"\x04skip\x18\x04 \x01(\x05R\x04skip\x129\n" +
	"\x05order\x18\x05 \x01(\x0e2#.gitaly.FindAllCommitsRequest.OrderR\x05order\"%\n" +
	"\x05Order\x12\b\n" +
	"\x04NONE\x10\x00\x12\b\n" +
	"\x04TOPO\x10\x01\x12\b\n" +
	"\x04DATE\x10\x02\"E\n" +
	"\x16FindAllCommitsResponse\x12+\n" +
	"\acommits\x18\x01 \x03(\v2\x11.gitaly.GitCommitR\acommits\"\xf6\x05\n" +
	"\x12FindCommitsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\x12\x14\n" +
	"\x05limit\x18\x03 \x01(\x05R\x05limit\x12\x16\n" +
	"\x06offset\x18\x04 \x01(\x05R\x06offset\x12\x14\n" +
	"\x05paths\x18\x05 \x03(\fR\x05paths\x12\x16\n" +
	"\x06follow\x18\x06 \x01(\bR\x06follow\x12\x1f\n" +
	"\vskip_merges\x18\a \x01(\bR\n" +
	"skipMerges\x12%\n" +
	"\fdisable_walk\x18\b \x01(\bB\x02\x18\x01R\vdisableWalk\x120\n" +
	"\x05after\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\x05after\x122\n" +
	"\x06before\x18\n" +
	" \x01(\v2\x1a.google.protobuf.TimestampR\x06before\x12\x10\n" +
	"\x03all\x18\v \x01(\bR\x03all\x12!\n" +
	"\ffirst_parent\x18\f \x01(\bR\vfirstParent\x12\x16\n" +
	"\x06author\x18\r \x01(\fR\x06author\x126\n" +
	"\x05order\x18\x0e \x01(\x0e2 .gitaly.FindCommitsRequest.OrderR\x05order\x12<\n" +
	"\x0eglobal_options\x18\x0f \x01(\v2\x15.gitaly.GlobalOptionsR\rglobalOptions\x12\x1a\n" +
	"\btrailers\x18\x10 \x01(\bR\btrailers\x12+\n" +
	"\x11include_shortstat\x18\x11 \x01(\bR\x10includeShortstat\x122\n" +
	"\x15include_referenced_by\x18\x12 \x03(\fR\x13includeReferencedBy\x12#\n" +
	"\rmessage_regex\x18\x13 \x01(\tR\fmessageRegex\"\x1b\n" +
	"\x05Order\x12\b\n" +
	"\x04NONE\x10\x00\x12\b\n" +
	"\x04TOPO\x10\x01\"B\n" +
	"\x13FindCommitsResponse\x12+\n" +
	"\acommits\x18\x01 \x03(\v2\x11.gitaly.GitCommitR\acommits\"\xe1\x01\n" +
	"\x10FindCommitsError\x127\n" +
	"\n" +
	"bad_object\x18\x01 \x01(\v2\x16.gitaly.BadObjectErrorH\x00R\tbadObject\x12F\n" +
	"\rambiguous_ref\x18\x02 \x01(\v2\x1f.gitaly.AmbiguousReferenceErrorH\x00R\fambiguousRef\x12C\n" +
	"\rinvalid_range\x18\x03 \x01(\v2\x1c.gitaly.InvalidRevisionRangeH\x00R\finvalidRangeB\a\n" +
	"\x05error\"n\n" +
	"\x16CommitLanguagesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\"\xf7\x01\n" +
	"\x17CommitLanguagesResponse\x12F\n" +
	"\tlanguages\x18\x01 \x03(\v2(.gitaly.CommitLanguagesResponse.LanguageR\tlanguages\x1a\x93\x01\n" +
	"\bLanguage\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" +
	"\x05share\x18\x02 \x01(\x02R\x05share\x12\x14\n" +
	"\x05color\x18\x03 \x01(\tR\x05color\x12\x14\n" +
	"\x05bytes\x18\x05 \x01(\x04R\x05bytes\x12\x1f\n" +
	"\vlanguage_id\x18\x06 \x01(\x03R\n" +
	"languageIdJ\x04\b\x04\x10\x05R\n" +
	"file_count\"\xc5\x01\n" +
	"\x0fRawBlameRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\x12\x12\n" +
	"\x04path\x18\x03 \x01(\fR\x04path\x12\x14\n" +
	"\x05range\x18\x04 \x01(\fR\x05range\x122\n" +
	"\x15ignore_revisions_blob\x18\x05 \x01(\fR\x13ignoreRevisionsBlob\"&\n" +
	"\x10RawBlameResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"\xb7\x04\n" +
	"\rRawBlameError\x12A\n" +
	"\x0epath_not_found\x18\x01 \x01(\v2\x19.gitaly.PathNotFoundErrorH\x00R\fpathNotFound\x12I\n" +
	"\fout_of_range\x18\x02 \x01(\v2%.gitaly.RawBlameError.OutOfRangeErrorH\x00R\n" +
	"outOfRange\x12^\n" +
	"\x13resolve_ignore_revs\x18\x03 \x01(\v2,.gitaly.RawBlameError.ResolveIgnoreRevsErrorH\x00R\x11resolveIgnoreRevs\x12q\n" +
	"\x1ainvalid_ignore_revs_format\x18\x04 \x01(\v22.gitaly.RawBlameError.InvalidIgnoreRevsFormatErrorH\x00R\x17invalidIgnoreRevsFormat\x1a4\n" +
	"\x0fOutOfRangeError\x12!\n" +
	"\factual_lines\x18\x01 \x01(\x04R\vactualLines\x1a8\n" +
	"\x1cInvalidIgnoreRevsFormatError\x12\x18\n" +
	"\acontent\x18\x01 \x01(\fR\acontent\x1aL\n" +
	"\x16ResolveIgnoreRevsError\x122\n" +
	"\x15ignore_revisions_blob\x18\x01 \x01(\fR\x13ignoreRevisionsBlobB\a\n" +
	"\x05error\"\xed\x01\n" +
	"\x18LastCommitForPathRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\x12\x12\n" +
	"\x04path\x18\x03 \x01(\fR\x04path\x12)\n" +
	"\x10literal_pathspec\x18\x04 \x01(\bR\x0fliteralPathspec\x12<\n" +
	"\x0eglobal_options\x18\x05 \x01(\v2\x15.gitaly.GlobalOptionsR\rglobalOptions\"F\n" +
	"\x19LastCommitForPathResponse\x12)\n" +
	"\x06commit\x18\x01 \x01(\v2\x11.gitaly.GitCommitR\x06commit\"\xa4\x02\n" +
	"\x1dListLastCommitsForTreeRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\tR\brevision\x12\x12\n" +
	"\x04path\x18\x03 \x01(\fR\x04path\x12\x14\n" +
	"\x05limit\x18\x04 \x01(\x05R\x05limit\x12\x16\n" +
	"\x06offset\x18\x05 \x01(\x05R\x06offset\x12-\n" +
	"\x10literal_pathspec\x18\x06 \x01(\bB\x02\x18\x01R\x0fliteralPathspec\x12<\n" +
	"\x0eglobal_options\x18\a \x01(\v2\x15.gitaly.GlobalOptionsR\rglobalOptions\"\xd7\x01\n" +
	"\x1eListLastCommitsForTreeResponse\x12N\n" +
	"\acommits\x18\x01 \x03(\v24.gitaly.ListLastCommitsForTreeResponse.CommitForTreeR\acommits\x1ae\n" +
	"\rCommitForTree\x12)\n" +
	"\x06commit\x18\x02 \x01(\v2\x11.gitaly.GitCommitR\x06commit\x12\x1d\n" +
	"\n" +
	"path_bytes\x18\x04 \x01(\fR\tpathBytesJ\x04\b\x01\x10\x02J\x04\b\x03\x10\x04\"\x85\x02\n" +
	"\x17CommitsByMessageRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\fR\brevision\x12\x16\n" +
	"\x06offset\x18\x03 \x01(\x05R\x06offset\x12\x14\n" +
	"\x05limit\x18\x04 \x01(\x05R\x05limit\x12\x12\n" +
	"\x04path\x18\x05 \x01(\fR\x04path\x12\x14\n" +
	"\x05query\x18\x06 \x01(\tR\x05query\x12<\n" +
	"\x0eglobal_options\x18\a \x01(\v2\x15.gitaly.GlobalOptionsR\rglobalOptions\"G\n" +
	"\x18CommitsByMessageResponse\x12+\n" +
	"\acommits\x18\x01 \x03(\v2\x11.gitaly.GitCommitR\acommits\"o\n" +
	"\x1fFilterShasWithSignaturesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x12\n" +
	"\x04shas\x18\x02 \x03(\fR\x04shas\"6\n" +
	" FilterShasWithSignaturesResponse\x12\x12\n" +
	"\x04shas\x18\x01 \x03(\fR\x04shas\"u\n" +
	"\x1aGetCommitSignaturesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1d\n" +
	"\n" +
	"commit_ids\x18\x02 \x03(\tR\tcommitIds\"\xe5\x02\n" +
	"\x1bGetCommitSignaturesResponse\x12\x1b\n" +
	"\tcommit_id\x18\x01 \x01(\tR\bcommitId\x12\x1c\n" +
	"\tsignature\x18\x02 \x01(\fR\tsignature\x12\x1f\n" +
	"\vsigned_text\x18\x03 \x01(\fR\n" +
	"signedText\x12B\n" +
	"\x06signer\x18\x04 \x01(\x0e2*.gitaly.GetCommitSignaturesResponse.SignerR\x06signer\x12,\n" +
	"\x06author\x18\x05 \x01(\v2\x14.gitaly.CommitAuthorR\x06author\x122\n" +
	"\tcommitter\x18\x06 \x01(\v2\x14.gitaly.CommitAuthorR\tcommitter\"D\n" +
	"\x06Signer\x12\x16\n" +
	"\x12SIGNER_UNSPECIFIED\x10\x00\x12\x0f\n" +
	"\vSIGNER_USER\x10\x01\x12\x11\n" +
	"\rSIGNER_SYSTEM\x10\x02\"s\n" +
	"\x18GetCommitMessagesRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1d\n" +
	"\n" +
	"commit_ids\x18\x02 \x03(\tR\tcommitIds\"R\n" +
	"\x19GetCommitMessagesResponse\x12\x1b\n" +
	"\tcommit_id\x18\x01 \x01(\tR\bcommitId\x12\x18\n" +
	"\amessage\x18\x02 \x01(\fR\amessage\"r\n" +
	"\x18CheckObjectsExistRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1c\n" +
	"\trevisions\x18\x02 \x03(\fR\trevisions\"\xaf\x01\n" +
	"\x19CheckObjectsExistResponse\x12Q\n" +
	"\trevisions\x18\x01 \x03(\v23.gitaly.CheckObjectsExistResponse.RevisionExistenceR\trevisions\x1a?\n" +
	"\x11RevisionExistence\x12\x12\n" +
	"\x04name\x18\x01 \x01(\fR\x04name\x12\x16\n" +
	"\x06exists\x18\x02 \x01(\bR\x06exists2\xf1\x10\n" +
	"\rCommitService\x12P\n" +
	"\vListCommits\x12\x1a.gitaly.ListCommitsRequest\x1a\x1b.gitaly.ListCommitsResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12Y\n" +
	"\x0eListAllCommits\x12\x1d.gitaly.ListAllCommitsRequest\x1a\x1e.gitaly.ListAllCommitsResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12]\n" +
	"\x10CommitIsAncestor\x12\x1f.gitaly.CommitIsAncestorRequest\x1a .gitaly.CommitIsAncestorResponse\"\x06\xfa\x97(\x02\b\x02\x12J\n" +
	"\tTreeEntry\x12\x18.gitaly.TreeEntryRequest\x1a\x19.gitaly.TreeEntryResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12Q\n" +
	"\fCountCommits\x12\x1b.gitaly.CountCommitsRequest\x1a\x1c.gitaly.CountCommitsResponse\"\x06\xfa\x97(\x02\b\x02\x12l\n" +
	"\x15CountDivergingCommits\x12$.gitaly.CountDivergingCommitsRequest\x1a%.gitaly.CountDivergingCommitsResponse\"\x06\xfa\x97(\x02\b\x02\x12Y\n" +
	"\x0eGetTreeEntries\x12\x1d.gitaly.GetTreeEntriesRequest\x1a\x1e.gitaly.GetTreeEntriesResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12J\n" +
	"\tListFiles\x12\x18.gitaly.ListFilesRequest\x1a\x19.gitaly.ListFilesResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12K\n" +
	"\n" +
	"FindCommit\x12\x19.gitaly.FindCommitRequest\x1a\x1a.gitaly.FindCommitResponse\"\x06\xfa\x97(\x02\b\x02\x12N\n" +
	"\vCommitStats\x12\x1a.gitaly.CommitStatsRequest\x1a\x1b.gitaly.CommitStatsResponse\"\x06\xfa\x97(\x02\b\x02\x12Y\n" +
	"\x0eFindAllCommits\x12\x1d.gitaly.FindAllCommitsRequest\x1a\x1e.gitaly.FindAllCommitsResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12P\n" +
	"\vFindCommits\x12\x1a.gitaly.FindCommitsRequest\x1a\x1b.gitaly.FindCommitsResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12Z\n" +
	"\x0fCommitLanguages\x12\x1e.gitaly.CommitLanguagesRequest\x1a\x1f.gitaly.CommitLanguagesResponse\"\x06\xfa\x97(\x02\b\x01\x12G\n" +
	"\bRawBlame\x12\x17.gitaly.RawBlameRequest\x1a\x18.gitaly.RawBlameResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12`\n" +
	"\x11LastCommitForPath\x12 .gitaly.LastCommitForPathRequest\x1a!.gitaly.LastCommitForPathResponse\"\x06\xfa\x97(\x02\b\x02\x12q\n" +
	"\x16ListLastCommitsForTree\x12%.gitaly.ListLastCommitsForTreeRequest\x1a&.gitaly.ListLastCommitsForTreeResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12_\n" +
	"\x10CommitsByMessage\x12\x1f.gitaly.CommitsByMessageRequest\x1a .gitaly.CommitsByMessageResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12_\n" +
	"\x10ListCommitsByOid\x12\x1f.gitaly.ListCommitsByOidRequest\x1a .gitaly.ListCommitsByOidResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12k\n" +
	"\x14ListCommitsByRefName\x12#.gitaly.ListCommitsByRefNameRequest\x1a$.gitaly.ListCommitsByRefNameResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12y\n" +
	"\x18FilterShasWithSignatures\x12'.gitaly.FilterShasWithSignaturesRequest\x1a(.gitaly.FilterShasWithSignaturesResponse\"\x06\xfa\x97(\x02\b\x02(\x010\x01\x12h\n" +
	"\x13GetCommitSignatures\x12\".gitaly.GetCommitSignaturesRequest\x1a#.gitaly.GetCommitSignaturesResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12b\n" +
	"\x11GetCommitMessages\x12 .gitaly.GetCommitMessagesRequest\x1a!.gitaly.GetCommitMessagesResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12d\n" +
	"\x11CheckObjectsExist\x12 .gitaly.CheckObjectsExistRequest\x1a!.gitaly.CheckObjectsExistResponse\"\x06\xfa\x97(\x02\b\x02(\x010\x01B4Z2gitlab.com/gitlab-org/gitaly/v18/proto/go/gitalypbb\x06proto3"

var (
	file_commit_proto_rawDescOnce sync.Once
	file_commit_proto_rawDescData []byte
)

func file_commit_proto_rawDescGZIP() []byte {
	file_commit_proto_rawDescOnce.Do(func() {
		file_commit_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_commit_proto_rawDesc), len(file_commit_proto_rawDesc)))
	})
	return file_commit_proto_rawDescData
}

var file_commit_proto_enumTypes = make([]protoimpl.EnumInfo, 7)
var file_commit_proto_msgTypes = make([]protoimpl.MessageInfo, 57)
var file_commit_proto_goTypes = []any{
	(ListCommitsRequest_Order)(0),                        // 0: gitaly.ListCommitsRequest.Order
	(TreeEntryResponse_ObjectType)(0),                    // 1: gitaly.TreeEntryResponse.ObjectType
	(TreeEntry_EntryType)(0),                             // 2: gitaly.TreeEntry.EntryType
	(GetTreeEntriesRequest_SortBy)(0),                    // 3: gitaly.GetTreeEntriesRequest.SortBy
	(FindAllCommitsRequest_Order)(0),                     // 4: gitaly.FindAllCommitsRequest.Order
	(FindCommitsRequest_Order)(0),                        // 5: gitaly.FindCommitsRequest.Order
	(GetCommitSignaturesResponse_Signer)(0),              // 6: gitaly.GetCommitSignaturesResponse.Signer
	(*ListCommitsRequest)(nil),                           // 7: gitaly.ListCommitsRequest
	(*ListCommitsResponse)(nil),                          // 8: gitaly.ListCommitsResponse
	(*ListAllCommitsRequest)(nil),                        // 9: gitaly.ListAllCommitsRequest
	(*ListAllCommitsResponse)(nil),                       // 10: gitaly.ListAllCommitsResponse
	(*CommitStatsRequest)(nil),                           // 11: gitaly.CommitStatsRequest
	(*CommitStatsResponse)(nil),                          // 12: gitaly.CommitStatsResponse
	(*CommitIsAncestorRequest)(nil),                      // 13: gitaly.CommitIsAncestorRequest
	(*CommitIsAncestorResponse)(nil),                     // 14: gitaly.CommitIsAncestorResponse
	(*TreeEntryRequest)(nil),                             // 15: gitaly.TreeEntryRequest
	(*TreeEntryResponse)(nil),                            // 16: gitaly.TreeEntryResponse
	(*CountCommitsRequest)(nil),                          // 17: gitaly.CountCommitsRequest
	(*CountCommitsResponse)(nil),                         // 18: gitaly.CountCommitsResponse
	(*CountDivergingCommitsRequest)(nil),                 // 19: gitaly.CountDivergingCommitsRequest
	(*CountDivergingCommitsResponse)(nil),                // 20: gitaly.CountDivergingCommitsResponse
	(*TreeEntry)(nil),                                    // 21: gitaly.TreeEntry
	(*GetTreeEntriesRequest)(nil),                        // 22: gitaly.GetTreeEntriesRequest
	(*GetTreeEntriesResponse)(nil),                       // 23: gitaly.GetTreeEntriesResponse
	(*GetTreeEntriesError)(nil),                          // 24: gitaly.GetTreeEntriesError
	(*ListFilesRequest)(nil),                             // 25: gitaly.ListFilesRequest
	(*ListFilesResponse)(nil),                            // 26: gitaly.ListFilesResponse
	(*FindCommitRequest)(nil),                            // 27: gitaly.FindCommitRequest
	(*FindCommitResponse)(nil),                           // 28: gitaly.FindCommitResponse
	(*ListCommitsByOidRequest)(nil),                      // 29: gitaly.ListCommitsByOidRequest
	(*ListCommitsByOidResponse)(nil),                     // 30: gitaly.ListCommitsByOidResponse
	(*ListCommitsByRefNameRequest)(nil),                  // 31: gitaly.ListCommitsByRefNameRequest
	(*ListCommitsByRefNameResponse)(nil),                 // 32: gitaly.ListCommitsByRefNameResponse
	(*FindAllCommitsRequest)(nil),                        // 33: gitaly.FindAllCommitsRequest
	(*FindAllCommitsResponse)(nil),                       // 34: gitaly.FindAllCommitsResponse
	(*FindCommitsRequest)(nil),                           // 35: gitaly.FindCommitsRequest
	(*FindCommitsResponse)(nil),                          // 36: gitaly.FindCommitsResponse
	(*FindCommitsError)(nil),                             // 37: gitaly.FindCommitsError
	(*CommitLanguagesRequest)(nil),                       // 38: gitaly.CommitLanguagesRequest
	(*CommitLanguagesResponse)(nil),                      // 39: gitaly.CommitLanguagesResponse
	(*RawBlameRequest)(nil),                              // 40: gitaly.RawBlameRequest
	(*RawBlameResponse)(nil),                             // 41: gitaly.RawBlameResponse
	(*RawBlameError)(nil),                                // 42: gitaly.RawBlameError
	(*LastCommitForPathRequest)(nil),                     // 43: gitaly.LastCommitForPathRequest
	(*LastCommitForPathResponse)(nil),                    // 44: gitaly.LastCommitForPathResponse
	(*ListLastCommitsForTreeRequest)(nil),                // 45: gitaly.ListLastCommitsForTreeRequest
	(*ListLastCommitsForTreeResponse)(nil),               // 46: gitaly.ListLastCommitsForTreeResponse
	(*CommitsByMessageRequest)(nil),                      // 47: gitaly.CommitsByMessageRequest
	(*CommitsByMessageResponse)(nil),                     // 48: gitaly.CommitsByMessageResponse
	(*FilterShasWithSignaturesRequest)(nil),              // 49: gitaly.FilterShasWithSignaturesRequest
	(*FilterShasWithSignaturesResponse)(nil),             // 50: gitaly.FilterShasWithSignaturesResponse
	(*GetCommitSignaturesRequest)(nil),                   // 51: gitaly.GetCommitSignaturesRequest
	(*GetCommitSignaturesResponse)(nil),                  // 52: gitaly.GetCommitSignaturesResponse
	(*GetCommitMessagesRequest)(nil),                     // 53: gitaly.GetCommitMessagesRequest
	(*GetCommitMessagesResponse)(nil),                    // 54: gitaly.GetCommitMessagesResponse
	(*CheckObjectsExistRequest)(nil),                     // 55: gitaly.CheckObjectsExistRequest
	(*CheckObjectsExistResponse)(nil),                    // 56: gitaly.CheckObjectsExistResponse
	(*ListCommitsByRefNameResponse_CommitForRef)(nil),    // 57: gitaly.ListCommitsByRefNameResponse.CommitForRef
	(*CommitLanguagesResponse_Language)(nil),             // 58: gitaly.CommitLanguagesResponse.Language
	(*RawBlameError_OutOfRangeError)(nil),                // 59: gitaly.RawBlameError.OutOfRangeError
	(*RawBlameError_InvalidIgnoreRevsFormatError)(nil),   // 60: gitaly.RawBlameError.InvalidIgnoreRevsFormatError
	(*RawBlameError_ResolveIgnoreRevsError)(nil),         // 61: gitaly.RawBlameError.ResolveIgnoreRevsError
	(*ListLastCommitsForTreeResponse_CommitForTree)(nil), // 62: gitaly.ListLastCommitsForTreeResponse.CommitForTree
	(*CheckObjectsExistResponse_RevisionExistence)(nil),  // 63: gitaly.CheckObjectsExistResponse.RevisionExistence
	(*Repository)(nil),                                   // 64: gitaly.Repository
	(*PaginationParameter)(nil),                          // 65: gitaly.PaginationParameter
	(*timestamppb.Timestamp)(nil),                        // 66: google.protobuf.Timestamp
	(*GlobalOptions)(nil),                                // 67: gitaly.GlobalOptions
	(*GitCommit)(nil),                                    // 68: gitaly.GitCommit
	(*PaginationCursor)(nil),                             // 69: gitaly.PaginationCursor
	(*ResolveRevisionError)(nil),                         // 70: gitaly.ResolveRevisionError
	(*PathError)(nil),                                    // 71: gitaly.PathError
	(*BadObjectError)(nil),                               // 72: gitaly.BadObjectError
	(*AmbiguousReferenceError)(nil),                      // 73: gitaly.AmbiguousReferenceError
	(*InvalidRevisionRange)(nil),                         // 74: gitaly.InvalidRevisionRange
	(*PathNotFoundError)(nil),                            // 75: gitaly.PathNotFoundError
	(*CommitAuthor)(nil),                                 // 76: gitaly.CommitAuthor
}
var file_commit_proto_depIdxs = []int32{
	64, // 0: gitaly.ListCommitsRequest.repository:type_name -> gitaly.Repository
	65, // 1: gitaly.ListCommitsRequest.pagination_params:type_name -> gitaly.PaginationParameter
	0,  // 2: gitaly.ListCommitsRequest.order:type_name -> gitaly.ListCommitsRequest.Order
	66, // 3: gitaly.ListCommitsRequest.after:type_name -> google.protobuf.Timestamp
	66, // 4: gitaly.ListCommitsRequest.before:type_name -> google.protobuf.Timestamp
	67, // 5: gitaly.ListCommitsRequest.global_options:type_name -> gitaly.GlobalOptions
	68, // 6: gitaly.ListCommitsResponse.commits:type_name -> gitaly.GitCommit
	69, // 7: gitaly.ListCommitsResponse.pagination_cursor:type_name -> gitaly.PaginationCursor
	64, // 8: gitaly.ListAllCommitsRequest.repository:type_name -> gitaly.Repository
	65, // 9: gitaly.ListAllCommitsRequest.pagination_params:type_name -> gitaly.PaginationParameter
	68, // 10: gitaly.ListAllCommitsResponse.commits:type_name -> gitaly.GitCommit
	64, // 11: gitaly.CommitStatsRequest.repository:type_name -> gitaly.Repository
	64, // 12: gitaly.CommitIsAncestorRequest.repository:type_name -> gitaly.Repository
	64, // 13: gitaly.TreeEntryRequest.repository:type_name -> gitaly.Repository
	1,  // 14: gitaly.TreeEntryResponse.type:type_name -> gitaly.TreeEntryResponse.ObjectType
	64, // 15: gitaly.CountCommitsRequest.repository:type_name -> gitaly.Repository
	66, // 16: gitaly.CountCommitsRequest.after:type_name -> google.protobuf.Timestamp
	66, // 17: gitaly.CountCommitsRequest.before:type_name -> google.protobuf.Timestamp
	67, // 18: gitaly.CountCommitsRequest.global_options:type_name -> gitaly.GlobalOptions
	64, // 19: gitaly.CountDivergingCommitsRequest.repository:type_name -> gitaly.Repository
	2,  // 20: gitaly.TreeEntry.type:type_name -> gitaly.TreeEntry.EntryType
	64, // 21: gitaly.GetTreeEntriesRequest.repository:type_name -> gitaly.Repository
	3,  // 22: gitaly.GetTreeEntriesRequest.sort:type_name -> gitaly.GetTreeEntriesRequest.SortBy
	65, // 23: gitaly.GetTreeEntriesRequest.pagination_params:type_name -> gitaly.PaginationParameter
	21, // 24: gitaly.GetTreeEntriesResponse.entries:type_name -> gitaly.TreeEntry
	69, // 25: gitaly.GetTreeEntriesResponse.pagination_cursor:type_name -> gitaly.PaginationCursor
	70, // 26: gitaly.GetTreeEntriesError.resolve_tree:type_name -> gitaly.ResolveRevisionError
	71, // 27: gitaly.GetTreeEntriesError.path:type_name -> gitaly.PathError
	64, // 28: gitaly.ListFilesRequest.repository:type_name -> gitaly.Repository
	64, // 29: gitaly.FindCommitRequest.repository:type_name -> gitaly.Repository
	68, // 30: gitaly.FindCommitResponse.commit:type_name -> gitaly.GitCommit
	64, // 31: gitaly.ListCommitsByOidRequest.repository:type_name -> gitaly.Repository
	68, // 32: gitaly.ListCommitsByOidResponse.commits:type_name -> gitaly.GitCommit
	64, // 33: gitaly.ListCommitsByRefNameRequest.repository:type_name -> gitaly.Repository
	57, // 34: gitaly.ListCommitsByRefNameResponse.commit_refs:type_name -> gitaly.ListCommitsByRefNameResponse.CommitForRef
	64, // 35: gitaly.FindAllCommitsRequest.repository:type_name -> gitaly.Repository
	4,  // 36: gitaly.FindAllCommitsRequest.order:type_name -> gitaly.FindAllCommitsRequest.Order
	68, // 37: gitaly.FindAllCommitsResponse.commits:type_name -> gitaly.GitCommit
	64, // 38: gitaly.FindCommitsRequest.repository:type_name -> gitaly.Repository
	66, // 39: gitaly.FindCommitsRequest.after:type_name -> google.protobuf.Timestamp
	66, // 40: gitaly.FindCommitsRequest.before:type_name -> google.protobuf.Timestamp
	5,  // 41: gitaly.FindCommitsRequest.order:type_name -> gitaly.FindCommitsRequest.Order
	67, // 42: gitaly.FindCommitsRequest.global_options:type_name -> gitaly.GlobalOptions
	68, // 43: gitaly.FindCommitsResponse.commits:type_name -> gitaly.GitCommit
	72, // 44: gitaly.FindCommitsError.bad_object:type_name -> gitaly.BadObjectError
	73, // 45: gitaly.FindCommitsError.ambiguous_ref:type_name -> gitaly.AmbiguousReferenceError
	74, // 46: gitaly.FindCommitsError.invalid_range:type_name -> gitaly.InvalidRevisionRange
	64, // 47: gitaly.CommitLanguagesRequest.repository:type_name -> gitaly.Repository
	58, // 48: gitaly.CommitLanguagesResponse.languages:type_name -> gitaly.CommitLanguagesResponse.Language
	64, // 49: gitaly.RawBlameRequest.repository:type_name -> gitaly.Repository
	75, // 50: gitaly.RawBlameError.path_not_found:type_name -> gitaly.PathNotFoundError
	59, // 51: gitaly.RawBlameError.out_of_range:type_name -> gitaly.RawBlameError.OutOfRangeError
	61, // 52: gitaly.RawBlameError.resolve_ignore_revs:type_name -> gitaly.RawBlameError.ResolveIgnoreRevsError
	60, // 53: gitaly.RawBlameError.invalid_ignore_revs_format:type_name -> gitaly.RawBlameError.InvalidIgnoreRevsFormatError
	64, // 54: gitaly.LastCommitForPathRequest.repository:type_name -> gitaly.Repository
	67, // 55: gitaly.LastCommitForPathRequest.global_options:type_name -> gitaly.GlobalOptions
	68, // 56: gitaly.LastCommitForPathResponse.commit:type_name -> gitaly.GitCommit
	64, // 57: gitaly.ListLastCommitsForTreeRequest.repository:type_name -> gitaly.Repository
	67, // 58: gitaly.ListLastCommitsForTreeRequest.global_options:type_name -> gitaly.GlobalOptions
	62, // 59: gitaly.ListLastCommitsForTreeResponse.commits:type_name -> gitaly.ListLastCommitsForTreeResponse.CommitForTree
	64, // 60: gitaly.CommitsByMessageRequest.repository:type_name -> gitaly.Repository
	67, // 61: gitaly.CommitsByMessageRequest.global_options:type_name -> gitaly.GlobalOptions
	68, // 62: gitaly.CommitsByMessageResponse.commits:type_name -> gitaly.GitCommit
	64, // 63: gitaly.FilterShasWithSignaturesRequest.repository:type_name -> gitaly.Repository
	64, // 64: gitaly.GetCommitSignaturesRequest.repository:type_name -> gitaly.Repository
	6,  // 65: gitaly.GetCommitSignaturesResponse.signer:type_name -> gitaly.GetCommitSignaturesResponse.Signer
	76, // 66: gitaly.GetCommitSignaturesResponse.author:type_name -> gitaly.CommitAuthor
	76, // 67: gitaly.GetCommitSignaturesResponse.committer:type_name -> gitaly.CommitAuthor
	64, // 68: gitaly.GetCommitMessagesRequest.repository:type_name -> gitaly.Repository
	64, // 69: gitaly.CheckObjectsExistRequest.repository:type_name -> gitaly.Repository
	63, // 70: gitaly.CheckObjectsExistResponse.revisions:type_name -> gitaly.CheckObjectsExistResponse.RevisionExistence
	68, // 71: gitaly.ListCommitsByRefNameResponse.CommitForRef.commit:type_name -> gitaly.GitCommit
	68, // 72: gitaly.ListLastCommitsForTreeResponse.CommitForTree.commit:type_name -> gitaly.GitCommit
	7,  // 73: gitaly.CommitService.ListCommits:input_type -> gitaly.ListCommitsRequest
	9,  // 74: gitaly.CommitService.ListAllCommits:input_type -> gitaly.ListAllCommitsRequest
	13, // 75: gitaly.CommitService.CommitIsAncestor:input_type -> gitaly.CommitIsAncestorRequest
	15, // 76: gitaly.CommitService.TreeEntry:input_type -> gitaly.TreeEntryRequest
	17, // 77: gitaly.CommitService.CountCommits:input_type -> gitaly.CountCommitsRequest
	19, // 78: gitaly.CommitService.CountDivergingCommits:input_type -> gitaly.CountDivergingCommitsRequest
	22, // 79: gitaly.CommitService.GetTreeEntries:input_type -> gitaly.GetTreeEntriesRequest
	25, // 80: gitaly.CommitService.ListFiles:input_type -> gitaly.ListFilesRequest
	27, // 81: gitaly.CommitService.FindCommit:input_type -> gitaly.FindCommitRequest
	11, // 82: gitaly.CommitService.CommitStats:input_type -> gitaly.CommitStatsRequest
	33, // 83: gitaly.CommitService.FindAllCommits:input_type -> gitaly.FindAllCommitsRequest
	35, // 84: gitaly.CommitService.FindCommits:input_type -> gitaly.FindCommitsRequest
	38, // 85: gitaly.CommitService.CommitLanguages:input_type -> gitaly.CommitLanguagesRequest
	40, // 86: gitaly.CommitService.RawBlame:input_type -> gitaly.RawBlameRequest
	43, // 87: gitaly.CommitService.LastCommitForPath:input_type -> gitaly.LastCommitForPathRequest
	45, // 88: gitaly.CommitService.ListLastCommitsForTree:input_type -> gitaly.ListLastCommitsForTreeRequest
	47, // 89: gitaly.CommitService.CommitsByMessage:input_type -> gitaly.CommitsByMessageRequest
	29, // 90: gitaly.CommitService.ListCommitsByOid:input_type -> gitaly.ListCommitsByOidRequest
	31, // 91: gitaly.CommitService.ListCommitsByRefName:input_type -> gitaly.ListCommitsByRefNameRequest
	49, // 92: gitaly.CommitService.FilterShasWithSignatures:input_type -> gitaly.FilterShasWithSignaturesRequest
	51, // 93: gitaly.CommitService.GetCommitSignatures:input_type -> gitaly.GetCommitSignaturesRequest
	53, // 94: gitaly.CommitService.GetCommitMessages:input_type -> gitaly.GetCommitMessagesRequest
	55, // 95: gitaly.CommitService.CheckObjectsExist:input_type -> gitaly.CheckObjectsExistRequest
	8,  // 96: gitaly.CommitService.ListCommits:output_type -> gitaly.ListCommitsResponse
	10, // 97: gitaly.CommitService.ListAllCommits:output_type -> gitaly.ListAllCommitsResponse
	14, // 98: gitaly.CommitService.CommitIsAncestor:output_type -> gitaly.CommitIsAncestorResponse
	16, // 99: gitaly.CommitService.TreeEntry:output_type -> gitaly.TreeEntryResponse
	18, // 100: gitaly.CommitService.CountCommits:output_type -> gitaly.CountCommitsResponse
	20, // 101: gitaly.CommitService.CountDivergingCommits:output_type -> gitaly.CountDivergingCommitsResponse
	23, // 102: gitaly.CommitService.GetTreeEntries:output_type -> gitaly.GetTreeEntriesResponse
	26, // 103: gitaly.CommitService.ListFiles:output_type -> gitaly.ListFilesResponse
	28, // 104: gitaly.CommitService.FindCommit:output_type -> gitaly.FindCommitResponse
	12, // 105: gitaly.CommitService.CommitStats:output_type -> gitaly.CommitStatsResponse
	34, // 106: gitaly.CommitService.FindAllCommits:output_type -> gitaly.FindAllCommitsResponse
	36, // 107: gitaly.CommitService.FindCommits:output_type -> gitaly.FindCommitsResponse
	39, // 108: gitaly.CommitService.CommitLanguages:output_type -> gitaly.CommitLanguagesResponse
	41, // 109: gitaly.CommitService.RawBlame:output_type -> gitaly.RawBlameResponse
	44, // 110: gitaly.CommitService.LastCommitForPath:output_type -> gitaly.LastCommitForPathResponse
	46, // 111: gitaly.CommitService.ListLastCommitsForTree:output_type -> gitaly.ListLastCommitsForTreeResponse
	48, // 112: gitaly.CommitService.CommitsByMessage:output_type -> gitaly.CommitsByMessageResponse
	30, // 113: gitaly.CommitService.ListCommitsByOid:output_type -> gitaly.ListCommitsByOidResponse
	32, // 114: gitaly.CommitService.ListCommitsByRefName:output_type -> gitaly.ListCommitsByRefNameResponse
	50, // 115: gitaly.CommitService.FilterShasWithSignatures:output_type -> gitaly.FilterShasWithSignaturesResponse
	52, // 116: gitaly.CommitService.GetCommitSignatures:output_type -> gitaly.GetCommitSignaturesResponse
	54, // 117: gitaly.CommitService.GetCommitMessages:output_type -> gitaly.GetCommitMessagesResponse
	56, // 118: gitaly.CommitService.CheckObjectsExist:output_type -> gitaly.CheckObjectsExistResponse
	96, // [96:119] is the sub-list for method output_type
	73, // [73:96] is the sub-list for method input_type
	73, // [73:73] is the sub-list for extension type_name
	73, // [73:73] is the sub-list for extension extendee
	0,  // [0:73] is the sub-list for field type_name
}

func init() { file_commit_proto_init() }
func file_commit_proto_init() {
	if File_commit_proto != nil {
		return
	}
	file_errors_proto_init()
	file_lint_proto_init()
	file_shared_proto_init()
	file_commit_proto_msgTypes[17].OneofWrappers = []any{
		(*GetTreeEntriesError_ResolveTree)(nil),
		(*GetTreeEntriesError_Path)(nil),
	}
	file_commit_proto_msgTypes[30].OneofWrappers = []any{
		(*FindCommitsError_BadObject)(nil),
		(*FindCommitsError_AmbiguousRef)(nil),
		(*FindCommitsError_InvalidRange)(nil),
	}
	file_commit_proto_msgTypes[35].OneofWrappers = []any{
		(*RawBlameError_PathNotFound)(nil),
		(*RawBlameError_OutOfRange)(nil),
		(*RawBlameError_ResolveIgnoreRevs)(nil),
		(*RawBlameError_InvalidIgnoreRevsFormat)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_commit_proto_rawDesc), len(file_commit_proto_rawDesc)),
			NumEnums:      7,
			NumMessages:   57,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_commit_proto_goTypes,
		DependencyIndexes: file_commit_proto_depIdxs,
		EnumInfos:         file_commit_proto_enumTypes,
		MessageInfos:      file_commit_proto_msgTypes,
	}.Build()
	File_commit_proto = out.File
	file_commit_proto_goTypes = nil
	file_commit_proto_depIdxs = nil
}
