// Code generated by protoc-gen-go. DO NOT EDIT.
// source: commit.proto

package gitalypb

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// TODO: Replace this enum with ObjectType in shared.proto
type TreeEntryResponse_ObjectType int32

const (
	TreeEntryResponse_COMMIT TreeEntryResponse_ObjectType = 0
	TreeEntryResponse_BLOB   TreeEntryResponse_ObjectType = 1
	TreeEntryResponse_TREE   TreeEntryResponse_ObjectType = 2
	TreeEntryResponse_TAG    TreeEntryResponse_ObjectType = 3
)

var TreeEntryResponse_ObjectType_name = map[int32]string{
	0: "COMMIT",
	1: "BLOB",
	2: "TREE",
	3: "TAG",
}

var TreeEntryResponse_ObjectType_value = map[string]int32{
	"COMMIT": 0,
	"BLOB":   1,
	"TREE":   2,
	"TAG":    3,
}

func (x TreeEntryResponse_ObjectType) String() string {
	return proto.EnumName(TreeEntryResponse_ObjectType_name, int32(x))
}

func (TreeEntryResponse_ObjectType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{5, 0}
}

// TODO: Replace this enum with ObjectType in shared.proto
type TreeEntry_EntryType int32

const (
	TreeEntry_BLOB   TreeEntry_EntryType = 0
	TreeEntry_TREE   TreeEntry_EntryType = 1
	TreeEntry_COMMIT TreeEntry_EntryType = 3
)

var TreeEntry_EntryType_name = map[int32]string{
	0: "BLOB",
	1: "TREE",
	3: "COMMIT",
}

var TreeEntry_EntryType_value = map[string]int32{
	"BLOB":   0,
	"TREE":   1,
	"COMMIT": 3,
}

func (x TreeEntry_EntryType) String() string {
	return proto.EnumName(TreeEntry_EntryType_name, int32(x))
}

func (TreeEntry_EntryType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{12, 0}
}

type FindAllCommitsRequest_Order int32

const (
	FindAllCommitsRequest_NONE FindAllCommitsRequest_Order = 0
	FindAllCommitsRequest_TOPO FindAllCommitsRequest_Order = 1
	FindAllCommitsRequest_DATE FindAllCommitsRequest_Order = 2
)

var FindAllCommitsRequest_Order_name = map[int32]string{
	0: "NONE",
	1: "TOPO",
	2: "DATE",
}

var FindAllCommitsRequest_Order_value = map[string]int32{
	"NONE": 0,
	"TOPO": 1,
	"DATE": 2,
}

func (x FindAllCommitsRequest_Order) String() string {
	return proto.EnumName(FindAllCommitsRequest_Order_name, int32(x))
}

func (FindAllCommitsRequest_Order) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{23, 0}
}

type CommitStatsRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision             []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CommitStatsRequest) Reset()         { *m = CommitStatsRequest{} }
func (m *CommitStatsRequest) String() string { return proto.CompactTextString(m) }
func (*CommitStatsRequest) ProtoMessage()    {}
func (*CommitStatsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{0}
}

func (m *CommitStatsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitStatsRequest.Unmarshal(m, b)
}
func (m *CommitStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitStatsRequest.Marshal(b, m, deterministic)
}
func (m *CommitStatsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitStatsRequest.Merge(m, src)
}
func (m *CommitStatsRequest) XXX_Size() int {
	return xxx_messageInfo_CommitStatsRequest.Size(m)
}
func (m *CommitStatsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitStatsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CommitStatsRequest proto.InternalMessageInfo

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

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

type CommitStatsResponse struct {
	// OID is the commit. Empty means not found
	Oid                  string   `protobuf:"bytes,1,opt,name=oid,proto3" json:"oid,omitempty"`
	Additions            int32    `protobuf:"varint,2,opt,name=additions,proto3" json:"additions,omitempty"`
	Deletions            int32    `protobuf:"varint,3,opt,name=deletions,proto3" json:"deletions,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CommitStatsResponse) Reset()         { *m = CommitStatsResponse{} }
func (m *CommitStatsResponse) String() string { return proto.CompactTextString(m) }
func (*CommitStatsResponse) ProtoMessage()    {}
func (*CommitStatsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{1}
}

func (m *CommitStatsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitStatsResponse.Unmarshal(m, b)
}
func (m *CommitStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitStatsResponse.Marshal(b, m, deterministic)
}
func (m *CommitStatsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitStatsResponse.Merge(m, src)
}
func (m *CommitStatsResponse) XXX_Size() int {
	return xxx_messageInfo_CommitStatsResponse.Size(m)
}
func (m *CommitStatsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitStatsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommitStatsResponse proto.InternalMessageInfo

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

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

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

type CommitIsAncestorRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	AncestorId           string      `protobuf:"bytes,2,opt,name=ancestor_id,json=ancestorId,proto3" json:"ancestor_id,omitempty"`
	ChildId              string      `protobuf:"bytes,3,opt,name=child_id,json=childId,proto3" json:"child_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CommitIsAncestorRequest) Reset()         { *m = CommitIsAncestorRequest{} }
func (m *CommitIsAncestorRequest) String() string { return proto.CompactTextString(m) }
func (*CommitIsAncestorRequest) ProtoMessage()    {}
func (*CommitIsAncestorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{2}
}

func (m *CommitIsAncestorRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitIsAncestorRequest.Unmarshal(m, b)
}
func (m *CommitIsAncestorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitIsAncestorRequest.Marshal(b, m, deterministic)
}
func (m *CommitIsAncestorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitIsAncestorRequest.Merge(m, src)
}
func (m *CommitIsAncestorRequest) XXX_Size() int {
	return xxx_messageInfo_CommitIsAncestorRequest.Size(m)
}
func (m *CommitIsAncestorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitIsAncestorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CommitIsAncestorRequest proto.InternalMessageInfo

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

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

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

type CommitIsAncestorResponse struct {
	Value                bool     `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CommitIsAncestorResponse) Reset()         { *m = CommitIsAncestorResponse{} }
func (m *CommitIsAncestorResponse) String() string { return proto.CompactTextString(m) }
func (*CommitIsAncestorResponse) ProtoMessage()    {}
func (*CommitIsAncestorResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{3}
}

func (m *CommitIsAncestorResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitIsAncestorResponse.Unmarshal(m, b)
}
func (m *CommitIsAncestorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitIsAncestorResponse.Marshal(b, m, deterministic)
}
func (m *CommitIsAncestorResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitIsAncestorResponse.Merge(m, src)
}
func (m *CommitIsAncestorResponse) XXX_Size() int {
	return xxx_messageInfo_CommitIsAncestorResponse.Size(m)
}
func (m *CommitIsAncestorResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitIsAncestorResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommitIsAncestorResponse proto.InternalMessageInfo

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

type TreeEntryRequest struct {
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// commit ID or refname
	Revision []byte `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	// entry path relative to repository root
	Path                 []byte   `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	Limit                int64    `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TreeEntryRequest) Reset()         { *m = TreeEntryRequest{} }
func (m *TreeEntryRequest) String() string { return proto.CompactTextString(m) }
func (*TreeEntryRequest) ProtoMessage()    {}
func (*TreeEntryRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{4}
}

func (m *TreeEntryRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TreeEntryRequest.Unmarshal(m, b)
}
func (m *TreeEntryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TreeEntryRequest.Marshal(b, m, deterministic)
}
func (m *TreeEntryRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeEntryRequest.Merge(m, src)
}
func (m *TreeEntryRequest) XXX_Size() int {
	return xxx_messageInfo_TreeEntryRequest.Size(m)
}
func (m *TreeEntryRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeEntryRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TreeEntryRequest proto.InternalMessageInfo

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

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

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

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

type TreeEntryResponse struct {
	Type TreeEntryResponse_ObjectType `protobuf:"varint,1,opt,name=type,proto3,enum=gitaly.TreeEntryResponse_ObjectType" json:"type,omitempty"`
	// SHA1 object ID
	Oid  string `protobuf:"bytes,2,opt,name=oid,proto3" json:"oid,omitempty"`
	Size int64  `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	// file mode
	Mode int32 `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"`
	// raw object contents
	Data                 []byte   `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TreeEntryResponse) Reset()         { *m = TreeEntryResponse{} }
func (m *TreeEntryResponse) String() string { return proto.CompactTextString(m) }
func (*TreeEntryResponse) ProtoMessage()    {}
func (*TreeEntryResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{5}
}

func (m *TreeEntryResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TreeEntryResponse.Unmarshal(m, b)
}
func (m *TreeEntryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TreeEntryResponse.Marshal(b, m, deterministic)
}
func (m *TreeEntryResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeEntryResponse.Merge(m, src)
}
func (m *TreeEntryResponse) XXX_Size() int {
	return xxx_messageInfo_TreeEntryResponse.Size(m)
}
func (m *TreeEntryResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeEntryResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TreeEntryResponse proto.InternalMessageInfo

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

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

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

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

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

type CommitsBetweenRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	From                 []byte      `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
	To                   []byte      `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CommitsBetweenRequest) Reset()         { *m = CommitsBetweenRequest{} }
func (m *CommitsBetweenRequest) String() string { return proto.CompactTextString(m) }
func (*CommitsBetweenRequest) ProtoMessage()    {}
func (*CommitsBetweenRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{6}
}

func (m *CommitsBetweenRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitsBetweenRequest.Unmarshal(m, b)
}
func (m *CommitsBetweenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitsBetweenRequest.Marshal(b, m, deterministic)
}
func (m *CommitsBetweenRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitsBetweenRequest.Merge(m, src)
}
func (m *CommitsBetweenRequest) XXX_Size() int {
	return xxx_messageInfo_CommitsBetweenRequest.Size(m)
}
func (m *CommitsBetweenRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitsBetweenRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CommitsBetweenRequest proto.InternalMessageInfo

func (m *CommitsBetweenRequest) GetRepository() *Repository {
	if m != nil {
		return m.Repository
	}
	return nil
}

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

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

type CommitsBetweenResponse struct {
	Commits              []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *CommitsBetweenResponse) Reset()         { *m = CommitsBetweenResponse{} }
func (m *CommitsBetweenResponse) String() string { return proto.CompactTextString(m) }
func (*CommitsBetweenResponse) ProtoMessage()    {}
func (*CommitsBetweenResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{7}
}

func (m *CommitsBetweenResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitsBetweenResponse.Unmarshal(m, b)
}
func (m *CommitsBetweenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitsBetweenResponse.Marshal(b, m, deterministic)
}
func (m *CommitsBetweenResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitsBetweenResponse.Merge(m, src)
}
func (m *CommitsBetweenResponse) XXX_Size() int {
	return xxx_messageInfo_CommitsBetweenResponse.Size(m)
}
func (m *CommitsBetweenResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitsBetweenResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommitsBetweenResponse proto.InternalMessageInfo

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

type CountCommitsRequest struct {
	Repository *Repository          `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision   []byte               `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	After      *timestamp.Timestamp `protobuf:"bytes,3,opt,name=after,proto3" json:"after,omitempty"`
	Before     *timestamp.Timestamp `protobuf:"bytes,4,opt,name=before,proto3" json:"before,omitempty"`
	Path       []byte               `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
	MaxCount   int32                `protobuf:"varint,6,opt,name=max_count,json=maxCount,proto3" json:"max_count,omitempty"`
	// all and revision are mutually exclusive
	All                  bool     `protobuf:"varint,7,opt,name=all,proto3" json:"all,omitempty"`
	FirstParent          bool     `protobuf:"varint,8,opt,name=first_parent,json=firstParent,proto3" json:"first_parent,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CountCommitsRequest) Reset()         { *m = CountCommitsRequest{} }
func (m *CountCommitsRequest) String() string { return proto.CompactTextString(m) }
func (*CountCommitsRequest) ProtoMessage()    {}
func (*CountCommitsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{8}
}

func (m *CountCommitsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CountCommitsRequest.Unmarshal(m, b)
}
func (m *CountCommitsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CountCommitsRequest.Marshal(b, m, deterministic)
}
func (m *CountCommitsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CountCommitsRequest.Merge(m, src)
}
func (m *CountCommitsRequest) XXX_Size() int {
	return xxx_messageInfo_CountCommitsRequest.Size(m)
}
func (m *CountCommitsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CountCommitsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CountCommitsRequest proto.InternalMessageInfo

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

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

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

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

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

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

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

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

type CountCommitsResponse struct {
	Count                int32    `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CountCommitsResponse) Reset()         { *m = CountCommitsResponse{} }
func (m *CountCommitsResponse) String() string { return proto.CompactTextString(m) }
func (*CountCommitsResponse) ProtoMessage()    {}
func (*CountCommitsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{9}
}

func (m *CountCommitsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CountCommitsResponse.Unmarshal(m, b)
}
func (m *CountCommitsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CountCommitsResponse.Marshal(b, m, deterministic)
}
func (m *CountCommitsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CountCommitsResponse.Merge(m, src)
}
func (m *CountCommitsResponse) XXX_Size() int {
	return xxx_messageInfo_CountCommitsResponse.Size(m)
}
func (m *CountCommitsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CountCommitsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CountCommitsResponse proto.InternalMessageInfo

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

type CountDivergingCommitsRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	From                 []byte      `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
	To                   []byte      `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
	MaxCount             int32       `protobuf:"varint,7,opt,name=max_count,json=maxCount,proto3" json:"max_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CountDivergingCommitsRequest) Reset()         { *m = CountDivergingCommitsRequest{} }
func (m *CountDivergingCommitsRequest) String() string { return proto.CompactTextString(m) }
func (*CountDivergingCommitsRequest) ProtoMessage()    {}
func (*CountDivergingCommitsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{10}
}

func (m *CountDivergingCommitsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CountDivergingCommitsRequest.Unmarshal(m, b)
}
func (m *CountDivergingCommitsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CountDivergingCommitsRequest.Marshal(b, m, deterministic)
}
func (m *CountDivergingCommitsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CountDivergingCommitsRequest.Merge(m, src)
}
func (m *CountDivergingCommitsRequest) XXX_Size() int {
	return xxx_messageInfo_CountDivergingCommitsRequest.Size(m)
}
func (m *CountDivergingCommitsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CountDivergingCommitsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CountDivergingCommitsRequest proto.InternalMessageInfo

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

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

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

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

type CountDivergingCommitsResponse struct {
	LeftCount            int32    `protobuf:"varint,1,opt,name=left_count,json=leftCount,proto3" json:"left_count,omitempty"`
	RightCount           int32    `protobuf:"varint,2,opt,name=right_count,json=rightCount,proto3" json:"right_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CountDivergingCommitsResponse) Reset()         { *m = CountDivergingCommitsResponse{} }
func (m *CountDivergingCommitsResponse) String() string { return proto.CompactTextString(m) }
func (*CountDivergingCommitsResponse) ProtoMessage()    {}
func (*CountDivergingCommitsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{11}
}

func (m *CountDivergingCommitsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CountDivergingCommitsResponse.Unmarshal(m, b)
}
func (m *CountDivergingCommitsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CountDivergingCommitsResponse.Marshal(b, m, deterministic)
}
func (m *CountDivergingCommitsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CountDivergingCommitsResponse.Merge(m, src)
}
func (m *CountDivergingCommitsResponse) XXX_Size() int {
	return xxx_messageInfo_CountDivergingCommitsResponse.Size(m)
}
func (m *CountDivergingCommitsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CountDivergingCommitsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CountDivergingCommitsResponse proto.InternalMessageInfo

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

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

type TreeEntry struct {
	// OID of the object this tree entry points to
	Oid string `protobuf:"bytes,1,opt,name=oid,proto3" json:"oid,omitempty"`
	// OID of the tree attached to commit_oid
	RootOid string `protobuf:"bytes,2,opt,name=root_oid,json=rootOid,proto3" json:"root_oid,omitempty"`
	// Path relative to repository root
	Path []byte              `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	Type TreeEntry_EntryType `protobuf:"varint,4,opt,name=type,proto3,enum=gitaly.TreeEntry_EntryType" json:"type,omitempty"`
	// File mode e.g. 0644
	Mode int32 `protobuf:"varint,5,opt,name=mode,proto3" json:"mode,omitempty"`
	// 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"`
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TreeEntry) Reset()         { *m = TreeEntry{} }
func (m *TreeEntry) String() string { return proto.CompactTextString(m) }
func (*TreeEntry) ProtoMessage()    {}
func (*TreeEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{12}
}

func (m *TreeEntry) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TreeEntry.Unmarshal(m, b)
}
func (m *TreeEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TreeEntry.Marshal(b, m, deterministic)
}
func (m *TreeEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeEntry.Merge(m, src)
}
func (m *TreeEntry) XXX_Size() int {
	return xxx_messageInfo_TreeEntry.Size(m)
}
func (m *TreeEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeEntry.DiscardUnknown(m)
}

var xxx_messageInfo_TreeEntry proto.InternalMessageInfo

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

func (m *TreeEntry) GetRootOid() string {
	if m != nil {
		return m.RootOid
	}
	return ""
}

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

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

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

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

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

type GetTreeEntriesRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision             []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	Path                 []byte      `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	Recursive            bool        `protobuf:"varint,4,opt,name=recursive,proto3" json:"recursive,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *GetTreeEntriesRequest) Reset()         { *m = GetTreeEntriesRequest{} }
func (m *GetTreeEntriesRequest) String() string { return proto.CompactTextString(m) }
func (*GetTreeEntriesRequest) ProtoMessage()    {}
func (*GetTreeEntriesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{13}
}

func (m *GetTreeEntriesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetTreeEntriesRequest.Unmarshal(m, b)
}
func (m *GetTreeEntriesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetTreeEntriesRequest.Marshal(b, m, deterministic)
}
func (m *GetTreeEntriesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTreeEntriesRequest.Merge(m, src)
}
func (m *GetTreeEntriesRequest) XXX_Size() int {
	return xxx_messageInfo_GetTreeEntriesRequest.Size(m)
}
func (m *GetTreeEntriesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTreeEntriesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetTreeEntriesRequest proto.InternalMessageInfo

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

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

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

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

type GetTreeEntriesResponse struct {
	Entries              []*TreeEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *GetTreeEntriesResponse) Reset()         { *m = GetTreeEntriesResponse{} }
func (m *GetTreeEntriesResponse) String() string { return proto.CompactTextString(m) }
func (*GetTreeEntriesResponse) ProtoMessage()    {}
func (*GetTreeEntriesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{14}
}

func (m *GetTreeEntriesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetTreeEntriesResponse.Unmarshal(m, b)
}
func (m *GetTreeEntriesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetTreeEntriesResponse.Marshal(b, m, deterministic)
}
func (m *GetTreeEntriesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTreeEntriesResponse.Merge(m, src)
}
func (m *GetTreeEntriesResponse) XXX_Size() int {
	return xxx_messageInfo_GetTreeEntriesResponse.Size(m)
}
func (m *GetTreeEntriesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTreeEntriesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetTreeEntriesResponse proto.InternalMessageInfo

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

type ListFilesRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision             []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *ListFilesRequest) Reset()         { *m = ListFilesRequest{} }
func (m *ListFilesRequest) String() string { return proto.CompactTextString(m) }
func (*ListFilesRequest) ProtoMessage()    {}
func (*ListFilesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{15}
}

func (m *ListFilesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFilesRequest.Unmarshal(m, b)
}
func (m *ListFilesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFilesRequest.Marshal(b, m, deterministic)
}
func (m *ListFilesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFilesRequest.Merge(m, src)
}
func (m *ListFilesRequest) XXX_Size() int {
	return xxx_messageInfo_ListFilesRequest.Size(m)
}
func (m *ListFilesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFilesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListFilesRequest proto.InternalMessageInfo

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

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

// A single 'page' of the paginated response
type ListFilesResponse struct {
	// Remember to force encoding utf-8 on the client side
	Paths                [][]byte `protobuf:"bytes,1,rep,name=paths,proto3" json:"paths,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListFilesResponse) Reset()         { *m = ListFilesResponse{} }
func (m *ListFilesResponse) String() string { return proto.CompactTextString(m) }
func (*ListFilesResponse) ProtoMessage()    {}
func (*ListFilesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{16}
}

func (m *ListFilesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListFilesResponse.Unmarshal(m, b)
}
func (m *ListFilesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListFilesResponse.Marshal(b, m, deterministic)
}
func (m *ListFilesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListFilesResponse.Merge(m, src)
}
func (m *ListFilesResponse) XXX_Size() int {
	return xxx_messageInfo_ListFilesResponse.Size(m)
}
func (m *ListFilesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListFilesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListFilesResponse proto.InternalMessageInfo

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

type FindCommitRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision             []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *FindCommitRequest) Reset()         { *m = FindCommitRequest{} }
func (m *FindCommitRequest) String() string { return proto.CompactTextString(m) }
func (*FindCommitRequest) ProtoMessage()    {}
func (*FindCommitRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{17}
}

func (m *FindCommitRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FindCommitRequest.Unmarshal(m, b)
}
func (m *FindCommitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FindCommitRequest.Marshal(b, m, deterministic)
}
func (m *FindCommitRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FindCommitRequest.Merge(m, src)
}
func (m *FindCommitRequest) XXX_Size() int {
	return xxx_messageInfo_FindCommitRequest.Size(m)
}
func (m *FindCommitRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FindCommitRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FindCommitRequest proto.InternalMessageInfo

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

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

type FindCommitResponse struct {
	// commit is nil when the commit was not found
	Commit               *GitCommit `protobuf:"bytes,1,opt,name=commit,proto3" json:"commit,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *FindCommitResponse) Reset()         { *m = FindCommitResponse{} }
func (m *FindCommitResponse) String() string { return proto.CompactTextString(m) }
func (*FindCommitResponse) ProtoMessage()    {}
func (*FindCommitResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{18}
}

func (m *FindCommitResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FindCommitResponse.Unmarshal(m, b)
}
func (m *FindCommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FindCommitResponse.Marshal(b, m, deterministic)
}
func (m *FindCommitResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FindCommitResponse.Merge(m, src)
}
func (m *FindCommitResponse) XXX_Size() int {
	return xxx_messageInfo_FindCommitResponse.Size(m)
}
func (m *FindCommitResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_FindCommitResponse.DiscardUnknown(m)
}

var xxx_messageInfo_FindCommitResponse proto.InternalMessageInfo

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

type ListCommitsByOidRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Oid                  []string    `protobuf:"bytes,2,rep,name=oid,proto3" json:"oid,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *ListCommitsByOidRequest) Reset()         { *m = ListCommitsByOidRequest{} }
func (m *ListCommitsByOidRequest) String() string { return proto.CompactTextString(m) }
func (*ListCommitsByOidRequest) ProtoMessage()    {}
func (*ListCommitsByOidRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{19}
}

func (m *ListCommitsByOidRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListCommitsByOidRequest.Unmarshal(m, b)
}
func (m *ListCommitsByOidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListCommitsByOidRequest.Marshal(b, m, deterministic)
}
func (m *ListCommitsByOidRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListCommitsByOidRequest.Merge(m, src)
}
func (m *ListCommitsByOidRequest) XXX_Size() int {
	return xxx_messageInfo_ListCommitsByOidRequest.Size(m)
}
func (m *ListCommitsByOidRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListCommitsByOidRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListCommitsByOidRequest proto.InternalMessageInfo

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

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

type ListCommitsByOidResponse struct {
	Commits              []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *ListCommitsByOidResponse) Reset()         { *m = ListCommitsByOidResponse{} }
func (m *ListCommitsByOidResponse) String() string { return proto.CompactTextString(m) }
func (*ListCommitsByOidResponse) ProtoMessage()    {}
func (*ListCommitsByOidResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{20}
}

func (m *ListCommitsByOidResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListCommitsByOidResponse.Unmarshal(m, b)
}
func (m *ListCommitsByOidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListCommitsByOidResponse.Marshal(b, m, deterministic)
}
func (m *ListCommitsByOidResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListCommitsByOidResponse.Merge(m, src)
}
func (m *ListCommitsByOidResponse) XXX_Size() int {
	return xxx_messageInfo_ListCommitsByOidResponse.Size(m)
}
func (m *ListCommitsByOidResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListCommitsByOidResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListCommitsByOidResponse proto.InternalMessageInfo

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

type ListCommitsByRefNameRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	RefNames             [][]byte    `protobuf:"bytes,2,rep,name=ref_names,json=refNames,proto3" json:"ref_names,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *ListCommitsByRefNameRequest) Reset()         { *m = ListCommitsByRefNameRequest{} }
func (m *ListCommitsByRefNameRequest) String() string { return proto.CompactTextString(m) }
func (*ListCommitsByRefNameRequest) ProtoMessage()    {}
func (*ListCommitsByRefNameRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{21}
}

func (m *ListCommitsByRefNameRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListCommitsByRefNameRequest.Unmarshal(m, b)
}
func (m *ListCommitsByRefNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListCommitsByRefNameRequest.Marshal(b, m, deterministic)
}
func (m *ListCommitsByRefNameRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListCommitsByRefNameRequest.Merge(m, src)
}
func (m *ListCommitsByRefNameRequest) XXX_Size() int {
	return xxx_messageInfo_ListCommitsByRefNameRequest.Size(m)
}
func (m *ListCommitsByRefNameRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListCommitsByRefNameRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListCommitsByRefNameRequest proto.InternalMessageInfo

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

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

type ListCommitsByRefNameResponse struct {
	Commits              []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *ListCommitsByRefNameResponse) Reset()         { *m = ListCommitsByRefNameResponse{} }
func (m *ListCommitsByRefNameResponse) String() string { return proto.CompactTextString(m) }
func (*ListCommitsByRefNameResponse) ProtoMessage()    {}
func (*ListCommitsByRefNameResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{22}
}

func (m *ListCommitsByRefNameResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListCommitsByRefNameResponse.Unmarshal(m, b)
}
func (m *ListCommitsByRefNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListCommitsByRefNameResponse.Marshal(b, m, deterministic)
}
func (m *ListCommitsByRefNameResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListCommitsByRefNameResponse.Merge(m, src)
}
func (m *ListCommitsByRefNameResponse) XXX_Size() int {
	return xxx_messageInfo_ListCommitsByRefNameResponse.Size(m)
}
func (m *ListCommitsByRefNameResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListCommitsByRefNameResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListCommitsByRefNameResponse proto.InternalMessageInfo

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

type FindAllCommitsRequest struct {
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// When nil, return all commits reachable by any branch in the repo
	Revision             []byte                      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	MaxCount             int32                       `protobuf:"varint,3,opt,name=max_count,json=maxCount,proto3" json:"max_count,omitempty"`
	Skip                 int32                       `protobuf:"varint,4,opt,name=skip,proto3" json:"skip,omitempty"`
	Order                FindAllCommitsRequest_Order `protobuf:"varint,5,opt,name=order,proto3,enum=gitaly.FindAllCommitsRequest_Order" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *FindAllCommitsRequest) Reset()         { *m = FindAllCommitsRequest{} }
func (m *FindAllCommitsRequest) String() string { return proto.CompactTextString(m) }
func (*FindAllCommitsRequest) ProtoMessage()    {}
func (*FindAllCommitsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{23}
}

func (m *FindAllCommitsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FindAllCommitsRequest.Unmarshal(m, b)
}
func (m *FindAllCommitsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FindAllCommitsRequest.Marshal(b, m, deterministic)
}
func (m *FindAllCommitsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FindAllCommitsRequest.Merge(m, src)
}
func (m *FindAllCommitsRequest) XXX_Size() int {
	return xxx_messageInfo_FindAllCommitsRequest.Size(m)
}
func (m *FindAllCommitsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FindAllCommitsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FindAllCommitsRequest proto.InternalMessageInfo

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

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

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

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

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

// A single 'page' of the result set
type FindAllCommitsResponse struct {
	Commits              []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *FindAllCommitsResponse) Reset()         { *m = FindAllCommitsResponse{} }
func (m *FindAllCommitsResponse) String() string { return proto.CompactTextString(m) }
func (*FindAllCommitsResponse) ProtoMessage()    {}
func (*FindAllCommitsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{24}
}

func (m *FindAllCommitsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FindAllCommitsResponse.Unmarshal(m, b)
}
func (m *FindAllCommitsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FindAllCommitsResponse.Marshal(b, m, deterministic)
}
func (m *FindAllCommitsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FindAllCommitsResponse.Merge(m, src)
}
func (m *FindAllCommitsResponse) XXX_Size() int {
	return xxx_messageInfo_FindAllCommitsResponse.Size(m)
}
func (m *FindAllCommitsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_FindAllCommitsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_FindAllCommitsResponse proto.InternalMessageInfo

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

type FindCommitsRequest struct {
	Repository  *Repository          `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision    []byte               `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	Limit       int32                `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	Offset      int32                `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"`
	Paths       [][]byte             `protobuf:"bytes,5,rep,name=paths,proto3" json:"paths,omitempty"`
	Follow      bool                 `protobuf:"varint,6,opt,name=follow,proto3" json:"follow,omitempty"`
	SkipMerges  bool                 `protobuf:"varint,7,opt,name=skip_merges,json=skipMerges,proto3" json:"skip_merges,omitempty"`
	DisableWalk bool                 `protobuf:"varint,8,opt,name=disable_walk,json=disableWalk,proto3" json:"disable_walk,omitempty"`
	After       *timestamp.Timestamp `protobuf:"bytes,9,opt,name=after,proto3" json:"after,omitempty"`
	Before      *timestamp.Timestamp `protobuf:"bytes,10,opt,name=before,proto3" json:"before,omitempty"`
	// all and revision are mutually exclusive
	All                  bool     `protobuf:"varint,11,opt,name=all,proto3" json:"all,omitempty"`
	FirstParent          bool     `protobuf:"varint,12,opt,name=first_parent,json=firstParent,proto3" json:"first_parent,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FindCommitsRequest) Reset()         { *m = FindCommitsRequest{} }
func (m *FindCommitsRequest) String() string { return proto.CompactTextString(m) }
func (*FindCommitsRequest) ProtoMessage()    {}
func (*FindCommitsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{25}
}

func (m *FindCommitsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FindCommitsRequest.Unmarshal(m, b)
}
func (m *FindCommitsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FindCommitsRequest.Marshal(b, m, deterministic)
}
func (m *FindCommitsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FindCommitsRequest.Merge(m, src)
}
func (m *FindCommitsRequest) XXX_Size() int {
	return xxx_messageInfo_FindCommitsRequest.Size(m)
}
func (m *FindCommitsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FindCommitsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FindCommitsRequest proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

// A single 'page' of the result set
type FindCommitsResponse struct {
	Commits              []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *FindCommitsResponse) Reset()         { *m = FindCommitsResponse{} }
func (m *FindCommitsResponse) String() string { return proto.CompactTextString(m) }
func (*FindCommitsResponse) ProtoMessage()    {}
func (*FindCommitsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{26}
}

func (m *FindCommitsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FindCommitsResponse.Unmarshal(m, b)
}
func (m *FindCommitsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FindCommitsResponse.Marshal(b, m, deterministic)
}
func (m *FindCommitsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FindCommitsResponse.Merge(m, src)
}
func (m *FindCommitsResponse) XXX_Size() int {
	return xxx_messageInfo_FindCommitsResponse.Size(m)
}
func (m *FindCommitsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_FindCommitsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_FindCommitsResponse proto.InternalMessageInfo

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

type CommitLanguagesRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision             []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CommitLanguagesRequest) Reset()         { *m = CommitLanguagesRequest{} }
func (m *CommitLanguagesRequest) String() string { return proto.CompactTextString(m) }
func (*CommitLanguagesRequest) ProtoMessage()    {}
func (*CommitLanguagesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{27}
}

func (m *CommitLanguagesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitLanguagesRequest.Unmarshal(m, b)
}
func (m *CommitLanguagesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitLanguagesRequest.Marshal(b, m, deterministic)
}
func (m *CommitLanguagesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitLanguagesRequest.Merge(m, src)
}
func (m *CommitLanguagesRequest) XXX_Size() int {
	return xxx_messageInfo_CommitLanguagesRequest.Size(m)
}
func (m *CommitLanguagesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitLanguagesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CommitLanguagesRequest proto.InternalMessageInfo

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

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

type CommitLanguagesResponse struct {
	Languages            []*CommitLanguagesResponse_Language `protobuf:"bytes,1,rep,name=languages,proto3" json:"languages,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

func (m *CommitLanguagesResponse) Reset()         { *m = CommitLanguagesResponse{} }
func (m *CommitLanguagesResponse) String() string { return proto.CompactTextString(m) }
func (*CommitLanguagesResponse) ProtoMessage()    {}
func (*CommitLanguagesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{28}
}

func (m *CommitLanguagesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitLanguagesResponse.Unmarshal(m, b)
}
func (m *CommitLanguagesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitLanguagesResponse.Marshal(b, m, deterministic)
}
func (m *CommitLanguagesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitLanguagesResponse.Merge(m, src)
}
func (m *CommitLanguagesResponse) XXX_Size() int {
	return xxx_messageInfo_CommitLanguagesResponse.Size(m)
}
func (m *CommitLanguagesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitLanguagesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommitLanguagesResponse proto.InternalMessageInfo

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

type CommitLanguagesResponse_Language struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Share                float32  `protobuf:"fixed32,2,opt,name=share,proto3" json:"share,omitempty"`
	Color                string   `protobuf:"bytes,3,opt,name=color,proto3" json:"color,omitempty"`
	FileCount            uint32   `protobuf:"varint,4,opt,name=file_count,json=fileCount,proto3" json:"file_count,omitempty"`
	Bytes                uint64   `protobuf:"varint,5,opt,name=bytes,proto3" json:"bytes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CommitLanguagesResponse_Language) Reset()         { *m = CommitLanguagesResponse_Language{} }
func (m *CommitLanguagesResponse_Language) String() string { return proto.CompactTextString(m) }
func (*CommitLanguagesResponse_Language) ProtoMessage()    {}
func (*CommitLanguagesResponse_Language) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{28, 0}
}

func (m *CommitLanguagesResponse_Language) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitLanguagesResponse_Language.Unmarshal(m, b)
}
func (m *CommitLanguagesResponse_Language) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitLanguagesResponse_Language.Marshal(b, m, deterministic)
}
func (m *CommitLanguagesResponse_Language) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitLanguagesResponse_Language.Merge(m, src)
}
func (m *CommitLanguagesResponse_Language) XXX_Size() int {
	return xxx_messageInfo_CommitLanguagesResponse_Language.Size(m)
}
func (m *CommitLanguagesResponse_Language) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitLanguagesResponse_Language.DiscardUnknown(m)
}

var xxx_messageInfo_CommitLanguagesResponse_Language proto.InternalMessageInfo

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

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

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

func (m *CommitLanguagesResponse_Language) GetFileCount() uint32 {
	if m != nil {
		return m.FileCount
	}
	return 0
}

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

type RawBlameRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision             []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	Path                 []byte      `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *RawBlameRequest) Reset()         { *m = RawBlameRequest{} }
func (m *RawBlameRequest) String() string { return proto.CompactTextString(m) }
func (*RawBlameRequest) ProtoMessage()    {}
func (*RawBlameRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{29}
}

func (m *RawBlameRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RawBlameRequest.Unmarshal(m, b)
}
func (m *RawBlameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RawBlameRequest.Marshal(b, m, deterministic)
}
func (m *RawBlameRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RawBlameRequest.Merge(m, src)
}
func (m *RawBlameRequest) XXX_Size() int {
	return xxx_messageInfo_RawBlameRequest.Size(m)
}
func (m *RawBlameRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RawBlameRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RawBlameRequest proto.InternalMessageInfo

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

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

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

type RawBlameResponse struct {
	Data                 []byte   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RawBlameResponse) Reset()         { *m = RawBlameResponse{} }
func (m *RawBlameResponse) String() string { return proto.CompactTextString(m) }
func (*RawBlameResponse) ProtoMessage()    {}
func (*RawBlameResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{30}
}

func (m *RawBlameResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RawBlameResponse.Unmarshal(m, b)
}
func (m *RawBlameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RawBlameResponse.Marshal(b, m, deterministic)
}
func (m *RawBlameResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RawBlameResponse.Merge(m, src)
}
func (m *RawBlameResponse) XXX_Size() int {
	return xxx_messageInfo_RawBlameResponse.Size(m)
}
func (m *RawBlameResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RawBlameResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RawBlameResponse proto.InternalMessageInfo

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

type LastCommitForPathRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision             []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	Path                 []byte      `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *LastCommitForPathRequest) Reset()         { *m = LastCommitForPathRequest{} }
func (m *LastCommitForPathRequest) String() string { return proto.CompactTextString(m) }
func (*LastCommitForPathRequest) ProtoMessage()    {}
func (*LastCommitForPathRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{31}
}

func (m *LastCommitForPathRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LastCommitForPathRequest.Unmarshal(m, b)
}
func (m *LastCommitForPathRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LastCommitForPathRequest.Marshal(b, m, deterministic)
}
func (m *LastCommitForPathRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LastCommitForPathRequest.Merge(m, src)
}
func (m *LastCommitForPathRequest) XXX_Size() int {
	return xxx_messageInfo_LastCommitForPathRequest.Size(m)
}
func (m *LastCommitForPathRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LastCommitForPathRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LastCommitForPathRequest proto.InternalMessageInfo

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

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

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

type LastCommitForPathResponse struct {
	// commit is nil when the commit was not found
	Commit               *GitCommit `protobuf:"bytes,1,opt,name=commit,proto3" json:"commit,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *LastCommitForPathResponse) Reset()         { *m = LastCommitForPathResponse{} }
func (m *LastCommitForPathResponse) String() string { return proto.CompactTextString(m) }
func (*LastCommitForPathResponse) ProtoMessage()    {}
func (*LastCommitForPathResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{32}
}

func (m *LastCommitForPathResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LastCommitForPathResponse.Unmarshal(m, b)
}
func (m *LastCommitForPathResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LastCommitForPathResponse.Marshal(b, m, deterministic)
}
func (m *LastCommitForPathResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LastCommitForPathResponse.Merge(m, src)
}
func (m *LastCommitForPathResponse) XXX_Size() int {
	return xxx_messageInfo_LastCommitForPathResponse.Size(m)
}
func (m *LastCommitForPathResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LastCommitForPathResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LastCommitForPathResponse proto.InternalMessageInfo

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

type ListLastCommitsForTreeRequest struct {
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision   string      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	Path       []byte      `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	// limit == -1 will get the last commit for all paths
	Limit                int32    `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	Offset               int32    `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListLastCommitsForTreeRequest) Reset()         { *m = ListLastCommitsForTreeRequest{} }
func (m *ListLastCommitsForTreeRequest) String() string { return proto.CompactTextString(m) }
func (*ListLastCommitsForTreeRequest) ProtoMessage()    {}
func (*ListLastCommitsForTreeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{33}
}

func (m *ListLastCommitsForTreeRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListLastCommitsForTreeRequest.Unmarshal(m, b)
}
func (m *ListLastCommitsForTreeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListLastCommitsForTreeRequest.Marshal(b, m, deterministic)
}
func (m *ListLastCommitsForTreeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListLastCommitsForTreeRequest.Merge(m, src)
}
func (m *ListLastCommitsForTreeRequest) XXX_Size() int {
	return xxx_messageInfo_ListLastCommitsForTreeRequest.Size(m)
}
func (m *ListLastCommitsForTreeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListLastCommitsForTreeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListLastCommitsForTreeRequest proto.InternalMessageInfo

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

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

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

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

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

type ListLastCommitsForTreeResponse struct {
	Commits              []*ListLastCommitsForTreeResponse_CommitForTree `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                        `json:"-"`
	XXX_unrecognized     []byte                                          `json:"-"`
	XXX_sizecache        int32                                           `json:"-"`
}

func (m *ListLastCommitsForTreeResponse) Reset()         { *m = ListLastCommitsForTreeResponse{} }
func (m *ListLastCommitsForTreeResponse) String() string { return proto.CompactTextString(m) }
func (*ListLastCommitsForTreeResponse) ProtoMessage()    {}
func (*ListLastCommitsForTreeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{34}
}

func (m *ListLastCommitsForTreeResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListLastCommitsForTreeResponse.Unmarshal(m, b)
}
func (m *ListLastCommitsForTreeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListLastCommitsForTreeResponse.Marshal(b, m, deterministic)
}
func (m *ListLastCommitsForTreeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListLastCommitsForTreeResponse.Merge(m, src)
}
func (m *ListLastCommitsForTreeResponse) XXX_Size() int {
	return xxx_messageInfo_ListLastCommitsForTreeResponse.Size(m)
}
func (m *ListLastCommitsForTreeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListLastCommitsForTreeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListLastCommitsForTreeResponse proto.InternalMessageInfo

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

type ListLastCommitsForTreeResponse_CommitForTree struct {
	Commit               *GitCommit `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"`
	PathBytes            []byte     `protobuf:"bytes,4,opt,name=path_bytes,json=pathBytes,proto3" json:"path_bytes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ListLastCommitsForTreeResponse_CommitForTree) Reset() {
	*m = ListLastCommitsForTreeResponse_CommitForTree{}
}
func (m *ListLastCommitsForTreeResponse_CommitForTree) String() string {
	return proto.CompactTextString(m)
}
func (*ListLastCommitsForTreeResponse_CommitForTree) ProtoMessage() {}
func (*ListLastCommitsForTreeResponse_CommitForTree) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{34, 0}
}

func (m *ListLastCommitsForTreeResponse_CommitForTree) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListLastCommitsForTreeResponse_CommitForTree.Unmarshal(m, b)
}
func (m *ListLastCommitsForTreeResponse_CommitForTree) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListLastCommitsForTreeResponse_CommitForTree.Marshal(b, m, deterministic)
}
func (m *ListLastCommitsForTreeResponse_CommitForTree) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListLastCommitsForTreeResponse_CommitForTree.Merge(m, src)
}
func (m *ListLastCommitsForTreeResponse_CommitForTree) XXX_Size() int {
	return xxx_messageInfo_ListLastCommitsForTreeResponse_CommitForTree.Size(m)
}
func (m *ListLastCommitsForTreeResponse_CommitForTree) XXX_DiscardUnknown() {
	xxx_messageInfo_ListLastCommitsForTreeResponse_CommitForTree.DiscardUnknown(m)
}

var xxx_messageInfo_ListLastCommitsForTreeResponse_CommitForTree proto.InternalMessageInfo

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

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

type CommitsByMessageRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Revision             []byte      `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	Offset               int32       `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	Limit                int32       `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	Path                 []byte      `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
	Query                string      `protobuf:"bytes,6,opt,name=query,proto3" json:"query,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CommitsByMessageRequest) Reset()         { *m = CommitsByMessageRequest{} }
func (m *CommitsByMessageRequest) String() string { return proto.CompactTextString(m) }
func (*CommitsByMessageRequest) ProtoMessage()    {}
func (*CommitsByMessageRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{35}
}

func (m *CommitsByMessageRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitsByMessageRequest.Unmarshal(m, b)
}
func (m *CommitsByMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitsByMessageRequest.Marshal(b, m, deterministic)
}
func (m *CommitsByMessageRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitsByMessageRequest.Merge(m, src)
}
func (m *CommitsByMessageRequest) XXX_Size() int {
	return xxx_messageInfo_CommitsByMessageRequest.Size(m)
}
func (m *CommitsByMessageRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitsByMessageRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CommitsByMessageRequest proto.InternalMessageInfo

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

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

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

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

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

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

// One 'page' of the paginated response of CommitsByMessage
type CommitsByMessageResponse struct {
	Commits              []*GitCommit `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *CommitsByMessageResponse) Reset()         { *m = CommitsByMessageResponse{} }
func (m *CommitsByMessageResponse) String() string { return proto.CompactTextString(m) }
func (*CommitsByMessageResponse) ProtoMessage()    {}
func (*CommitsByMessageResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{36}
}

func (m *CommitsByMessageResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitsByMessageResponse.Unmarshal(m, b)
}
func (m *CommitsByMessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitsByMessageResponse.Marshal(b, m, deterministic)
}
func (m *CommitsByMessageResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitsByMessageResponse.Merge(m, src)
}
func (m *CommitsByMessageResponse) XXX_Size() int {
	return xxx_messageInfo_CommitsByMessageResponse.Size(m)
}
func (m *CommitsByMessageResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitsByMessageResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommitsByMessageResponse proto.InternalMessageInfo

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

type FilterShasWithSignaturesRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	Shas                 [][]byte    `protobuf:"bytes,2,rep,name=shas,proto3" json:"shas,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *FilterShasWithSignaturesRequest) Reset()         { *m = FilterShasWithSignaturesRequest{} }
func (m *FilterShasWithSignaturesRequest) String() string { return proto.CompactTextString(m) }
func (*FilterShasWithSignaturesRequest) ProtoMessage()    {}
func (*FilterShasWithSignaturesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{37}
}

func (m *FilterShasWithSignaturesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FilterShasWithSignaturesRequest.Unmarshal(m, b)
}
func (m *FilterShasWithSignaturesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FilterShasWithSignaturesRequest.Marshal(b, m, deterministic)
}
func (m *FilterShasWithSignaturesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FilterShasWithSignaturesRequest.Merge(m, src)
}
func (m *FilterShasWithSignaturesRequest) XXX_Size() int {
	return xxx_messageInfo_FilterShasWithSignaturesRequest.Size(m)
}
func (m *FilterShasWithSignaturesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FilterShasWithSignaturesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FilterShasWithSignaturesRequest proto.InternalMessageInfo

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

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

type FilterShasWithSignaturesResponse struct {
	Shas                 [][]byte `protobuf:"bytes,1,rep,name=shas,proto3" json:"shas,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FilterShasWithSignaturesResponse) Reset()         { *m = FilterShasWithSignaturesResponse{} }
func (m *FilterShasWithSignaturesResponse) String() string { return proto.CompactTextString(m) }
func (*FilterShasWithSignaturesResponse) ProtoMessage()    {}
func (*FilterShasWithSignaturesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{38}
}

func (m *FilterShasWithSignaturesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FilterShasWithSignaturesResponse.Unmarshal(m, b)
}
func (m *FilterShasWithSignaturesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FilterShasWithSignaturesResponse.Marshal(b, m, deterministic)
}
func (m *FilterShasWithSignaturesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FilterShasWithSignaturesResponse.Merge(m, src)
}
func (m *FilterShasWithSignaturesResponse) XXX_Size() int {
	return xxx_messageInfo_FilterShasWithSignaturesResponse.Size(m)
}
func (m *FilterShasWithSignaturesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_FilterShasWithSignaturesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_FilterShasWithSignaturesResponse proto.InternalMessageInfo

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

type ExtractCommitSignatureRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	CommitId             string      `protobuf:"bytes,2,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *ExtractCommitSignatureRequest) Reset()         { *m = ExtractCommitSignatureRequest{} }
func (m *ExtractCommitSignatureRequest) String() string { return proto.CompactTextString(m) }
func (*ExtractCommitSignatureRequest) ProtoMessage()    {}
func (*ExtractCommitSignatureRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{39}
}

func (m *ExtractCommitSignatureRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExtractCommitSignatureRequest.Unmarshal(m, b)
}
func (m *ExtractCommitSignatureRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExtractCommitSignatureRequest.Marshal(b, m, deterministic)
}
func (m *ExtractCommitSignatureRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExtractCommitSignatureRequest.Merge(m, src)
}
func (m *ExtractCommitSignatureRequest) XXX_Size() int {
	return xxx_messageInfo_ExtractCommitSignatureRequest.Size(m)
}
func (m *ExtractCommitSignatureRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ExtractCommitSignatureRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ExtractCommitSignatureRequest proto.InternalMessageInfo

func (m *ExtractCommitSignatureRequest) GetRepository() *Repository {
	if m != nil {
		return m.Repository
	}
	return nil
}

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

// Either of the 'signature' and 'signed_text' fields may be present. It
// is up to the caller to stitch them together.
type ExtractCommitSignatureResponse struct {
	Signature            []byte   `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
	SignedText           []byte   `protobuf:"bytes,2,opt,name=signed_text,json=signedText,proto3" json:"signed_text,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExtractCommitSignatureResponse) Reset()         { *m = ExtractCommitSignatureResponse{} }
func (m *ExtractCommitSignatureResponse) String() string { return proto.CompactTextString(m) }
func (*ExtractCommitSignatureResponse) ProtoMessage()    {}
func (*ExtractCommitSignatureResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{40}
}

func (m *ExtractCommitSignatureResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExtractCommitSignatureResponse.Unmarshal(m, b)
}
func (m *ExtractCommitSignatureResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExtractCommitSignatureResponse.Marshal(b, m, deterministic)
}
func (m *ExtractCommitSignatureResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExtractCommitSignatureResponse.Merge(m, src)
}
func (m *ExtractCommitSignatureResponse) XXX_Size() int {
	return xxx_messageInfo_ExtractCommitSignatureResponse.Size(m)
}
func (m *ExtractCommitSignatureResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ExtractCommitSignatureResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ExtractCommitSignatureResponse proto.InternalMessageInfo

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

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

type GetCommitSignaturesRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	CommitIds            []string    `protobuf:"bytes,2,rep,name=commit_ids,json=commitIds,proto3" json:"commit_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *GetCommitSignaturesRequest) Reset()         { *m = GetCommitSignaturesRequest{} }
func (m *GetCommitSignaturesRequest) String() string { return proto.CompactTextString(m) }
func (*GetCommitSignaturesRequest) ProtoMessage()    {}
func (*GetCommitSignaturesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{41}
}

func (m *GetCommitSignaturesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetCommitSignaturesRequest.Unmarshal(m, b)
}
func (m *GetCommitSignaturesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetCommitSignaturesRequest.Marshal(b, m, deterministic)
}
func (m *GetCommitSignaturesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetCommitSignaturesRequest.Merge(m, src)
}
func (m *GetCommitSignaturesRequest) XXX_Size() int {
	return xxx_messageInfo_GetCommitSignaturesRequest.Size(m)
}
func (m *GetCommitSignaturesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetCommitSignaturesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetCommitSignaturesRequest proto.InternalMessageInfo

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

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

type GetCommitSignaturesResponse struct {
	// Only present for a new commit signature data.
	CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// See ExtractCommitSignatureResponse above for how these fields should be handled.
	Signature            []byte   `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	SignedText           []byte   `protobuf:"bytes,3,opt,name=signed_text,json=signedText,proto3" json:"signed_text,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetCommitSignaturesResponse) Reset()         { *m = GetCommitSignaturesResponse{} }
func (m *GetCommitSignaturesResponse) String() string { return proto.CompactTextString(m) }
func (*GetCommitSignaturesResponse) ProtoMessage()    {}
func (*GetCommitSignaturesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{42}
}

func (m *GetCommitSignaturesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetCommitSignaturesResponse.Unmarshal(m, b)
}
func (m *GetCommitSignaturesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetCommitSignaturesResponse.Marshal(b, m, deterministic)
}
func (m *GetCommitSignaturesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetCommitSignaturesResponse.Merge(m, src)
}
func (m *GetCommitSignaturesResponse) XXX_Size() int {
	return xxx_messageInfo_GetCommitSignaturesResponse.Size(m)
}
func (m *GetCommitSignaturesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetCommitSignaturesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetCommitSignaturesResponse proto.InternalMessageInfo

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

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

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

type GetCommitMessagesRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	CommitIds            []string    `protobuf:"bytes,2,rep,name=commit_ids,json=commitIds,proto3" json:"commit_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *GetCommitMessagesRequest) Reset()         { *m = GetCommitMessagesRequest{} }
func (m *GetCommitMessagesRequest) String() string { return proto.CompactTextString(m) }
func (*GetCommitMessagesRequest) ProtoMessage()    {}
func (*GetCommitMessagesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{43}
}

func (m *GetCommitMessagesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetCommitMessagesRequest.Unmarshal(m, b)
}
func (m *GetCommitMessagesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetCommitMessagesRequest.Marshal(b, m, deterministic)
}
func (m *GetCommitMessagesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetCommitMessagesRequest.Merge(m, src)
}
func (m *GetCommitMessagesRequest) XXX_Size() int {
	return xxx_messageInfo_GetCommitMessagesRequest.Size(m)
}
func (m *GetCommitMessagesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetCommitMessagesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetCommitMessagesRequest proto.InternalMessageInfo

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

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

type GetCommitMessagesResponse struct {
	// Only present for a new commit message
	CommitId             string   `protobuf:"bytes,1,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	Message              []byte   `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetCommitMessagesResponse) Reset()         { *m = GetCommitMessagesResponse{} }
func (m *GetCommitMessagesResponse) String() string { return proto.CompactTextString(m) }
func (*GetCommitMessagesResponse) ProtoMessage()    {}
func (*GetCommitMessagesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_db7163399a465f48, []int{44}
}

func (m *GetCommitMessagesResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetCommitMessagesResponse.Unmarshal(m, b)
}
func (m *GetCommitMessagesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetCommitMessagesResponse.Marshal(b, m, deterministic)
}
func (m *GetCommitMessagesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetCommitMessagesResponse.Merge(m, src)
}
func (m *GetCommitMessagesResponse) XXX_Size() int {
	return xxx_messageInfo_GetCommitMessagesResponse.Size(m)
}
func (m *GetCommitMessagesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetCommitMessagesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetCommitMessagesResponse proto.InternalMessageInfo

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

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

func init() {
	proto.RegisterEnum("gitaly.TreeEntryResponse_ObjectType", TreeEntryResponse_ObjectType_name, TreeEntryResponse_ObjectType_value)
	proto.RegisterEnum("gitaly.TreeEntry_EntryType", TreeEntry_EntryType_name, TreeEntry_EntryType_value)
	proto.RegisterEnum("gitaly.FindAllCommitsRequest_Order", FindAllCommitsRequest_Order_name, FindAllCommitsRequest_Order_value)
	proto.RegisterType((*CommitStatsRequest)(nil), "gitaly.CommitStatsRequest")
	proto.RegisterType((*CommitStatsResponse)(nil), "gitaly.CommitStatsResponse")
	proto.RegisterType((*CommitIsAncestorRequest)(nil), "gitaly.CommitIsAncestorRequest")
	proto.RegisterType((*CommitIsAncestorResponse)(nil), "gitaly.CommitIsAncestorResponse")
	proto.RegisterType((*TreeEntryRequest)(nil), "gitaly.TreeEntryRequest")
	proto.RegisterType((*TreeEntryResponse)(nil), "gitaly.TreeEntryResponse")
	proto.RegisterType((*CommitsBetweenRequest)(nil), "gitaly.CommitsBetweenRequest")
	proto.RegisterType((*CommitsBetweenResponse)(nil), "gitaly.CommitsBetweenResponse")
	proto.RegisterType((*CountCommitsRequest)(nil), "gitaly.CountCommitsRequest")
	proto.RegisterType((*CountCommitsResponse)(nil), "gitaly.CountCommitsResponse")
	proto.RegisterType((*CountDivergingCommitsRequest)(nil), "gitaly.CountDivergingCommitsRequest")
	proto.RegisterType((*CountDivergingCommitsResponse)(nil), "gitaly.CountDivergingCommitsResponse")
	proto.RegisterType((*TreeEntry)(nil), "gitaly.TreeEntry")
	proto.RegisterType((*GetTreeEntriesRequest)(nil), "gitaly.GetTreeEntriesRequest")
	proto.RegisterType((*GetTreeEntriesResponse)(nil), "gitaly.GetTreeEntriesResponse")
	proto.RegisterType((*ListFilesRequest)(nil), "gitaly.ListFilesRequest")
	proto.RegisterType((*ListFilesResponse)(nil), "gitaly.ListFilesResponse")
	proto.RegisterType((*FindCommitRequest)(nil), "gitaly.FindCommitRequest")
	proto.RegisterType((*FindCommitResponse)(nil), "gitaly.FindCommitResponse")
	proto.RegisterType((*ListCommitsByOidRequest)(nil), "gitaly.ListCommitsByOidRequest")
	proto.RegisterType((*ListCommitsByOidResponse)(nil), "gitaly.ListCommitsByOidResponse")
	proto.RegisterType((*ListCommitsByRefNameRequest)(nil), "gitaly.ListCommitsByRefNameRequest")
	proto.RegisterType((*ListCommitsByRefNameResponse)(nil), "gitaly.ListCommitsByRefNameResponse")
	proto.RegisterType((*FindAllCommitsRequest)(nil), "gitaly.FindAllCommitsRequest")
	proto.RegisterType((*FindAllCommitsResponse)(nil), "gitaly.FindAllCommitsResponse")
	proto.RegisterType((*FindCommitsRequest)(nil), "gitaly.FindCommitsRequest")
	proto.RegisterType((*FindCommitsResponse)(nil), "gitaly.FindCommitsResponse")
	proto.RegisterType((*CommitLanguagesRequest)(nil), "gitaly.CommitLanguagesRequest")
	proto.RegisterType((*CommitLanguagesResponse)(nil), "gitaly.CommitLanguagesResponse")
	proto.RegisterType((*CommitLanguagesResponse_Language)(nil), "gitaly.CommitLanguagesResponse.Language")
	proto.RegisterType((*RawBlameRequest)(nil), "gitaly.RawBlameRequest")
	proto.RegisterType((*RawBlameResponse)(nil), "gitaly.RawBlameResponse")
	proto.RegisterType((*LastCommitForPathRequest)(nil), "gitaly.LastCommitForPathRequest")
	proto.RegisterType((*LastCommitForPathResponse)(nil), "gitaly.LastCommitForPathResponse")
	proto.RegisterType((*ListLastCommitsForTreeRequest)(nil), "gitaly.ListLastCommitsForTreeRequest")
	proto.RegisterType((*ListLastCommitsForTreeResponse)(nil), "gitaly.ListLastCommitsForTreeResponse")
	proto.RegisterType((*ListLastCommitsForTreeResponse_CommitForTree)(nil), "gitaly.ListLastCommitsForTreeResponse.CommitForTree")
	proto.RegisterType((*CommitsByMessageRequest)(nil), "gitaly.CommitsByMessageRequest")
	proto.RegisterType((*CommitsByMessageResponse)(nil), "gitaly.CommitsByMessageResponse")
	proto.RegisterType((*FilterShasWithSignaturesRequest)(nil), "gitaly.FilterShasWithSignaturesRequest")
	proto.RegisterType((*FilterShasWithSignaturesResponse)(nil), "gitaly.FilterShasWithSignaturesResponse")
	proto.RegisterType((*ExtractCommitSignatureRequest)(nil), "gitaly.ExtractCommitSignatureRequest")
	proto.RegisterType((*ExtractCommitSignatureResponse)(nil), "gitaly.ExtractCommitSignatureResponse")
	proto.RegisterType((*GetCommitSignaturesRequest)(nil), "gitaly.GetCommitSignaturesRequest")
	proto.RegisterType((*GetCommitSignaturesResponse)(nil), "gitaly.GetCommitSignaturesResponse")
	proto.RegisterType((*GetCommitMessagesRequest)(nil), "gitaly.GetCommitMessagesRequest")
	proto.RegisterType((*GetCommitMessagesResponse)(nil), "gitaly.GetCommitMessagesResponse")
}

func init() { proto.RegisterFile("commit.proto", fileDescriptor_db7163399a465f48) }

var fileDescriptor_db7163399a465f48 = []byte{
	// 2026 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x59, 0x5b, 0x6f, 0xdb, 0xc8,
	0x15, 0x5e, 0xea, 0x66, 0xf2, 0x48, 0xeb, 0xc8, 0x13, 0x27, 0x91, 0x69, 0x3b, 0xf6, 0x32, 0xc9,
	0xd6, 0x8b, 0x6d, 0x65, 0xd7, 0xbd, 0xa0, 0x7d, 0x2a, 0xe2, 0x5d, 0xdb, 0xb0, 0x1b, 0x5b, 0x29,
	0x2d, 0x60, 0x81, 0x62, 0x0b, 0x95, 0x12, 0x47, 0xd2, 0x34, 0x94, 0xa8, 0x25, 0x47, 0x8e, 0x55,
	0x14, 0xed, 0x73, 0x81, 0xbe, 0x17, 0x7d, 0xea, 0x53, 0x7f, 0xc0, 0xfe, 0x84, 0xfe, 0x85, 0xbe,
	0xf4, 0xbd, 0xbf, 0xa2, 0xc8, 0xd3, 0x62, 0x2e, 0xbc, 0x89, 0xa4, 0x1d, 0xdb, 0xab, 0xbc, 0x08,
	0x9c, 0x33, 0x97, 0x73, 0x99, 0x39, 0xdf, 0x7c, 0x73, 0x04, 0xb5, 0x9e, 0x3b, 0x1a, 0x11, 0xda,
	0x9c, 0x78, 0x2e, 0x75, 0x51, 0x65, 0x40, 0xa8, 0xe5, 0xcc, 0xf4, 0x9a, 0x3f, 0xb4, 0x3c, 0x6c,
	0x0b, 0xa9, 0xbe, 0x35, 0x70, 0xdd, 0x81, 0x83, 0x77, 0x79, 0xab, 0x3b, 0xed, 0xef, 0x52, 0x32,
	0xc2, 0x3e, 0xb5, 0x46, 0x13, 0x31, 0xc0, 0xb0, 0x01, 0x7d, 0xc1, 0x97, 0xb9, 0xa0, 0x16, 0xf5,
	0x4d, 0xfc, 0xcd, 0x14, 0xfb, 0x14, 0xed, 0x03, 0x78, 0x78, 0xe2, 0xfa, 0x84, 0xba, 0xde, 0xac,
	0xa1, 0x6c, 0x2b, 0x3b, 0xd5, 0x7d, 0xd4, 0x14, 0x1a, 0x9a, 0x66, 0xd8, 0x63, 0xc6, 0x46, 0x21,
	0x1d, 0x54, 0x0f, 0x5f, 0x12, 0x9f, 0xb8, 0xe3, 0x46, 0x61, 0x5b, 0xd9, 0xa9, 0x99, 0x61, 0xdb,
	0xe8, 0xc1, 0xc3, 0x84, 0x16, 0x7f, 0xe2, 0x8e, 0x7d, 0x8c, 0xea, 0x50, 0x74, 0x89, 0xcd, 0xd7,
	0xd7, 0x4c, 0xf6, 0x89, 0x36, 0x40, 0xb3, 0x6c, 0x9b, 0x50, 0xe2, 0x8e, 0x7d, 0xbe, 0x4a, 0xd9,
	0x8c, 0x04, 0xac, 0xd7, 0xc6, 0x0e, 0x16, 0xbd, 0x45, 0xd1, 0x1b, 0x0a, 0x8c, 0xbf, 0x2a, 0xf0,
	0x44, 0x68, 0x39, 0xf1, 0x5f, 0x8e, 0x7b, 0xd8, 0xa7, 0xae, 0x77, 0x1f, 0x87, 0xb6, 0xa0, 0x6a,
	0xc9, 0x65, 0x3a, 0xc4, 0xe6, 0xd6, 0x68, 0x26, 0x04, 0xa2, 0x13, 0x1b, 0xad, 0x81, 0xda, 0x1b,
	0x12, 0xc7, 0x66, 0xbd, 0x45, 0xde, 0xbb, 0xc4, 0xdb, 0x27, 0xb6, 0xb1, 0x07, 0x8d, 0xb4, 0x29,
	0xd2, 0xeb, 0x55, 0x28, 0x5f, 0x5a, 0xce, 0x14, 0x73, 0x33, 0x54, 0x53, 0x34, 0x8c, 0xbf, 0x29,
	0x50, 0x6f, 0x7b, 0x18, 0x1f, 0x8e, 0xa9, 0x37, 0x5b, 0xd0, 0x3e, 0x20, 0x04, 0xa5, 0x89, 0x45,
	0x87, 0xdc, 0xda, 0x9a, 0xc9, 0xbf, 0x99, 0x39, 0x0e, 0x19, 0x11, 0xda, 0x28, 0x6d, 0x2b, 0x3b,
	0x45, 0x53, 0x34, 0x8c, 0xff, 0x28, 0xb0, 0x12, 0x33, 0x47, 0x9a, 0xfe, 0x0b, 0x28, 0xd1, 0xd9,
	0x44, 0x58, 0xbe, 0xbc, 0xff, 0x3c, 0xb0, 0x24, 0x35, 0xb0, 0xd9, 0xea, 0xfe, 0x01, 0xf7, 0x68,
	0x7b, 0x36, 0xc1, 0x26, 0x9f, 0x11, 0x6c, 0x75, 0x21, 0xda, 0x6a, 0x04, 0x25, 0x9f, 0xfc, 0x11,
	0x73, 0x5b, 0x8a, 0x26, 0xff, 0x66, 0xb2, 0x91, 0x6b, 0x63, 0x6e, 0x4a, 0xd9, 0xe4, 0xdf, 0x4c,
	0x66, 0x5b, 0xd4, 0x6a, 0x94, 0x85, 0xcd, 0xec, 0xdb, 0xf8, 0x19, 0x40, 0xa4, 0x01, 0x01, 0x54,
	0xbe, 0x68, 0x9d, 0x9d, 0x9d, 0xb4, 0xeb, 0x1f, 0x21, 0x15, 0x4a, 0x07, 0xaf, 0x5a, 0x07, 0x75,
	0x85, 0x7d, 0xb5, 0xcd, 0xc3, 0xc3, 0x7a, 0x01, 0x2d, 0x41, 0xb1, 0xfd, 0xf2, 0xb8, 0x5e, 0x34,
	0x5c, 0x78, 0x24, 0x76, 0xc5, 0x3f, 0xc0, 0xf4, 0x2d, 0xc6, 0xe3, 0xfb, 0xc4, 0x19, 0x41, 0xa9,
	0xef, 0xb9, 0x23, 0x19, 0x63, 0xfe, 0x8d, 0x96, 0xa1, 0x40, 0x5d, 0x19, 0xdd, 0x02, 0x75, 0x8d,
	0x43, 0x78, 0x3c, 0xaf, 0x50, 0x46, 0xf2, 0x73, 0x58, 0x12, 0xe9, 0xeb, 0x37, 0x94, 0xed, 0xe2,
	0x4e, 0x75, 0x7f, 0x25, 0x50, 0x77, 0x4c, 0xa8, 0x98, 0x63, 0x06, 0x23, 0x8c, 0x6f, 0x0b, 0x2c,
	0x7f, 0xa6, 0x63, 0xd9, 0xb1, 0xa8, 0x34, 0x45, 0x7b, 0x50, 0xb6, 0xfa, 0x14, 0x7b, 0xdc, 0x83,
	0xea, 0xbe, 0xde, 0x14, 0xe8, 0xd1, 0x0c, 0xd0, 0xa3, 0xd9, 0x0e, 0xd0, 0xc3, 0x14, 0x03, 0xd1,
	0x3e, 0x54, 0xba, 0xb8, 0xef, 0x7a, 0x62, 0xcb, 0xae, 0x9f, 0x22, 0x47, 0x86, 0x87, 0xb0, 0x1c,
	0x3b, 0x84, 0xeb, 0xa0, 0x8d, 0xac, 0xab, 0x4e, 0x8f, 0x39, 0xd9, 0xa8, 0xf0, 0xdd, 0x57, 0x47,
	0xd6, 0x15, 0x77, 0x9a, 0x9d, 0x1d, 0xcb, 0x71, 0x1a, 0x4b, 0x3c, 0x5d, 0xd8, 0x27, 0xfa, 0x04,
	0x6a, 0x7d, 0xe2, 0xf9, 0xb4, 0x33, 0xb1, 0x3c, 0x3c, 0xa6, 0x0d, 0x95, 0x77, 0x55, 0xb9, 0xec,
	0x35, 0x17, 0x19, 0x3f, 0x84, 0xd5, 0x64, 0xc8, 0xa2, 0xec, 0x13, 0x5a, 0x14, 0xae, 0x45, 0x34,
	0x8c, 0x7f, 0x29, 0xb0, 0xc1, 0x87, 0x7f, 0x49, 0x2e, 0xb1, 0x37, 0x20, 0xe3, 0xc1, 0xf7, 0x10,
	0xea, 0xf7, 0x38, 0x21, 0x49, 0xc7, 0x97, 0x92, 0x8e, 0x9f, 0x96, 0xd4, 0x52, 0xbd, 0x7c, 0x5a,
	0x52, 0xcb, 0xf5, 0xca, 0x69, 0x49, 0xad, 0xd4, 0x97, 0x8c, 0x0e, 0x6c, 0xe6, 0x98, 0x29, 0xdd,
	0xdb, 0x04, 0x70, 0x70, 0x9f, 0x76, 0xe2, 0x3e, 0x6a, 0x4c, 0x22, 0x42, 0xb9, 0x05, 0x55, 0x8f,
	0x0c, 0x86, 0x41, 0xbf, 0x40, 0x58, 0xe0, 0x22, 0x3e, 0xc0, 0x78, 0xa7, 0x80, 0x16, 0xa6, 0x73,
	0x06, 0x40, 0xaf, 0x81, 0xea, 0xb9, 0x2e, 0xed, 0x44, 0xc9, 0xbc, 0xc4, 0xda, 0x2d, 0x91, 0xd0,
	0x29, 0x70, 0xd9, 0x95, 0x80, 0x51, 0xe2, 0x80, 0xb1, 0x9e, 0x02, 0x8c, 0x26, 0xff, 0x8d, 0xe1,
	0x44, 0x80, 0x00, 0xe5, 0x18, 0x02, 0x6c, 0x02, 0x88, 0x4c, 0xe0, 0x5a, 0x2b, 0x5c, 0xab, 0x26,
	0x24, 0x4c, 0xef, 0x3a, 0x68, 0x7d, 0xc7, 0x62, 0x67, 0x81, 0x0e, 0x79, 0x08, 0x6b, 0xa6, 0xca,
	0x04, 0xaf, 0x2d, 0x3a, 0x34, 0x3e, 0x07, 0x2d, 0x54, 0x11, 0x82, 0xc3, 0x47, 0x21, 0x38, 0x28,
	0x31, 0xf0, 0x28, 0x1a, 0xff, 0x50, 0xe0, 0xd1, 0x31, 0xa6, 0x81, 0x75, 0x04, 0xfb, 0x1f, 0x12,
	0x88, 0x37, 0x40, 0xf3, 0x70, 0x6f, 0xea, 0xf9, 0xe4, 0x52, 0x04, 0x4c, 0x35, 0x23, 0x01, 0x83,
	0x92, 0x79, 0xd3, 0x22, 0x28, 0xc1, 0x42, 0x34, 0x0f, 0x25, 0x11, 0x2e, 0x07, 0x23, 0x8c, 0x2e,
	0xd4, 0x5f, 0x11, 0x9f, 0x1e, 0x11, 0x67, 0x61, 0xce, 0x19, 0x9f, 0xc1, 0x4a, 0x4c, 0x47, 0x94,
	0x77, 0xcc, 0x4b, 0x61, 0x63, 0xcd, 0x14, 0x0d, 0xa3, 0x07, 0x2b, 0x47, 0x64, 0x6c, 0x4b, 0xc0,
	0x5b, 0x90, 0x3d, 0xbf, 0x02, 0x14, 0x57, 0x22, 0x0d, 0xfa, 0x0c, 0x2a, 0xe2, 0x0c, 0x49, 0x0d,
	0x19, 0x00, 0x2c, 0x07, 0x18, 0x1d, 0x78, 0xc2, 0x1c, 0x0a, 0xa0, 0x7c, 0xd6, 0x22, 0xf6, 0x7d,
	0x6c, 0x0d, 0xef, 0xc2, 0xa2, 0xcc, 0x2a, 0xe3, 0x18, 0x1a, 0x69, 0x05, 0x77, 0xb9, 0x29, 0xc6,
	0xb0, 0x9e, 0x58, 0xc8, 0xc4, 0xfd, 0x73, 0x6b, 0x84, 0xef, 0x63, 0xed, 0x3a, 0x3b, 0x96, 0xfd,
	0xce, 0xd8, 0x1a, 0x61, 0x9f, 0xdb, 0xcc, 0x43, 0xcb, 0x97, 0xf5, 0x8d, 0x5f, 0xc3, 0x46, 0xb6,
	0xbe, 0xbb, 0x18, 0xff, 0x4e, 0x81, 0x47, 0x6c, 0xa3, 0x5e, 0x3a, 0xce, 0x82, 0x2f, 0xba, 0x04,
	0xea, 0x16, 0xe7, 0xae, 0x1b, 0x46, 0x4c, 0xde, 0x90, 0x49, 0x40, 0x42, 0xd8, 0x37, 0xfa, 0x25,
	0x94, 0x5d, 0xcf, 0xc6, 0x1e, 0xc7, 0xa5, 0xe5, 0xfd, 0x67, 0x81, 0xee, 0x4c, 0x73, 0x9b, 0x2d,
	0x36, 0xd4, 0x14, 0x33, 0x8c, 0x17, 0x50, 0xe6, 0x6d, 0x86, 0x39, 0xe7, 0xad, 0xf3, 0x43, 0x89,
	0x3e, 0xad, 0xd7, 0x2d, 0x41, 0x52, 0xbe, 0x7c, 0xd9, 0x3e, 0xac, 0x17, 0x58, 0x7e, 0xcf, 0x2f,
	0x76, 0x97, 0x18, 0xfe, 0xb3, 0x18, 0x3f, 0xec, 0x0b, 0x0b, 0x60, 0x48, 0x1a, 0x45, 0xf0, 0x44,
	0x03, 0x3d, 0x86, 0x8a, 0xdb, 0xef, 0xfb, 0x98, 0xca, 0xd8, 0xc9, 0x56, 0x94, 0xfb, 0xe5, 0x58,
	0xee, 0xb3, 0xd1, 0x7d, 0xd7, 0x71, 0xdc, 0xb7, 0x1c, 0xd2, 0x55, 0x53, 0xb6, 0xd8, 0x1d, 0xc5,
	0x62, 0xde, 0x19, 0x61, 0x6f, 0x80, 0x7d, 0x79, 0xed, 0x03, 0x13, 0x9d, 0x71, 0x09, 0xbb, 0xfd,
	0x6d, 0xe2, 0x5b, 0x5d, 0x07, 0x77, 0xde, 0x5a, 0xce, 0x9b, 0xe0, 0xf6, 0x97, 0xb2, 0xaf, 0x2c,
	0xe7, 0x4d, 0xc4, 0x64, 0xb4, 0xdb, 0x33, 0x19, 0x78, 0x6f, 0x26, 0x23, 0x89, 0x49, 0x35, 0x9f,
	0x98, 0xd4, 0xd2, 0xc4, 0xe4, 0x00, 0x1e, 0x26, 0x36, 0xe8, 0x2e, 0xbb, 0x3c, 0x0c, 0x78, 0xe5,
	0x2b, 0x6b, 0x3c, 0x98, 0x5a, 0x83, 0xc5, 0x61, 0xf9, 0xff, 0xc2, 0x47, 0x55, 0x4c, 0x95, 0x34,
	0xf9, 0x08, 0x34, 0x27, 0x10, 0x4a, 0xa3, 0x77, 0x02, 0x55, 0x39, 0x73, 0x9a, 0x81, 0xc4, 0x8c,
	0xa6, 0xea, 0x7f, 0x01, 0x35, 0x10, 0xb3, 0xe4, 0x63, 0x48, 0x23, 0x29, 0x07, 0xff, 0x66, 0xc7,
	0x87, 0x3f, 0x6a, 0xb9, 0x71, 0x05, 0x53, 0x34, 0x04, 0x91, 0x73, 0x5c, 0x4f, 0x3e, 0xbd, 0x44,
	0x83, 0x71, 0x85, 0x3e, 0x71, 0xb0, 0x4c, 0x6d, 0x76, 0x0c, 0x3f, 0x36, 0x35, 0x26, 0x11, 0xb9,
	0xbd, 0x0a, 0xe5, 0xee, 0x8c, 0x62, 0x9f, 0xe7, 0x71, 0xc9, 0x14, 0x0d, 0x63, 0x0a, 0x0f, 0x4c,
	0xeb, 0xed, 0x81, 0x73, 0x4f, 0xa4, 0xbc, 0xe5, 0x85, 0x6f, 0x7c, 0x0a, 0xf5, 0x48, 0xad, 0x8c,
	0x69, 0xf0, 0xda, 0x51, 0x62, 0xaf, 0x9d, 0x3f, 0x43, 0xe3, 0x95, 0x15, 0x80, 0xec, 0x91, 0xeb,
	0x31, 0x62, 0xf3, 0x21, 0xed, 0x3c, 0x82, 0xb5, 0x0c, 0xfd, 0xb7, 0xbf, 0x46, 0xbf, 0x55, 0x60,
	0x93, 0xdd, 0x16, 0xd1, 0x62, 0xfe, 0x91, 0xeb, 0x31, 0x92, 0xf2, 0x7d, 0x7a, 0xa3, 0xdd, 0xe6,
	0xbd, 0x9b, 0x01, 0x5d, 0xe5, 0x38, 0x74, 0x19, 0xff, 0x55, 0xe0, 0x69, 0x9e, 0xcd, 0x32, 0x02,
	0xe7, 0xf3, 0x99, 0xfb, 0xd3, 0xc0, 0xe2, 0xeb, 0x27, 0x36, 0xc3, 0x80, 0x72, 0x69, 0xb0, 0x88,
	0x8e, 0xe1, 0xe3, 0x44, 0x4f, 0x2c, 0xc4, 0x85, 0x1b, 0x42, 0xcc, 0x8e, 0x3f, 0x73, 0xb2, 0x23,
	0x0e, 0x79, 0x89, 0xbb, 0xad, 0x31, 0xc9, 0x01, 0x13, 0x9c, 0x96, 0x54, 0xa5, 0x5e, 0x38, 0x2d,
	0xa9, 0xc5, 0x7a, 0xc9, 0xf8, 0x77, 0x98, 0xd9, 0xfe, 0xc1, 0xec, 0x0c, 0xfb, 0x3e, 0xcb, 0xca,
	0x05, 0x9d, 0xaa, 0x28, 0xba, 0xc5, 0xf9, 0x8b, 0x21, 0x63, 0x2f, 0xb2, 0x1e, 0x88, 0xab, 0x50,
	0xfe, 0x66, 0x8a, 0xbd, 0x99, 0xa4, 0xff, 0xa2, 0xc1, 0x78, 0x53, 0xda, 0x85, 0xbb, 0x00, 0x2a,
	0x81, 0xad, 0x23, 0xe2, 0x50, 0xec, 0x5d, 0x0c, 0x2d, 0xff, 0x2b, 0x42, 0x87, 0x17, 0x64, 0x30,
	0xb6, 0xe8, 0xd4, 0xc3, 0xf7, 0x7d, 0x01, 0xfa, 0x43, 0x2b, 0xa0, 0x4d, 0xfc, 0xdb, 0xf8, 0x39,
	0x6c, 0xe7, 0xab, 0x8a, 0x50, 0x80, 0xcf, 0x53, 0x62, 0xf3, 0x26, 0xb0, 0x79, 0x78, 0x45, 0x3d,
	0xab, 0x27, 0x8d, 0x0f, 0xa7, 0xdd, 0x93, 0xdc, 0xc9, 0xa7, 0x55, 0xf8, 0x9e, 0x53, 0x85, 0xe0,
	0xc4, 0x36, 0x3a, 0xf0, 0x34, 0x4f, 0xa3, 0xb4, 0x73, 0x03, 0x34, 0x3f, 0x10, 0x4a, 0xc8, 0x8a,
	0x04, 0xfc, 0x22, 0x27, 0x83, 0x31, 0xb6, 0x3b, 0x14, 0x5f, 0x51, 0x79, 0x28, 0x40, 0x88, 0xda,
	0xf8, 0x8a, 0x1a, 0x2e, 0xe8, 0xc7, 0x78, 0x7e, 0xf1, 0x7b, 0x05, 0x3c, 0x7a, 0x2a, 0x12, 0xdb,
	0x97, 0x0c, 0x5b, 0x0b, 0x1c, 0xf2, 0x8d, 0x19, 0xac, 0x67, 0x2a, 0x94, 0xee, 0x24, 0xa2, 0xa1,
	0x24, 0xa3, 0x91, 0xf4, 0xb5, 0x70, 0x83, 0xaf, 0xc5, 0x94, 0xaf, 0x23, 0x68, 0x84, 0xaa, 0xe5,
	0x51, 0x5d, 0xa4, 0xa7, 0x26, 0xac, 0x65, 0xa8, 0x7b, 0x1f, 0x3f, 0x1b, 0xb0, 0x34, 0x12, 0x13,
	0xa4, 0x97, 0x41, 0x73, 0xff, 0xff, 0x0f, 0x02, 0x64, 0xba, 0xc0, 0xde, 0x25, 0xe9, 0x61, 0xf4,
	0x7b, 0xa8, 0xcf, 0x97, 0x39, 0xd1, 0x56, 0x92, 0x02, 0xa4, 0x6a, 0xb1, 0xfa, 0x76, 0xfe, 0x00,
	0x61, 0x9f, 0xa1, 0xbd, 0xfb, 0xfb, 0x4e, 0x59, 0x2d, 0xe8, 0xca, 0x8f, 0xd1, 0x59, 0xbc, 0x1c,
	0xd1, 0xc8, 0x28, 0x38, 0x8a, 0x35, 0xd7, 0x72, 0x4b, 0x91, 0xb1, 0xc5, 0xf6, 0x14, 0xf4, 0x35,
	0x2c, 0x27, 0x0b, 0x72, 0x68, 0x33, 0x69, 0xcd, 0x5c, 0x65, 0x50, 0x7f, 0x9a, 0xd7, 0x9d, 0xb5,
	0x7a, 0x1b, 0x6a, 0xf1, 0x9a, 0x13, 0x5a, 0x8f, 0x26, 0xa7, 0x8a, 0x77, 0xfa, 0x46, 0x76, 0x67,
	0x3a, 0x04, 0xbc, 0x6a, 0x99, 0x51, 0xf3, 0x41, 0xcf, 0x13, 0x2b, 0xe4, 0x54, 0xae, 0xf4, 0x17,
	0x37, 0x8c, 0x4a, 0x2b, 0xfc, 0x1a, 0x96, 0x93, 0xa5, 0x86, 0x28, 0x48, 0x99, 0xd5, 0x91, 0x28,
	0x48, 0xd9, 0x15, 0x8a, 0x64, 0x90, 0xce, 0x40, 0x0b, 0xab, 0x03, 0xd1, 0x8e, 0xce, 0x17, 0x25,
	0xa2, 0x1d, 0x4d, 0x95, 0x12, 0x92, 0xcb, 0x9d, 0x03, 0x44, 0x74, 0x1a, 0xad, 0xc5, 0x1f, 0x66,
	0x89, 0xaa, 0x82, 0xae, 0x67, 0x75, 0xa5, 0x9d, 0xff, 0x0d, 0x54, 0x63, 0x7f, 0x55, 0x20, 0x3d,
	0xb9, 0xff, 0xf1, 0x7f, 0x49, 0xf4, 0xf5, 0xcc, 0xbe, 0xcc, 0x78, 0x26, 0x9f, 0x76, 0x51, 0x3c,
	0x33, 0xdf, 0x8f, 0x51, 0x3c, 0xb3, 0x5f, 0x84, 0xc9, 0x00, 0x5c, 0x40, 0x35, 0xf6, 0x9e, 0x40,
	0x19, 0x6e, 0xa6, 0x0d, 0xce, 0x78, 0x80, 0x24, 0x17, 0xfd, 0x1d, 0x3c, 0x98, 0x63, 0xf0, 0xe8,
	0x69, 0x2e, 0xb5, 0x17, 0x8b, 0x6f, 0xdd, 0x40, 0xfd, 0xe3, 0x11, 0x39, 0x05, 0x35, 0x60, 0xbe,
	0xe8, 0x49, 0x08, 0x74, 0x49, 0x0a, 0xae, 0x37, 0xd2, 0x1d, 0x59, 0xa6, 0xf6, 0x60, 0x25, 0xc5,
	0x4e, 0x51, 0x88, 0x31, 0x79, 0xc4, 0x59, 0xff, 0xe4, 0x9a, 0x11, 0x69, 0x83, 0x29, 0x3c, 0xce,
	0x26, 0x73, 0xe8, 0xc5, 0x4d, 0x64, 0x4f, 0xa8, 0xfb, 0xf4, 0xfd, 0x38, 0x61, 0xd2, 0xb5, 0x6e,
	0x00, 0xaf, 0x11, 0xbd, 0x99, 0x87, 0xd7, 0x14, 0x77, 0x9b, 0x87, 0xd7, 0x34, 0x33, 0x4a, 0xe9,
	0x98, 0x2f, 0x3d, 0x45, 0x3a, 0x72, 0xaa, 0x5e, 0x91, 0x8e, 0xbc, 0xaa, 0x55, 0x52, 0xc7, 0x18,
	0x56, 0xb3, 0xaa, 0x44, 0xe8, 0x59, 0xe6, 0x32, 0xc9, 0x9a, 0x95, 0xfe, 0xfc, 0xfa, 0x41, 0x59,
	0xfa, 0xfe, 0x04, 0x8d, 0x3c, 0x8a, 0x85, 0x7e, 0x10, 0xe5, 0xc0, 0xb5, 0x7c, 0x4f, 0xdf, 0xb9,
	0x79, 0x60, 0x4a, 0xf7, 0x8e, 0xb2, 0xa7, 0xa0, 0x37, 0xf0, 0x30, 0x83, 0x64, 0x20, 0x23, 0x06,
	0x92, 0x39, 0x94, 0x47, 0x7f, 0x76, 0xed, 0x98, 0x2c, 0x57, 0x31, 0xac, 0xa4, 0xee, 0xf9, 0xe8,
	0xf4, 0xe7, 0x31, 0x8e, 0xe8, 0xf4, 0xe7, 0x92, 0x84, 0x84, 0x9a, 0x83, 0xbd, 0xdf, 0xb2, 0x09,
	0x8e, 0xd5, 0x6d, 0xf6, 0xdc, 0xd1, 0xae, 0xf8, 0xfc, 0x91, 0xeb, 0x0d, 0x76, 0xc5, 0x32, 0xe2,
	0xff, 0xe5, 0xdd, 0x81, 0x2b, 0xdb, 0x93, 0x6e, 0xb7, 0xc2, 0x45, 0x3f, 0xf9, 0x2e, 0x00, 0x00,
	0xff, 0xff, 0x40, 0xb0, 0x08, 0x31, 0xa6, 0x1e, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// CommitServiceClient is the client API for CommitService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CommitServiceClient interface {
	CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error)
	TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (CommitService_TreeEntryClient, error)
	CommitsBetween(ctx context.Context, in *CommitsBetweenRequest, opts ...grpc.CallOption) (CommitService_CommitsBetweenClient, error)
	CountCommits(ctx context.Context, in *CountCommitsRequest, opts ...grpc.CallOption) (*CountCommitsResponse, error)
	CountDivergingCommits(ctx context.Context, in *CountDivergingCommitsRequest, opts ...grpc.CallOption) (*CountDivergingCommitsResponse, error)
	GetTreeEntries(ctx context.Context, in *GetTreeEntriesRequest, opts ...grpc.CallOption) (CommitService_GetTreeEntriesClient, error)
	ListFiles(ctx context.Context, in *ListFilesRequest, opts ...grpc.CallOption) (CommitService_ListFilesClient, error)
	FindCommit(ctx context.Context, in *FindCommitRequest, opts ...grpc.CallOption) (*FindCommitResponse, error)
	CommitStats(ctx context.Context, in *CommitStatsRequest, opts ...grpc.CallOption) (*CommitStatsResponse, error)
	// Use a stream to paginate the result set
	FindAllCommits(ctx context.Context, in *FindAllCommitsRequest, opts ...grpc.CallOption) (CommitService_FindAllCommitsClient, error)
	FindCommits(ctx context.Context, in *FindCommitsRequest, opts ...grpc.CallOption) (CommitService_FindCommitsClient, error)
	CommitLanguages(ctx context.Context, in *CommitLanguagesRequest, opts ...grpc.CallOption) (*CommitLanguagesResponse, error)
	RawBlame(ctx context.Context, in *RawBlameRequest, opts ...grpc.CallOption) (CommitService_RawBlameClient, error)
	LastCommitForPath(ctx context.Context, in *LastCommitForPathRequest, opts ...grpc.CallOption) (*LastCommitForPathResponse, error)
	ListLastCommitsForTree(ctx context.Context, in *ListLastCommitsForTreeRequest, opts ...grpc.CallOption) (CommitService_ListLastCommitsForTreeClient, error)
	CommitsByMessage(ctx context.Context, in *CommitsByMessageRequest, opts ...grpc.CallOption) (CommitService_CommitsByMessageClient, error)
	ListCommitsByOid(ctx context.Context, in *ListCommitsByOidRequest, opts ...grpc.CallOption) (CommitService_ListCommitsByOidClient, error)
	ListCommitsByRefName(ctx context.Context, in *ListCommitsByRefNameRequest, opts ...grpc.CallOption) (CommitService_ListCommitsByRefNameClient, error)
	FilterShasWithSignatures(ctx context.Context, opts ...grpc.CallOption) (CommitService_FilterShasWithSignaturesClient, error)
	GetCommitSignatures(ctx context.Context, in *GetCommitSignaturesRequest, opts ...grpc.CallOption) (CommitService_GetCommitSignaturesClient, error)
	GetCommitMessages(ctx context.Context, in *GetCommitMessagesRequest, opts ...grpc.CallOption) (CommitService_GetCommitMessagesClient, error)
}

type commitServiceClient struct {
	cc *grpc.ClientConn
}

func NewCommitServiceClient(cc *grpc.ClientConn) CommitServiceClient {
	return &commitServiceClient{cc}
}

func (c *commitServiceClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) {
	out := new(CommitIsAncestorResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/CommitIsAncestor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (CommitService_TreeEntryClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[0], "/gitaly.CommitService/TreeEntry", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceTreeEntryClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_TreeEntryClient interface {
	Recv() (*TreeEntryResponse, error)
	grpc.ClientStream
}

type commitServiceTreeEntryClient struct {
	grpc.ClientStream
}

func (x *commitServiceTreeEntryClient) Recv() (*TreeEntryResponse, error) {
	m := new(TreeEntryResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) CommitsBetween(ctx context.Context, in *CommitsBetweenRequest, opts ...grpc.CallOption) (CommitService_CommitsBetweenClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[1], "/gitaly.CommitService/CommitsBetween", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceCommitsBetweenClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_CommitsBetweenClient interface {
	Recv() (*CommitsBetweenResponse, error)
	grpc.ClientStream
}

type commitServiceCommitsBetweenClient struct {
	grpc.ClientStream
}

func (x *commitServiceCommitsBetweenClient) Recv() (*CommitsBetweenResponse, error) {
	m := new(CommitsBetweenResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) CountCommits(ctx context.Context, in *CountCommitsRequest, opts ...grpc.CallOption) (*CountCommitsResponse, error) {
	out := new(CountCommitsResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/CountCommits", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) CountDivergingCommits(ctx context.Context, in *CountDivergingCommitsRequest, opts ...grpc.CallOption) (*CountDivergingCommitsResponse, error) {
	out := new(CountDivergingCommitsResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/CountDivergingCommits", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) GetTreeEntries(ctx context.Context, in *GetTreeEntriesRequest, opts ...grpc.CallOption) (CommitService_GetTreeEntriesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[2], "/gitaly.CommitService/GetTreeEntries", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceGetTreeEntriesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_GetTreeEntriesClient interface {
	Recv() (*GetTreeEntriesResponse, error)
	grpc.ClientStream
}

type commitServiceGetTreeEntriesClient struct {
	grpc.ClientStream
}

func (x *commitServiceGetTreeEntriesClient) Recv() (*GetTreeEntriesResponse, error) {
	m := new(GetTreeEntriesResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) ListFiles(ctx context.Context, in *ListFilesRequest, opts ...grpc.CallOption) (CommitService_ListFilesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[3], "/gitaly.CommitService/ListFiles", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceListFilesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_ListFilesClient interface {
	Recv() (*ListFilesResponse, error)
	grpc.ClientStream
}

type commitServiceListFilesClient struct {
	grpc.ClientStream
}

func (x *commitServiceListFilesClient) Recv() (*ListFilesResponse, error) {
	m := new(ListFilesResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) FindCommit(ctx context.Context, in *FindCommitRequest, opts ...grpc.CallOption) (*FindCommitResponse, error) {
	out := new(FindCommitResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/FindCommit", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) CommitStats(ctx context.Context, in *CommitStatsRequest, opts ...grpc.CallOption) (*CommitStatsResponse, error) {
	out := new(CommitStatsResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/CommitStats", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) FindAllCommits(ctx context.Context, in *FindAllCommitsRequest, opts ...grpc.CallOption) (CommitService_FindAllCommitsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[4], "/gitaly.CommitService/FindAllCommits", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceFindAllCommitsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_FindAllCommitsClient interface {
	Recv() (*FindAllCommitsResponse, error)
	grpc.ClientStream
}

type commitServiceFindAllCommitsClient struct {
	grpc.ClientStream
}

func (x *commitServiceFindAllCommitsClient) Recv() (*FindAllCommitsResponse, error) {
	m := new(FindAllCommitsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) FindCommits(ctx context.Context, in *FindCommitsRequest, opts ...grpc.CallOption) (CommitService_FindCommitsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[5], "/gitaly.CommitService/FindCommits", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceFindCommitsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_FindCommitsClient interface {
	Recv() (*FindCommitsResponse, error)
	grpc.ClientStream
}

type commitServiceFindCommitsClient struct {
	grpc.ClientStream
}

func (x *commitServiceFindCommitsClient) Recv() (*FindCommitsResponse, error) {
	m := new(FindCommitsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) CommitLanguages(ctx context.Context, in *CommitLanguagesRequest, opts ...grpc.CallOption) (*CommitLanguagesResponse, error) {
	out := new(CommitLanguagesResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/CommitLanguages", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) RawBlame(ctx context.Context, in *RawBlameRequest, opts ...grpc.CallOption) (CommitService_RawBlameClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[6], "/gitaly.CommitService/RawBlame", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceRawBlameClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_RawBlameClient interface {
	Recv() (*RawBlameResponse, error)
	grpc.ClientStream
}

type commitServiceRawBlameClient struct {
	grpc.ClientStream
}

func (x *commitServiceRawBlameClient) Recv() (*RawBlameResponse, error) {
	m := new(RawBlameResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) LastCommitForPath(ctx context.Context, in *LastCommitForPathRequest, opts ...grpc.CallOption) (*LastCommitForPathResponse, error) {
	out := new(LastCommitForPathResponse)
	err := c.cc.Invoke(ctx, "/gitaly.CommitService/LastCommitForPath", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *commitServiceClient) ListLastCommitsForTree(ctx context.Context, in *ListLastCommitsForTreeRequest, opts ...grpc.CallOption) (CommitService_ListLastCommitsForTreeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[7], "/gitaly.CommitService/ListLastCommitsForTree", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceListLastCommitsForTreeClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_ListLastCommitsForTreeClient interface {
	Recv() (*ListLastCommitsForTreeResponse, error)
	grpc.ClientStream
}

type commitServiceListLastCommitsForTreeClient struct {
	grpc.ClientStream
}

func (x *commitServiceListLastCommitsForTreeClient) Recv() (*ListLastCommitsForTreeResponse, error) {
	m := new(ListLastCommitsForTreeResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) CommitsByMessage(ctx context.Context, in *CommitsByMessageRequest, opts ...grpc.CallOption) (CommitService_CommitsByMessageClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[8], "/gitaly.CommitService/CommitsByMessage", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceCommitsByMessageClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_CommitsByMessageClient interface {
	Recv() (*CommitsByMessageResponse, error)
	grpc.ClientStream
}

type commitServiceCommitsByMessageClient struct {
	grpc.ClientStream
}

func (x *commitServiceCommitsByMessageClient) Recv() (*CommitsByMessageResponse, error) {
	m := new(CommitsByMessageResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) ListCommitsByOid(ctx context.Context, in *ListCommitsByOidRequest, opts ...grpc.CallOption) (CommitService_ListCommitsByOidClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[9], "/gitaly.CommitService/ListCommitsByOid", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceListCommitsByOidClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_ListCommitsByOidClient interface {
	Recv() (*ListCommitsByOidResponse, error)
	grpc.ClientStream
}

type commitServiceListCommitsByOidClient struct {
	grpc.ClientStream
}

func (x *commitServiceListCommitsByOidClient) Recv() (*ListCommitsByOidResponse, error) {
	m := new(ListCommitsByOidResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) ListCommitsByRefName(ctx context.Context, in *ListCommitsByRefNameRequest, opts ...grpc.CallOption) (CommitService_ListCommitsByRefNameClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[10], "/gitaly.CommitService/ListCommitsByRefName", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceListCommitsByRefNameClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_ListCommitsByRefNameClient interface {
	Recv() (*ListCommitsByRefNameResponse, error)
	grpc.ClientStream
}

type commitServiceListCommitsByRefNameClient struct {
	grpc.ClientStream
}

func (x *commitServiceListCommitsByRefNameClient) Recv() (*ListCommitsByRefNameResponse, error) {
	m := new(ListCommitsByRefNameResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) FilterShasWithSignatures(ctx context.Context, opts ...grpc.CallOption) (CommitService_FilterShasWithSignaturesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[11], "/gitaly.CommitService/FilterShasWithSignatures", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceFilterShasWithSignaturesClient{stream}
	return x, nil
}

type CommitService_FilterShasWithSignaturesClient interface {
	Send(*FilterShasWithSignaturesRequest) error
	Recv() (*FilterShasWithSignaturesResponse, error)
	grpc.ClientStream
}

type commitServiceFilterShasWithSignaturesClient struct {
	grpc.ClientStream
}

func (x *commitServiceFilterShasWithSignaturesClient) Send(m *FilterShasWithSignaturesRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *commitServiceFilterShasWithSignaturesClient) Recv() (*FilterShasWithSignaturesResponse, error) {
	m := new(FilterShasWithSignaturesResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) GetCommitSignatures(ctx context.Context, in *GetCommitSignaturesRequest, opts ...grpc.CallOption) (CommitService_GetCommitSignaturesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[12], "/gitaly.CommitService/GetCommitSignatures", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceGetCommitSignaturesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_GetCommitSignaturesClient interface {
	Recv() (*GetCommitSignaturesResponse, error)
	grpc.ClientStream
}

type commitServiceGetCommitSignaturesClient struct {
	grpc.ClientStream
}

func (x *commitServiceGetCommitSignaturesClient) Recv() (*GetCommitSignaturesResponse, error) {
	m := new(GetCommitSignaturesResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *commitServiceClient) GetCommitMessages(ctx context.Context, in *GetCommitMessagesRequest, opts ...grpc.CallOption) (CommitService_GetCommitMessagesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_CommitService_serviceDesc.Streams[13], "/gitaly.CommitService/GetCommitMessages", opts...)
	if err != nil {
		return nil, err
	}
	x := &commitServiceGetCommitMessagesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type CommitService_GetCommitMessagesClient interface {
	Recv() (*GetCommitMessagesResponse, error)
	grpc.ClientStream
}

type commitServiceGetCommitMessagesClient struct {
	grpc.ClientStream
}

func (x *commitServiceGetCommitMessagesClient) Recv() (*GetCommitMessagesResponse, error) {
	m := new(GetCommitMessagesResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// CommitServiceServer is the server API for CommitService service.
type CommitServiceServer interface {
	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
	TreeEntry(*TreeEntryRequest, CommitService_TreeEntryServer) error
	CommitsBetween(*CommitsBetweenRequest, CommitService_CommitsBetweenServer) error
	CountCommits(context.Context, *CountCommitsRequest) (*CountCommitsResponse, error)
	CountDivergingCommits(context.Context, *CountDivergingCommitsRequest) (*CountDivergingCommitsResponse, error)
	GetTreeEntries(*GetTreeEntriesRequest, CommitService_GetTreeEntriesServer) error
	ListFiles(*ListFilesRequest, CommitService_ListFilesServer) error
	FindCommit(context.Context, *FindCommitRequest) (*FindCommitResponse, error)
	CommitStats(context.Context, *CommitStatsRequest) (*CommitStatsResponse, error)
	// Use a stream to paginate the result set
	FindAllCommits(*FindAllCommitsRequest, CommitService_FindAllCommitsServer) error
	FindCommits(*FindCommitsRequest, CommitService_FindCommitsServer) error
	CommitLanguages(context.Context, *CommitLanguagesRequest) (*CommitLanguagesResponse, error)
	RawBlame(*RawBlameRequest, CommitService_RawBlameServer) error
	LastCommitForPath(context.Context, *LastCommitForPathRequest) (*LastCommitForPathResponse, error)
	ListLastCommitsForTree(*ListLastCommitsForTreeRequest, CommitService_ListLastCommitsForTreeServer) error
	CommitsByMessage(*CommitsByMessageRequest, CommitService_CommitsByMessageServer) error
	ListCommitsByOid(*ListCommitsByOidRequest, CommitService_ListCommitsByOidServer) error
	ListCommitsByRefName(*ListCommitsByRefNameRequest, CommitService_ListCommitsByRefNameServer) error
	FilterShasWithSignatures(CommitService_FilterShasWithSignaturesServer) error
	GetCommitSignatures(*GetCommitSignaturesRequest, CommitService_GetCommitSignaturesServer) error
	GetCommitMessages(*GetCommitMessagesRequest, CommitService_GetCommitMessagesServer) error
}

// UnimplementedCommitServiceServer can be embedded to have forward compatible implementations.
type UnimplementedCommitServiceServer struct {
}

func (*UnimplementedCommitServiceServer) CommitIsAncestor(ctx context.Context, req *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CommitIsAncestor not implemented")
}
func (*UnimplementedCommitServiceServer) TreeEntry(req *TreeEntryRequest, srv CommitService_TreeEntryServer) error {
	return status.Errorf(codes.Unimplemented, "method TreeEntry not implemented")
}
func (*UnimplementedCommitServiceServer) CommitsBetween(req *CommitsBetweenRequest, srv CommitService_CommitsBetweenServer) error {
	return status.Errorf(codes.Unimplemented, "method CommitsBetween not implemented")
}
func (*UnimplementedCommitServiceServer) CountCommits(ctx context.Context, req *CountCommitsRequest) (*CountCommitsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CountCommits not implemented")
}
func (*UnimplementedCommitServiceServer) CountDivergingCommits(ctx context.Context, req *CountDivergingCommitsRequest) (*CountDivergingCommitsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CountDivergingCommits not implemented")
}
func (*UnimplementedCommitServiceServer) GetTreeEntries(req *GetTreeEntriesRequest, srv CommitService_GetTreeEntriesServer) error {
	return status.Errorf(codes.Unimplemented, "method GetTreeEntries not implemented")
}
func (*UnimplementedCommitServiceServer) ListFiles(req *ListFilesRequest, srv CommitService_ListFilesServer) error {
	return status.Errorf(codes.Unimplemented, "method ListFiles not implemented")
}
func (*UnimplementedCommitServiceServer) FindCommit(ctx context.Context, req *FindCommitRequest) (*FindCommitResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FindCommit not implemented")
}
func (*UnimplementedCommitServiceServer) CommitStats(ctx context.Context, req *CommitStatsRequest) (*CommitStatsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CommitStats not implemented")
}
func (*UnimplementedCommitServiceServer) FindAllCommits(req *FindAllCommitsRequest, srv CommitService_FindAllCommitsServer) error {
	return status.Errorf(codes.Unimplemented, "method FindAllCommits not implemented")
}
func (*UnimplementedCommitServiceServer) FindCommits(req *FindCommitsRequest, srv CommitService_FindCommitsServer) error {
	return status.Errorf(codes.Unimplemented, "method FindCommits not implemented")
}
func (*UnimplementedCommitServiceServer) CommitLanguages(ctx context.Context, req *CommitLanguagesRequest) (*CommitLanguagesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CommitLanguages not implemented")
}
func (*UnimplementedCommitServiceServer) RawBlame(req *RawBlameRequest, srv CommitService_RawBlameServer) error {
	return status.Errorf(codes.Unimplemented, "method RawBlame not implemented")
}
func (*UnimplementedCommitServiceServer) LastCommitForPath(ctx context.Context, req *LastCommitForPathRequest) (*LastCommitForPathResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LastCommitForPath not implemented")
}
func (*UnimplementedCommitServiceServer) ListLastCommitsForTree(req *ListLastCommitsForTreeRequest, srv CommitService_ListLastCommitsForTreeServer) error {
	return status.Errorf(codes.Unimplemented, "method ListLastCommitsForTree not implemented")
}
func (*UnimplementedCommitServiceServer) CommitsByMessage(req *CommitsByMessageRequest, srv CommitService_CommitsByMessageServer) error {
	return status.Errorf(codes.Unimplemented, "method CommitsByMessage not implemented")
}
func (*UnimplementedCommitServiceServer) ListCommitsByOid(req *ListCommitsByOidRequest, srv CommitService_ListCommitsByOidServer) error {
	return status.Errorf(codes.Unimplemented, "method ListCommitsByOid not implemented")
}
func (*UnimplementedCommitServiceServer) ListCommitsByRefName(req *ListCommitsByRefNameRequest, srv CommitService_ListCommitsByRefNameServer) error {
	return status.Errorf(codes.Unimplemented, "method ListCommitsByRefName not implemented")
}
func (*UnimplementedCommitServiceServer) FilterShasWithSignatures(srv CommitService_FilterShasWithSignaturesServer) error {
	return status.Errorf(codes.Unimplemented, "method FilterShasWithSignatures not implemented")
}
func (*UnimplementedCommitServiceServer) GetCommitSignatures(req *GetCommitSignaturesRequest, srv CommitService_GetCommitSignaturesServer) error {
	return status.Errorf(codes.Unimplemented, "method GetCommitSignatures not implemented")
}
func (*UnimplementedCommitServiceServer) GetCommitMessages(req *GetCommitMessagesRequest, srv CommitService_GetCommitMessagesServer) error {
	return status.Errorf(codes.Unimplemented, "method GetCommitMessages not implemented")
}

func RegisterCommitServiceServer(s *grpc.Server, srv CommitServiceServer) {
	s.RegisterService(&_CommitService_serviceDesc, srv)
}

func _CommitService_CommitIsAncestor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommitIsAncestorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).CommitIsAncestor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/CommitIsAncestor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_TreeEntry_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TreeEntryRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).TreeEntry(m, &commitServiceTreeEntryServer{stream})
}

type CommitService_TreeEntryServer interface {
	Send(*TreeEntryResponse) error
	grpc.ServerStream
}

type commitServiceTreeEntryServer struct {
	grpc.ServerStream
}

func (x *commitServiceTreeEntryServer) Send(m *TreeEntryResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_CommitsBetween_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CommitsBetweenRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).CommitsBetween(m, &commitServiceCommitsBetweenServer{stream})
}

type CommitService_CommitsBetweenServer interface {
	Send(*CommitsBetweenResponse) error
	grpc.ServerStream
}

type commitServiceCommitsBetweenServer struct {
	grpc.ServerStream
}

func (x *commitServiceCommitsBetweenServer) Send(m *CommitsBetweenResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_CountCommits_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CountCommitsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).CountCommits(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/CountCommits",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).CountCommits(ctx, req.(*CountCommitsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_CountDivergingCommits_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CountDivergingCommitsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).CountDivergingCommits(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/CountDivergingCommits",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).CountDivergingCommits(ctx, req.(*CountDivergingCommitsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_GetTreeEntries_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetTreeEntriesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).GetTreeEntries(m, &commitServiceGetTreeEntriesServer{stream})
}

type CommitService_GetTreeEntriesServer interface {
	Send(*GetTreeEntriesResponse) error
	grpc.ServerStream
}

type commitServiceGetTreeEntriesServer struct {
	grpc.ServerStream
}

func (x *commitServiceGetTreeEntriesServer) Send(m *GetTreeEntriesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_ListFiles_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListFilesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).ListFiles(m, &commitServiceListFilesServer{stream})
}

type CommitService_ListFilesServer interface {
	Send(*ListFilesResponse) error
	grpc.ServerStream
}

type commitServiceListFilesServer struct {
	grpc.ServerStream
}

func (x *commitServiceListFilesServer) Send(m *ListFilesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_FindCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FindCommitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).FindCommit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/FindCommit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).FindCommit(ctx, req.(*FindCommitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_CommitStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommitStatsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).CommitStats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/CommitStats",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).CommitStats(ctx, req.(*CommitStatsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_FindAllCommits_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(FindAllCommitsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).FindAllCommits(m, &commitServiceFindAllCommitsServer{stream})
}

type CommitService_FindAllCommitsServer interface {
	Send(*FindAllCommitsResponse) error
	grpc.ServerStream
}

type commitServiceFindAllCommitsServer struct {
	grpc.ServerStream
}

func (x *commitServiceFindAllCommitsServer) Send(m *FindAllCommitsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_FindCommits_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(FindCommitsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).FindCommits(m, &commitServiceFindCommitsServer{stream})
}

type CommitService_FindCommitsServer interface {
	Send(*FindCommitsResponse) error
	grpc.ServerStream
}

type commitServiceFindCommitsServer struct {
	grpc.ServerStream
}

func (x *commitServiceFindCommitsServer) Send(m *FindCommitsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_CommitLanguages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommitLanguagesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).CommitLanguages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/CommitLanguages",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).CommitLanguages(ctx, req.(*CommitLanguagesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_RawBlame_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RawBlameRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).RawBlame(m, &commitServiceRawBlameServer{stream})
}

type CommitService_RawBlameServer interface {
	Send(*RawBlameResponse) error
	grpc.ServerStream
}

type commitServiceRawBlameServer struct {
	grpc.ServerStream
}

func (x *commitServiceRawBlameServer) Send(m *RawBlameResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_LastCommitForPath_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LastCommitForPathRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CommitServiceServer).LastCommitForPath(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gitaly.CommitService/LastCommitForPath",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CommitServiceServer).LastCommitForPath(ctx, req.(*LastCommitForPathRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CommitService_ListLastCommitsForTree_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListLastCommitsForTreeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).ListLastCommitsForTree(m, &commitServiceListLastCommitsForTreeServer{stream})
}

type CommitService_ListLastCommitsForTreeServer interface {
	Send(*ListLastCommitsForTreeResponse) error
	grpc.ServerStream
}

type commitServiceListLastCommitsForTreeServer struct {
	grpc.ServerStream
}

func (x *commitServiceListLastCommitsForTreeServer) Send(m *ListLastCommitsForTreeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_CommitsByMessage_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CommitsByMessageRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).CommitsByMessage(m, &commitServiceCommitsByMessageServer{stream})
}

type CommitService_CommitsByMessageServer interface {
	Send(*CommitsByMessageResponse) error
	grpc.ServerStream
}

type commitServiceCommitsByMessageServer struct {
	grpc.ServerStream
}

func (x *commitServiceCommitsByMessageServer) Send(m *CommitsByMessageResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_ListCommitsByOid_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListCommitsByOidRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).ListCommitsByOid(m, &commitServiceListCommitsByOidServer{stream})
}

type CommitService_ListCommitsByOidServer interface {
	Send(*ListCommitsByOidResponse) error
	grpc.ServerStream
}

type commitServiceListCommitsByOidServer struct {
	grpc.ServerStream
}

func (x *commitServiceListCommitsByOidServer) Send(m *ListCommitsByOidResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_ListCommitsByRefName_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListCommitsByRefNameRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).ListCommitsByRefName(m, &commitServiceListCommitsByRefNameServer{stream})
}

type CommitService_ListCommitsByRefNameServer interface {
	Send(*ListCommitsByRefNameResponse) error
	grpc.ServerStream
}

type commitServiceListCommitsByRefNameServer struct {
	grpc.ServerStream
}

func (x *commitServiceListCommitsByRefNameServer) Send(m *ListCommitsByRefNameResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_FilterShasWithSignatures_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CommitServiceServer).FilterShasWithSignatures(&commitServiceFilterShasWithSignaturesServer{stream})
}

type CommitService_FilterShasWithSignaturesServer interface {
	Send(*FilterShasWithSignaturesResponse) error
	Recv() (*FilterShasWithSignaturesRequest, error)
	grpc.ServerStream
}

type commitServiceFilterShasWithSignaturesServer struct {
	grpc.ServerStream
}

func (x *commitServiceFilterShasWithSignaturesServer) Send(m *FilterShasWithSignaturesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *commitServiceFilterShasWithSignaturesServer) Recv() (*FilterShasWithSignaturesRequest, error) {
	m := new(FilterShasWithSignaturesRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _CommitService_GetCommitSignatures_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetCommitSignaturesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).GetCommitSignatures(m, &commitServiceGetCommitSignaturesServer{stream})
}

type CommitService_GetCommitSignaturesServer interface {
	Send(*GetCommitSignaturesResponse) error
	grpc.ServerStream
}

type commitServiceGetCommitSignaturesServer struct {
	grpc.ServerStream
}

func (x *commitServiceGetCommitSignaturesServer) Send(m *GetCommitSignaturesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _CommitService_GetCommitMessages_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetCommitMessagesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CommitServiceServer).GetCommitMessages(m, &commitServiceGetCommitMessagesServer{stream})
}

type CommitService_GetCommitMessagesServer interface {
	Send(*GetCommitMessagesResponse) error
	grpc.ServerStream
}

type commitServiceGetCommitMessagesServer struct {
	grpc.ServerStream
}

func (x *commitServiceGetCommitMessagesServer) Send(m *GetCommitMessagesResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _CommitService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gitaly.CommitService",
	HandlerType: (*CommitServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CommitIsAncestor",
			Handler:    _CommitService_CommitIsAncestor_Handler,
		},
		{
			MethodName: "CountCommits",
			Handler:    _CommitService_CountCommits_Handler,
		},
		{
			MethodName: "CountDivergingCommits",
			Handler:    _CommitService_CountDivergingCommits_Handler,
		},
		{
			MethodName: "FindCommit",
			Handler:    _CommitService_FindCommit_Handler,
		},
		{
			MethodName: "CommitStats",
			Handler:    _CommitService_CommitStats_Handler,
		},
		{
			MethodName: "CommitLanguages",
			Handler:    _CommitService_CommitLanguages_Handler,
		},
		{
			MethodName: "LastCommitForPath",
			Handler:    _CommitService_LastCommitForPath_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "TreeEntry",
			Handler:       _CommitService_TreeEntry_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CommitsBetween",
			Handler:       _CommitService_CommitsBetween_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetTreeEntries",
			Handler:       _CommitService_GetTreeEntries_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListFiles",
			Handler:       _CommitService_ListFiles_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "FindAllCommits",
			Handler:       _CommitService_FindAllCommits_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "FindCommits",
			Handler:       _CommitService_FindCommits_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RawBlame",
			Handler:       _CommitService_RawBlame_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListLastCommitsForTree",
			Handler:       _CommitService_ListLastCommitsForTree_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CommitsByMessage",
			Handler:       _CommitService_CommitsByMessage_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListCommitsByOid",
			Handler:       _CommitService_ListCommitsByOid_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListCommitsByRefName",
			Handler:       _CommitService_ListCommitsByRefName_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "FilterShasWithSignatures",
			Handler:       _CommitService_FilterShasWithSignatures_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "GetCommitSignatures",
			Handler:       _CommitService_GetCommitSignatures_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetCommitMessages",
			Handler:       _CommitService_GetCommitMessages_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "commit.proto",
}
