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

package gitalypb

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	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

type CommitDiffRequest struct {
	Repository             *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	LeftCommitId           string      `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
	RightCommitId          string      `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId,proto3" json:"right_commit_id,omitempty"`
	IgnoreWhitespaceChange bool        `protobuf:"varint,4,opt,name=ignore_whitespace_change,json=ignoreWhitespaceChange,proto3" json:"ignore_whitespace_change,omitempty"`
	Paths                  [][]byte    `protobuf:"bytes,5,rep,name=paths,proto3" json:"paths,omitempty"`
	CollapseDiffs          bool        `protobuf:"varint,6,opt,name=collapse_diffs,json=collapseDiffs,proto3" json:"collapse_diffs,omitempty"`
	EnforceLimits          bool        `protobuf:"varint,7,opt,name=enforce_limits,json=enforceLimits,proto3" json:"enforce_limits,omitempty"`
	// These limits are only enforced when enforce_limits == true.
	MaxFiles int32 `protobuf:"varint,8,opt,name=max_files,json=maxFiles,proto3" json:"max_files,omitempty"`
	MaxLines int32 `protobuf:"varint,9,opt,name=max_lines,json=maxLines,proto3" json:"max_lines,omitempty"`
	MaxBytes int32 `protobuf:"varint,10,opt,name=max_bytes,json=maxBytes,proto3" json:"max_bytes,omitempty"`
	// Limitation of a single diff patch,
	// patches surpassing this limit are pruned by default.
	// If this is 0 you will get back empty patches.
	MaxPatchBytes int32 `protobuf:"varint,14,opt,name=max_patch_bytes,json=maxPatchBytes,proto3" json:"max_patch_bytes,omitempty"`
	// These limits are only enforced if collapse_diffs == true.
	SafeMaxFiles         int32    `protobuf:"varint,11,opt,name=safe_max_files,json=safeMaxFiles,proto3" json:"safe_max_files,omitempty"`
	SafeMaxLines         int32    `protobuf:"varint,12,opt,name=safe_max_lines,json=safeMaxLines,proto3" json:"safe_max_lines,omitempty"`
	SafeMaxBytes         int32    `protobuf:"varint,13,opt,name=safe_max_bytes,json=safeMaxBytes,proto3" json:"safe_max_bytes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CommitDiffRequest proto.InternalMessageInfo

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

func (m *CommitDiffRequest) GetLeftCommitId() string {
	if m != nil {
		return m.LeftCommitId
	}
	return ""
}

func (m *CommitDiffRequest) GetRightCommitId() string {
	if m != nil {
		return m.RightCommitId
	}
	return ""
}

func (m *CommitDiffRequest) GetIgnoreWhitespaceChange() bool {
	if m != nil {
		return m.IgnoreWhitespaceChange
	}
	return false
}

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

func (m *CommitDiffRequest) GetCollapseDiffs() bool {
	if m != nil {
		return m.CollapseDiffs
	}
	return false
}

func (m *CommitDiffRequest) GetEnforceLimits() bool {
	if m != nil {
		return m.EnforceLimits
	}
	return false
}

func (m *CommitDiffRequest) GetMaxFiles() int32 {
	if m != nil {
		return m.MaxFiles
	}
	return 0
}

func (m *CommitDiffRequest) GetMaxLines() int32 {
	if m != nil {
		return m.MaxLines
	}
	return 0
}

func (m *CommitDiffRequest) GetMaxBytes() int32 {
	if m != nil {
		return m.MaxBytes
	}
	return 0
}

func (m *CommitDiffRequest) GetMaxPatchBytes() int32 {
	if m != nil {
		return m.MaxPatchBytes
	}
	return 0
}

func (m *CommitDiffRequest) GetSafeMaxFiles() int32 {
	if m != nil {
		return m.SafeMaxFiles
	}
	return 0
}

func (m *CommitDiffRequest) GetSafeMaxLines() int32 {
	if m != nil {
		return m.SafeMaxLines
	}
	return 0
}

func (m *CommitDiffRequest) GetSafeMaxBytes() int32 {
	if m != nil {
		return m.SafeMaxBytes
	}
	return 0
}

// A CommitDiffResponse corresponds to a single changed file in a commit.
type CommitDiffResponse struct {
	FromPath []byte `protobuf:"bytes,1,opt,name=from_path,json=fromPath,proto3" json:"from_path,omitempty"`
	ToPath   []byte `protobuf:"bytes,2,opt,name=to_path,json=toPath,proto3" json:"to_path,omitempty"`
	// Blob ID as returned via `git diff --full-index`
	FromId       string `protobuf:"bytes,3,opt,name=from_id,json=fromId,proto3" json:"from_id,omitempty"`
	ToId         string `protobuf:"bytes,4,opt,name=to_id,json=toId,proto3" json:"to_id,omitempty"`
	OldMode      int32  `protobuf:"varint,5,opt,name=old_mode,json=oldMode,proto3" json:"old_mode,omitempty"`
	NewMode      int32  `protobuf:"varint,6,opt,name=new_mode,json=newMode,proto3" json:"new_mode,omitempty"`
	Binary       bool   `protobuf:"varint,7,opt,name=binary,proto3" json:"binary,omitempty"`
	RawPatchData []byte `protobuf:"bytes,9,opt,name=raw_patch_data,json=rawPatchData,proto3" json:"raw_patch_data,omitempty"`
	EndOfPatch   bool   `protobuf:"varint,10,opt,name=end_of_patch,json=endOfPatch,proto3" json:"end_of_patch,omitempty"`
	// Indicates the diff file at which we overflow according to the limitations sent,
	// in which case only this attribute will be set.
	OverflowMarker bool `protobuf:"varint,11,opt,name=overflow_marker,json=overflowMarker,proto3" json:"overflow_marker,omitempty"`
	// Indicates the patch surpassed a "safe" limit and was therefore pruned, but
	// the client may still request the full patch on a separate request.
	Collapsed bool `protobuf:"varint,12,opt,name=collapsed,proto3" json:"collapsed,omitempty"`
	// Indicates the patch was pruned since it surpassed a hard limit, and can
	// therefore not be expanded.
	TooLarge             bool     `protobuf:"varint,13,opt,name=too_large,json=tooLarge,proto3" json:"too_large,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CommitDiffResponse proto.InternalMessageInfo

func (m *CommitDiffResponse) GetFromPath() []byte {
	if m != nil {
		return m.FromPath
	}
	return nil
}

func (m *CommitDiffResponse) GetToPath() []byte {
	if m != nil {
		return m.ToPath
	}
	return nil
}

func (m *CommitDiffResponse) GetFromId() string {
	if m != nil {
		return m.FromId
	}
	return ""
}

func (m *CommitDiffResponse) GetToId() string {
	if m != nil {
		return m.ToId
	}
	return ""
}

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

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

func (m *CommitDiffResponse) GetBinary() bool {
	if m != nil {
		return m.Binary
	}
	return false
}

func (m *CommitDiffResponse) GetRawPatchData() []byte {
	if m != nil {
		return m.RawPatchData
	}
	return nil
}

func (m *CommitDiffResponse) GetEndOfPatch() bool {
	if m != nil {
		return m.EndOfPatch
	}
	return false
}

func (m *CommitDiffResponse) GetOverflowMarker() bool {
	if m != nil {
		return m.OverflowMarker
	}
	return false
}

func (m *CommitDiffResponse) GetCollapsed() bool {
	if m != nil {
		return m.Collapsed
	}
	return false
}

func (m *CommitDiffResponse) GetTooLarge() bool {
	if m != nil {
		return m.TooLarge
	}
	return false
}

type CommitDeltaRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	LeftCommitId         string      `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
	RightCommitId        string      `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId,proto3" json:"right_commit_id,omitempty"`
	Paths                [][]byte    `protobuf:"bytes,4,rep,name=paths,proto3" json:"paths,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_CommitDeltaRequest proto.InternalMessageInfo

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

func (m *CommitDeltaRequest) GetLeftCommitId() string {
	if m != nil {
		return m.LeftCommitId
	}
	return ""
}

func (m *CommitDeltaRequest) GetRightCommitId() string {
	if m != nil {
		return m.RightCommitId
	}
	return ""
}

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

type CommitDelta struct {
	FromPath []byte `protobuf:"bytes,1,opt,name=from_path,json=fromPath,proto3" json:"from_path,omitempty"`
	ToPath   []byte `protobuf:"bytes,2,opt,name=to_path,json=toPath,proto3" json:"to_path,omitempty"`
	// Blob ID as returned via `git diff --full-index`
	FromId               string   `protobuf:"bytes,3,opt,name=from_id,json=fromId,proto3" json:"from_id,omitempty"`
	ToId                 string   `protobuf:"bytes,4,opt,name=to_id,json=toId,proto3" json:"to_id,omitempty"`
	OldMode              int32    `protobuf:"varint,5,opt,name=old_mode,json=oldMode,proto3" json:"old_mode,omitempty"`
	NewMode              int32    `protobuf:"varint,6,opt,name=new_mode,json=newMode,proto3" json:"new_mode,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CommitDelta proto.InternalMessageInfo

func (m *CommitDelta) GetFromPath() []byte {
	if m != nil {
		return m.FromPath
	}
	return nil
}

func (m *CommitDelta) GetToPath() []byte {
	if m != nil {
		return m.ToPath
	}
	return nil
}

func (m *CommitDelta) GetFromId() string {
	if m != nil {
		return m.FromId
	}
	return ""
}

func (m *CommitDelta) GetToId() string {
	if m != nil {
		return m.ToId
	}
	return ""
}

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

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

type CommitDeltaResponse struct {
	Deltas               []*CommitDelta `protobuf:"bytes,1,rep,name=deltas,proto3" json:"deltas,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_CommitDeltaResponse proto.InternalMessageInfo

func (m *CommitDeltaResponse) GetDeltas() []*CommitDelta {
	if m != nil {
		return m.Deltas
	}
	return nil
}

type RawDiffRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	LeftCommitId         string      `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
	RightCommitId        string      `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId,proto3" json:"right_commit_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_RawDiffRequest proto.InternalMessageInfo

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

func (m *RawDiffRequest) GetLeftCommitId() string {
	if m != nil {
		return m.LeftCommitId
	}
	return ""
}

func (m *RawDiffRequest) GetRightCommitId() string {
	if m != nil {
		return m.RightCommitId
	}
	return ""
}

type RawDiffResponse 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 *RawDiffResponse) Reset()         { *m = RawDiffResponse{} }
func (m *RawDiffResponse) String() string { return proto.CompactTextString(m) }
func (*RawDiffResponse) ProtoMessage()    {}
func (*RawDiffResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_686521effc814b25, []int{6}
}

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

var xxx_messageInfo_RawDiffResponse proto.InternalMessageInfo

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

type RawPatchRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	LeftCommitId         string      `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
	RightCommitId        string      `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId,proto3" json:"right_commit_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_RawPatchRequest proto.InternalMessageInfo

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

func (m *RawPatchRequest) GetLeftCommitId() string {
	if m != nil {
		return m.LeftCommitId
	}
	return ""
}

func (m *RawPatchRequest) GetRightCommitId() string {
	if m != nil {
		return m.RightCommitId
	}
	return ""
}

type RawPatchResponse 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 *RawPatchResponse) Reset()         { *m = RawPatchResponse{} }
func (m *RawPatchResponse) String() string { return proto.CompactTextString(m) }
func (*RawPatchResponse) ProtoMessage()    {}
func (*RawPatchResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_686521effc814b25, []int{8}
}

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

var xxx_messageInfo_RawPatchResponse proto.InternalMessageInfo

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

type DiffStatsRequest struct {
	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	LeftCommitId         string      `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
	RightCommitId        string      `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId,proto3" json:"right_commit_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_DiffStatsRequest proto.InternalMessageInfo

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

func (m *DiffStatsRequest) GetLeftCommitId() string {
	if m != nil {
		return m.LeftCommitId
	}
	return ""
}

func (m *DiffStatsRequest) GetRightCommitId() string {
	if m != nil {
		return m.RightCommitId
	}
	return ""
}

type DiffStats struct {
	Path                 []byte   `protobuf:"bytes,1,opt,name=path,proto3" json:"path,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 *DiffStats) Reset()         { *m = DiffStats{} }
func (m *DiffStats) String() string { return proto.CompactTextString(m) }
func (*DiffStats) ProtoMessage()    {}
func (*DiffStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_686521effc814b25, []int{10}
}

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

var xxx_messageInfo_DiffStats proto.InternalMessageInfo

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

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

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

type DiffStatsResponse struct {
	Stats                []*DiffStats `protobuf:"bytes,1,rep,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_DiffStatsResponse proto.InternalMessageInfo

func (m *DiffStatsResponse) GetStats() []*DiffStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

func init() {
	proto.RegisterType((*CommitDiffRequest)(nil), "gitaly.CommitDiffRequest")
	proto.RegisterType((*CommitDiffResponse)(nil), "gitaly.CommitDiffResponse")
	proto.RegisterType((*CommitDeltaRequest)(nil), "gitaly.CommitDeltaRequest")
	proto.RegisterType((*CommitDelta)(nil), "gitaly.CommitDelta")
	proto.RegisterType((*CommitDeltaResponse)(nil), "gitaly.CommitDeltaResponse")
	proto.RegisterType((*RawDiffRequest)(nil), "gitaly.RawDiffRequest")
	proto.RegisterType((*RawDiffResponse)(nil), "gitaly.RawDiffResponse")
	proto.RegisterType((*RawPatchRequest)(nil), "gitaly.RawPatchRequest")
	proto.RegisterType((*RawPatchResponse)(nil), "gitaly.RawPatchResponse")
	proto.RegisterType((*DiffStatsRequest)(nil), "gitaly.DiffStatsRequest")
	proto.RegisterType((*DiffStats)(nil), "gitaly.DiffStats")
	proto.RegisterType((*DiffStatsResponse)(nil), "gitaly.DiffStatsResponse")
}

func init() { proto.RegisterFile("diff.proto", fileDescriptor_686521effc814b25) }

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

// DiffServiceClient is the client API for DiffService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DiffServiceClient interface {
	// Returns stream of CommitDiffResponse with patches chunked over messages
	CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (DiffService_CommitDiffClient, error)
	// Return a stream so we can divide the response in chunks of deltas
	CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (DiffService_CommitDeltaClient, error)
	RawDiff(ctx context.Context, in *RawDiffRequest, opts ...grpc.CallOption) (DiffService_RawDiffClient, error)
	RawPatch(ctx context.Context, in *RawPatchRequest, opts ...grpc.CallOption) (DiffService_RawPatchClient, error)
	DiffStats(ctx context.Context, in *DiffStatsRequest, opts ...grpc.CallOption) (DiffService_DiffStatsClient, error)
}

type diffServiceClient struct {
	cc *grpc.ClientConn
}

func NewDiffServiceClient(cc *grpc.ClientConn) DiffServiceClient {
	return &diffServiceClient{cc}
}

func (c *diffServiceClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (DiffService_CommitDiffClient, error) {
	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[0], "/gitaly.DiffService/CommitDiff", opts...)
	if err != nil {
		return nil, err
	}
	x := &diffServiceCommitDiffClient{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 DiffService_CommitDiffClient interface {
	Recv() (*CommitDiffResponse, error)
	grpc.ClientStream
}

type diffServiceCommitDiffClient struct {
	grpc.ClientStream
}

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

func (c *diffServiceClient) CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (DiffService_CommitDeltaClient, error) {
	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[1], "/gitaly.DiffService/CommitDelta", opts...)
	if err != nil {
		return nil, err
	}
	x := &diffServiceCommitDeltaClient{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 DiffService_CommitDeltaClient interface {
	Recv() (*CommitDeltaResponse, error)
	grpc.ClientStream
}

type diffServiceCommitDeltaClient struct {
	grpc.ClientStream
}

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

func (c *diffServiceClient) RawDiff(ctx context.Context, in *RawDiffRequest, opts ...grpc.CallOption) (DiffService_RawDiffClient, error) {
	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[2], "/gitaly.DiffService/RawDiff", opts...)
	if err != nil {
		return nil, err
	}
	x := &diffServiceRawDiffClient{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 DiffService_RawDiffClient interface {
	Recv() (*RawDiffResponse, error)
	grpc.ClientStream
}

type diffServiceRawDiffClient struct {
	grpc.ClientStream
}

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

func (c *diffServiceClient) RawPatch(ctx context.Context, in *RawPatchRequest, opts ...grpc.CallOption) (DiffService_RawPatchClient, error) {
	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[3], "/gitaly.DiffService/RawPatch", opts...)
	if err != nil {
		return nil, err
	}
	x := &diffServiceRawPatchClient{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 DiffService_RawPatchClient interface {
	Recv() (*RawPatchResponse, error)
	grpc.ClientStream
}

type diffServiceRawPatchClient struct {
	grpc.ClientStream
}

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

func (c *diffServiceClient) DiffStats(ctx context.Context, in *DiffStatsRequest, opts ...grpc.CallOption) (DiffService_DiffStatsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_DiffService_serviceDesc.Streams[4], "/gitaly.DiffService/DiffStats", opts...)
	if err != nil {
		return nil, err
	}
	x := &diffServiceDiffStatsClient{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 DiffService_DiffStatsClient interface {
	Recv() (*DiffStatsResponse, error)
	grpc.ClientStream
}

type diffServiceDiffStatsClient struct {
	grpc.ClientStream
}

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

// DiffServiceServer is the server API for DiffService service.
type DiffServiceServer interface {
	// Returns stream of CommitDiffResponse with patches chunked over messages
	CommitDiff(*CommitDiffRequest, DiffService_CommitDiffServer) error
	// Return a stream so we can divide the response in chunks of deltas
	CommitDelta(*CommitDeltaRequest, DiffService_CommitDeltaServer) error
	RawDiff(*RawDiffRequest, DiffService_RawDiffServer) error
	RawPatch(*RawPatchRequest, DiffService_RawPatchServer) error
	DiffStats(*DiffStatsRequest, DiffService_DiffStatsServer) error
}

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

func (*UnimplementedDiffServiceServer) CommitDiff(req *CommitDiffRequest, srv DiffService_CommitDiffServer) error {
	return status.Errorf(codes.Unimplemented, "method CommitDiff not implemented")
}
func (*UnimplementedDiffServiceServer) CommitDelta(req *CommitDeltaRequest, srv DiffService_CommitDeltaServer) error {
	return status.Errorf(codes.Unimplemented, "method CommitDelta not implemented")
}
func (*UnimplementedDiffServiceServer) RawDiff(req *RawDiffRequest, srv DiffService_RawDiffServer) error {
	return status.Errorf(codes.Unimplemented, "method RawDiff not implemented")
}
func (*UnimplementedDiffServiceServer) RawPatch(req *RawPatchRequest, srv DiffService_RawPatchServer) error {
	return status.Errorf(codes.Unimplemented, "method RawPatch not implemented")
}
func (*UnimplementedDiffServiceServer) DiffStats(req *DiffStatsRequest, srv DiffService_DiffStatsServer) error {
	return status.Errorf(codes.Unimplemented, "method DiffStats not implemented")
}

func RegisterDiffServiceServer(s *grpc.Server, srv DiffServiceServer) {
	s.RegisterService(&_DiffService_serviceDesc, srv)
}

func _DiffService_CommitDiff_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CommitDiffRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DiffServiceServer).CommitDiff(m, &diffServiceCommitDiffServer{stream})
}

type DiffService_CommitDiffServer interface {
	Send(*CommitDiffResponse) error
	grpc.ServerStream
}

type diffServiceCommitDiffServer struct {
	grpc.ServerStream
}

func (x *diffServiceCommitDiffServer) Send(m *CommitDiffResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DiffService_CommitDelta_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CommitDeltaRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DiffServiceServer).CommitDelta(m, &diffServiceCommitDeltaServer{stream})
}

type DiffService_CommitDeltaServer interface {
	Send(*CommitDeltaResponse) error
	grpc.ServerStream
}

type diffServiceCommitDeltaServer struct {
	grpc.ServerStream
}

func (x *diffServiceCommitDeltaServer) Send(m *CommitDeltaResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DiffService_RawDiff_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RawDiffRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DiffServiceServer).RawDiff(m, &diffServiceRawDiffServer{stream})
}

type DiffService_RawDiffServer interface {
	Send(*RawDiffResponse) error
	grpc.ServerStream
}

type diffServiceRawDiffServer struct {
	grpc.ServerStream
}

func (x *diffServiceRawDiffServer) Send(m *RawDiffResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DiffService_RawPatch_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RawPatchRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DiffServiceServer).RawPatch(m, &diffServiceRawPatchServer{stream})
}

type DiffService_RawPatchServer interface {
	Send(*RawPatchResponse) error
	grpc.ServerStream
}

type diffServiceRawPatchServer struct {
	grpc.ServerStream
}

func (x *diffServiceRawPatchServer) Send(m *RawPatchResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DiffService_DiffStats_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DiffStatsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DiffServiceServer).DiffStats(m, &diffServiceDiffStatsServer{stream})
}

type DiffService_DiffStatsServer interface {
	Send(*DiffStatsResponse) error
	grpc.ServerStream
}

type diffServiceDiffStatsServer struct {
	grpc.ServerStream
}

func (x *diffServiceDiffStatsServer) Send(m *DiffStatsResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _DiffService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gitaly.DiffService",
	HandlerType: (*DiffServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "CommitDiff",
			Handler:       _DiffService_CommitDiff_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CommitDelta",
			Handler:       _DiffService_CommitDelta_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RawDiff",
			Handler:       _DiffService_RawDiff_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RawPatch",
			Handler:       _DiffService_RawPatch_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DiffStats",
			Handler:       _DiffService_DiffStats_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "diff.proto",
}
