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

package gitalypb

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

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

// DiffMode determines the type of diff that will be returned.
type CommitDiffRequest_DiffMode int32

const (
	// DEFAULT is the standard diff mode and results in a linewise diff for textfiles.
	CommitDiffRequest_DEFAULT CommitDiffRequest_DiffMode = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// WORDDIFF is a word diff and computes the diff for whitespace separated words instead of for whole lines.
	CommitDiffRequest_WORDDIFF CommitDiffRequest_DiffMode = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for CommitDiffRequest_DiffMode.
var (
	CommitDiffRequest_DiffMode_name = map[int32]string{
		0: "DEFAULT",
		1: "WORDDIFF",
	}
	CommitDiffRequest_DiffMode_value = map[string]int32{
		"DEFAULT":  0,
		"WORDDIFF": 1,
	}
)

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

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

func (CommitDiffRequest_DiffMode) Descriptor() protoreflect.EnumDescriptor {
	return file_diff_proto_enumTypes[0].Descriptor()
}

func (CommitDiffRequest_DiffMode) Type() protoreflect.EnumType {
	return &file_diff_proto_enumTypes[0]
}

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

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

// WhitespaceChanges states which whitespace changes we should ignore. These options correlate to
// the ones present in git-diff(1).
type CommitDiffRequest_WhitespaceChanges int32

const (
	// WHITESPACE_CHANGES_UNSPECIFIED is used to not ignore any whitespace changes.
	CommitDiffRequest_WHITESPACE_CHANGES_UNSPECIFIED CommitDiffRequest_WhitespaceChanges = 0
	// WHITESPACE_CHANGES_IGNORE specifies to use the `--ignore-space-change` flag of git-diff(1).
	// Only changes in amount of whitespace are ignored.
	CommitDiffRequest_WHITESPACE_CHANGES_IGNORE CommitDiffRequest_WhitespaceChanges = 1
	// WHITESPACE_CHANGES_IGNORE_ALL specifies to use the `--ignore-all-space` flag of git-diff(1).
	// all whitespace characters are ignored when comparing lines.
	CommitDiffRequest_WHITESPACE_CHANGES_IGNORE_ALL CommitDiffRequest_WhitespaceChanges = 2
)

// Enum value maps for CommitDiffRequest_WhitespaceChanges.
var (
	CommitDiffRequest_WhitespaceChanges_name = map[int32]string{
		0: "WHITESPACE_CHANGES_UNSPECIFIED",
		1: "WHITESPACE_CHANGES_IGNORE",
		2: "WHITESPACE_CHANGES_IGNORE_ALL",
	}
	CommitDiffRequest_WhitespaceChanges_value = map[string]int32{
		"WHITESPACE_CHANGES_UNSPECIFIED": 0,
		"WHITESPACE_CHANGES_IGNORE":      1,
		"WHITESPACE_CHANGES_IGNORE_ALL":  2,
	}
)

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

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

func (CommitDiffRequest_WhitespaceChanges) Descriptor() protoreflect.EnumDescriptor {
	return file_diff_proto_enumTypes[1].Descriptor()
}

func (CommitDiffRequest_WhitespaceChanges) Type() protoreflect.EnumType {
	return &file_diff_proto_enumTypes[1]
}

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

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

// MergeCommitDiffMode controls which mode to use to produce diff output for merge commits
type FindChangedPathsRequest_MergeCommitDiffMode int32

const (
	// MERGE_COMMIT_DIFF_MODE_UNSPECIFIED is the default value.
	// It is equivalent to DIFF_MODE_INCLUDE_MERGES.
	FindChangedPathsRequest_MERGE_COMMIT_DIFF_MODE_UNSPECIFIED FindChangedPathsRequest_MergeCommitDiffMode = 0
	// MERGE_COMMIT_DIFF_MODE_INCLUDE_MERGES tells git to also show differences for merge commits.
	// Please refer to the documentation of the `-m` flag of git-diff-tree(1).
	FindChangedPathsRequest_MERGE_COMMIT_DIFF_MODE_INCLUDE_MERGES FindChangedPathsRequest_MergeCommitDiffMode = 1
	// MERGE_COMMIT_DIFF_MODE_ALL_PARENTS tells git to only show differences for
	// files which were modified from all parents.
	// Please refer to the documentation of the `-c` flag of git-diff-tree(1).
	FindChangedPathsRequest_MERGE_COMMIT_DIFF_MODE_ALL_PARENTS FindChangedPathsRequest_MergeCommitDiffMode = 2
)

// Enum value maps for FindChangedPathsRequest_MergeCommitDiffMode.
var (
	FindChangedPathsRequest_MergeCommitDiffMode_name = map[int32]string{
		0: "MERGE_COMMIT_DIFF_MODE_UNSPECIFIED",
		1: "MERGE_COMMIT_DIFF_MODE_INCLUDE_MERGES",
		2: "MERGE_COMMIT_DIFF_MODE_ALL_PARENTS",
	}
	FindChangedPathsRequest_MergeCommitDiffMode_value = map[string]int32{
		"MERGE_COMMIT_DIFF_MODE_UNSPECIFIED":    0,
		"MERGE_COMMIT_DIFF_MODE_INCLUDE_MERGES": 1,
		"MERGE_COMMIT_DIFF_MODE_ALL_PARENTS":    2,
	}
)

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

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

func (FindChangedPathsRequest_MergeCommitDiffMode) Descriptor() protoreflect.EnumDescriptor {
	return file_diff_proto_enumTypes[2].Descriptor()
}

func (FindChangedPathsRequest_MergeCommitDiffMode) Type() protoreflect.EnumType {
	return &file_diff_proto_enumTypes[2]
}

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

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

// DiffStatus defines the possible status types for a diff. This is used to filter requested diffs.
type FindChangedPathsRequest_DiffStatus int32

const (
	// DIFF_STATUS_UNSPECIFIED indicates a file with unknown change type.
	FindChangedPathsRequest_DIFF_STATUS_UNSPECIFIED FindChangedPathsRequest_DiffStatus = 0
	// DIFF_STATUS_ADDED indicates a file was added.
	FindChangedPathsRequest_DIFF_STATUS_ADDED FindChangedPathsRequest_DiffStatus = 1
	// DIFF_STATUS_MODIFIED indicates a file was modified.
	FindChangedPathsRequest_DIFF_STATUS_MODIFIED FindChangedPathsRequest_DiffStatus = 2
	// DIFF_STATUS_DELETED indicates a file was deleted.
	FindChangedPathsRequest_DIFF_STATUS_DELETED FindChangedPathsRequest_DiffStatus = 3
	// DIFF_STATUS_TYPE_CHANGE indicates change in the type of the file (regular file, symbolic link or submodule).
	FindChangedPathsRequest_DIFF_STATUS_TYPE_CHANGE FindChangedPathsRequest_DiffStatus = 4
	// DIFF_STATUS_COPIED indicates Git determined the file was copied.
	FindChangedPathsRequest_DIFF_STATUS_COPIED FindChangedPathsRequest_DiffStatus = 5
	// DIFF_STATUS_RENAMED indicates Git determined the file was renamed.
	FindChangedPathsRequest_DIFF_STATUS_RENAMED FindChangedPathsRequest_DiffStatus = 6
)

// Enum value maps for FindChangedPathsRequest_DiffStatus.
var (
	FindChangedPathsRequest_DiffStatus_name = map[int32]string{
		0: "DIFF_STATUS_UNSPECIFIED",
		1: "DIFF_STATUS_ADDED",
		2: "DIFF_STATUS_MODIFIED",
		3: "DIFF_STATUS_DELETED",
		4: "DIFF_STATUS_TYPE_CHANGE",
		5: "DIFF_STATUS_COPIED",
		6: "DIFF_STATUS_RENAMED",
	}
	FindChangedPathsRequest_DiffStatus_value = map[string]int32{
		"DIFF_STATUS_UNSPECIFIED": 0,
		"DIFF_STATUS_ADDED":       1,
		"DIFF_STATUS_MODIFIED":    2,
		"DIFF_STATUS_DELETED":     3,
		"DIFF_STATUS_TYPE_CHANGE": 4,
		"DIFF_STATUS_COPIED":      5,
		"DIFF_STATUS_RENAMED":     6,
	}
)

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

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

func (FindChangedPathsRequest_DiffStatus) Descriptor() protoreflect.EnumDescriptor {
	return file_diff_proto_enumTypes[3].Descriptor()
}

func (FindChangedPathsRequest_DiffStatus) Type() protoreflect.EnumType {
	return &file_diff_proto_enumTypes[3]
}

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

// Deprecated: Use FindChangedPathsRequest_DiffStatus.Descriptor instead.
func (FindChangedPathsRequest_DiffStatus) EnumDescriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{12, 1}
}

// Status is an enum representing the type of change.
type ChangedPaths_Status int32

const (
	// ADDED indicates a file was added.
	ChangedPaths_ADDED ChangedPaths_Status = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// MODIFIED indicates a file was modified.
	ChangedPaths_MODIFIED ChangedPaths_Status = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// DELETED indicates a file was deleted.
	ChangedPaths_DELETED ChangedPaths_Status = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// TYPE_CHANGE indicates change in the type of the file (regular file, symbolic link or submodule).
	ChangedPaths_TYPE_CHANGE ChangedPaths_Status = 3 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// COPIED indicates Git determined the file was copied.
	ChangedPaths_COPIED ChangedPaths_Status = 4 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// RENAMED indicates Git determined the file was renamed.
	ChangedPaths_RENAMED ChangedPaths_Status = 5 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for ChangedPaths_Status.
var (
	ChangedPaths_Status_name = map[int32]string{
		0: "ADDED",
		1: "MODIFIED",
		2: "DELETED",
		3: "TYPE_CHANGE",
		4: "COPIED",
		5: "RENAMED",
	}
	ChangedPaths_Status_value = map[string]int32{
		"ADDED":       0,
		"MODIFIED":    1,
		"DELETED":     2,
		"TYPE_CHANGE": 3,
		"COPIED":      4,
		"RENAMED":     5,
	}
)

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

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

func (ChangedPaths_Status) Descriptor() protoreflect.EnumDescriptor {
	return file_diff_proto_enumTypes[4].Descriptor()
}

func (ChangedPaths_Status) Type() protoreflect.EnumType {
	return &file_diff_proto_enumTypes[4]
}

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

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

// Comparator is the comparison state of the two commits (= , > , < , !).
type RangeDiffResponse_Comparator int32

const (
	// COMPARATOR_EQUAL_UNSPECIFIED specifies =.
	RangeDiffResponse_COMPARATOR_EQUAL_UNSPECIFIED RangeDiffResponse_Comparator = 0
	// COMPARATOR_GREATER_THAN specifies >.
	RangeDiffResponse_COMPARATOR_GREATER_THAN RangeDiffResponse_Comparator = 1
	// COMPARATOR_LESS_THAN specifies <.
	RangeDiffResponse_COMPARATOR_LESS_THAN RangeDiffResponse_Comparator = 2
	// COMPARATOR_NOT_EQUAL specifies !.
	RangeDiffResponse_COMPARATOR_NOT_EQUAL RangeDiffResponse_Comparator = 3
)

// Enum value maps for RangeDiffResponse_Comparator.
var (
	RangeDiffResponse_Comparator_name = map[int32]string{
		0: "COMPARATOR_EQUAL_UNSPECIFIED",
		1: "COMPARATOR_GREATER_THAN",
		2: "COMPARATOR_LESS_THAN",
		3: "COMPARATOR_NOT_EQUAL",
	}
	RangeDiffResponse_Comparator_value = map[string]int32{
		"COMPARATOR_EQUAL_UNSPECIFIED": 0,
		"COMPARATOR_GREATER_THAN":      1,
		"COMPARATOR_LESS_THAN":         2,
		"COMPARATOR_NOT_EQUAL":         3,
	}
)

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

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

func (RangeDiffResponse_Comparator) Descriptor() protoreflect.EnumDescriptor {
	return file_diff_proto_enumTypes[5].Descriptor()
}

func (RangeDiffResponse_Comparator) Type() protoreflect.EnumType {
	return &file_diff_proto_enumTypes[5]
}

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

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

// DiffMode determines the type of diff that will be returned.
type DiffBlobsRequest_DiffMode int32

const (
	// DIFF_MODE_UNSPECIFIED is the standard diff mode and results in a line diff for text files.
	DiffBlobsRequest_DIFF_MODE_UNSPECIFIED DiffBlobsRequest_DiffMode = 0
	// DIFF_MODE_WORD is a word diff and computes the diff for whitespace separated words instead of
	// for whole lines by using the `--word-diff=porcelain` option.
	DiffBlobsRequest_DIFF_MODE_WORD DiffBlobsRequest_DiffMode = 1
)

// Enum value maps for DiffBlobsRequest_DiffMode.
var (
	DiffBlobsRequest_DiffMode_name = map[int32]string{
		0: "DIFF_MODE_UNSPECIFIED",
		1: "DIFF_MODE_WORD",
	}
	DiffBlobsRequest_DiffMode_value = map[string]int32{
		"DIFF_MODE_UNSPECIFIED": 0,
		"DIFF_MODE_WORD":        1,
	}
)

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

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

func (DiffBlobsRequest_DiffMode) Descriptor() protoreflect.EnumDescriptor {
	return file_diff_proto_enumTypes[6].Descriptor()
}

func (DiffBlobsRequest_DiffMode) Type() protoreflect.EnumType {
	return &file_diff_proto_enumTypes[6]
}

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

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

// WhitespaceChanges states which whitespace changes we should ignore. These options correlate to
// the ones present in git-diff(1).
type DiffBlobsRequest_WhitespaceChanges int32

const (
	// WHITESPACE_CHANGES_UNSPECIFIED is used to not ignore any whitespace changes.
	DiffBlobsRequest_WHITESPACE_CHANGES_UNSPECIFIED DiffBlobsRequest_WhitespaceChanges = 0
	// WHITESPACE_CHANGES_IGNORE specifies to use the `--ignore-space-change` flag of git-diff(1).
	// Only changes in amount of whitespace are ignored.
	DiffBlobsRequest_WHITESPACE_CHANGES_IGNORE DiffBlobsRequest_WhitespaceChanges = 1
	// WHITESPACE_CHANGES_IGNORE_ALL specifies to use the `--ignore-all-space` flag of git-diff(1).
	// all whitespace characters are ignored when comparing lines.
	DiffBlobsRequest_WHITESPACE_CHANGES_IGNORE_ALL DiffBlobsRequest_WhitespaceChanges = 2
)

// Enum value maps for DiffBlobsRequest_WhitespaceChanges.
var (
	DiffBlobsRequest_WhitespaceChanges_name = map[int32]string{
		0: "WHITESPACE_CHANGES_UNSPECIFIED",
		1: "WHITESPACE_CHANGES_IGNORE",
		2: "WHITESPACE_CHANGES_IGNORE_ALL",
	}
	DiffBlobsRequest_WhitespaceChanges_value = map[string]int32{
		"WHITESPACE_CHANGES_UNSPECIFIED": 0,
		"WHITESPACE_CHANGES_IGNORE":      1,
		"WHITESPACE_CHANGES_IGNORE_ALL":  2,
	}
)

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

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

func (DiffBlobsRequest_WhitespaceChanges) Descriptor() protoreflect.EnumDescriptor {
	return file_diff_proto_enumTypes[7].Descriptor()
}

func (DiffBlobsRequest_WhitespaceChanges) Type() protoreflect.EnumType {
	return &file_diff_proto_enumTypes[7]
}

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

// Deprecated: Use DiffBlobsRequest_WhitespaceChanges.Descriptor instead.
func (DiffBlobsRequest_WhitespaceChanges) EnumDescriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{24, 1}
}

// Status defines the state of a patch at a given response message.
type DiffBlobsResponse_Status int32

const (
	// STATUS_INCOMPLETE indicates the patch has not been completely transmitted. Subsequent
	// response messages contain the remaining content of the patch.
	DiffBlobsResponse_STATUS_INCOMPLETE DiffBlobsResponse_Status = 0 // protolint:disable:this ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// STATUS_END_OF_PATCH indicates the patch was completely parsed and sent. Subsequent response
	// messages contain the content of the next patch in the diff.
	DiffBlobsResponse_STATUS_END_OF_PATCH DiffBlobsResponse_Status = 1
)

// Enum value maps for DiffBlobsResponse_Status.
var (
	DiffBlobsResponse_Status_name = map[int32]string{
		0: "STATUS_INCOMPLETE",
		1: "STATUS_END_OF_PATCH",
	}
	DiffBlobsResponse_Status_value = map[string]int32{
		"STATUS_INCOMPLETE":   0,
		"STATUS_END_OF_PATCH": 1,
	}
)

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

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

func (DiffBlobsResponse_Status) Descriptor() protoreflect.EnumDescriptor {
	return file_diff_proto_enumTypes[8].Descriptor()
}

func (DiffBlobsResponse_Status) Type() protoreflect.EnumType {
	return &file_diff_proto_enumTypes[8]
}

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

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

// CommitDiffRequest is a request for the CommitDiff RPC.
type CommitDiffRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the one from which to get the diff.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// left_commit_id is the left commit ID in <left commit>..<right commit>.
	LeftCommitId string `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
	// right_commit_id is the right commit ID in <left commit>..<right commit>.
	RightCommitId string `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId,proto3" json:"right_commit_id,omitempty"`
	// paths is a list of paths that limits the diff to those specific paths.
	Paths [][]byte `protobuf:"bytes,5,rep,name=paths,proto3" json:"paths,omitempty"`
	// collapse_diffs causes patches to be emptied after safe_max_files,
	// safe_max_files, or safe_max_lines is reached.
	CollapseDiffs bool `protobuf:"varint,6,opt,name=collapse_diffs,json=collapseDiffs,proto3" json:"collapse_diffs,omitempty"`
	// enforce_limits causes parsing of diffs to stop if max_files, max_lines,
	// or max_bytes is reached.
	EnforceLimits bool `protobuf:"varint,7,opt,name=enforce_limits,json=enforceLimits,proto3" json:"enforce_limits,omitempty"`
	// max_files is the maximum number of files in a diff. Once reached, parsing is stopped
	// if enforce_limits is true.
	MaxFiles int32 `protobuf:"varint,8,opt,name=max_files,json=maxFiles,proto3" json:"max_files,omitempty"`
	// max_lines is the maximum number of lines in a diff. Once reached, parsing is stopped
	// if enforce_limits is true.
	MaxLines int32 `protobuf:"varint,9,opt,name=max_lines,json=maxLines,proto3" json:"max_lines,omitempty"`
	// max_bytes is the maximum number of bytes in a diff. Once reached, parsing is stopped
	// if enforce_limits is true.
	MaxBytes int32 `protobuf:"varint,10,opt,name=max_bytes,json=maxBytes,proto3" json:"max_bytes,omitempty"`
	// safe_max_files is the maximum number of files in a diff. Once reached, patches are emptied if
	// collapse_diffs is true.
	SafeMaxFiles int32 `protobuf:"varint,11,opt,name=safe_max_files,json=safeMaxFiles,proto3" json:"safe_max_files,omitempty"`
	// safe_max_lines is the maximum number of lines in a diff. Once reached, patches are emptied if
	// collapse_diffs is true.
	SafeMaxLines int32 `protobuf:"varint,12,opt,name=safe_max_lines,json=safeMaxLines,proto3" json:"safe_max_lines,omitempty"`
	// safe_max_bytes is the maximum number of bytes in a diff. Once reached, patches are emptied if
	// collapse_diffs is true.
	SafeMaxBytes int32 `protobuf:"varint,13,opt,name=safe_max_bytes,json=safeMaxBytes,proto3" json:"safe_max_bytes,omitempty"`
	// max_patch_bytes is the 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"`
	// diff_mode is the mode used for generating the diff. Please refer to the enum declaration for supported modes.
	DiffMode CommitDiffRequest_DiffMode `protobuf:"varint,15,opt,name=diff_mode,json=diffMode,proto3,enum=gitaly.CommitDiffRequest_DiffMode" json:"diff_mode,omitempty"`
	// max_patch_bytes_for_file_extension is a map of file extension to max patch bytes for
	// that extension. It overrides max patch bytes for file extension. If the file does not
	// have an extension (eg Dockerfile), then the file name is used for matching.
	// For files with more than on extension (eg file.html.tmpl) only the last extension is matched.
	MaxPatchBytesForFileExtension map[string]int32 `protobuf:"bytes,16,rep,name=max_patch_bytes_for_file_extension,json=maxPatchBytesForFileExtension,proto3" json:"max_patch_bytes_for_file_extension,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	// whitespace_changes states which whitespace changes should be included in the diff.
	// Please refer to the enum declaration for supported modes.
	WhitespaceChanges CommitDiffRequest_WhitespaceChanges `protobuf:"varint,17,opt,name=whitespace_changes,json=whitespaceChanges,proto3,enum=gitaly.CommitDiffRequest_WhitespaceChanges" json:"whitespace_changes,omitempty"`
	// collect_all_paths can be set when you want to get back all files,
	// even when the enforced limits are hit. Responses sent when the limits
	// were hit will have the path filled in, have the `overflow_marker` set,
	// but have no patch data.
	CollectAllPaths bool `protobuf:"varint,18,opt,name=collect_all_paths,json=collectAllPaths,proto3" json:"collect_all_paths,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*CommitDiffRequest) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (x *CommitDiffRequest) GetDiffMode() CommitDiffRequest_DiffMode {
	if x != nil {
		return x.DiffMode
	}
	return CommitDiffRequest_DEFAULT
}

func (x *CommitDiffRequest) GetMaxPatchBytesForFileExtension() map[string]int32 {
	if x != nil {
		return x.MaxPatchBytesForFileExtension
	}
	return nil
}

func (x *CommitDiffRequest) GetWhitespaceChanges() CommitDiffRequest_WhitespaceChanges {
	if x != nil {
		return x.WhitespaceChanges
	}
	return CommitDiffRequest_WHITESPACE_CHANGES_UNSPECIFIED
}

func (x *CommitDiffRequest) GetCollectAllPaths() bool {
	if x != nil {
		return x.CollectAllPaths
	}
	return false
}

// CommitDiffResponse corresponds to a single changed file in a commit.
type CommitDiffResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// from_path is the path that to_path is getting compared to.
	FromPath []byte `protobuf:"bytes,1,opt,name=from_path,json=fromPath,proto3" json:"from_path,omitempty"`
	// to_path is the path that from_path is getting compared against.
	ToPath []byte `protobuf:"bytes,2,opt,name=to_path,json=toPath,proto3" json:"to_path,omitempty"`
	// from_id is the id of the blob that is getting compared against.
	FromId string `protobuf:"bytes,3,opt,name=from_id,json=fromId,proto3" json:"from_id,omitempty"`
	// to_id is the id of the blob that is getting compared to.
	ToId string `protobuf:"bytes,4,opt,name=to_id,json=toId,proto3" json:"to_id,omitempty"`
	// old_mode is the mode of the file getting compared against.
	OldMode int32 `protobuf:"varint,5,opt,name=old_mode,json=oldMode,proto3" json:"old_mode,omitempty"`
	// new_mode is the mode of the file getting compared to.
	NewMode int32 `protobuf:"varint,6,opt,name=new_mode,json=newMode,proto3" json:"new_mode,omitempty"`
	// binary indicates whether or not binary data is getting compared.
	Binary bool `protobuf:"varint,7,opt,name=binary,proto3" json:"binary,omitempty"`
	// raw_patch_data is the unparsed data of the diff.
	RawPatchData []byte `protobuf:"bytes,9,opt,name=raw_patch_data,json=rawPatchData,proto3" json:"raw_patch_data,omitempty"`
	// end_of_patch indicates if this message represents the end of the diff.
	EndOfPatch bool `protobuf:"varint,10,opt,name=end_of_patch,json=endOfPatch,proto3" json:"end_of_patch,omitempty"`
	// overflow_marker Indicates if the diff file exceeded limitations, in which case
	// there will be no patch data sent, only information about the patch.
	OverflowMarker bool `protobuf:"varint,11,opt,name=overflow_marker,json=overflowMarker,proto3" json:"overflow_marker,omitempty"`
	// collapsed 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"`
	// too_large 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"`
	// lines_added is the number of lines added in the diff. This count always represents the
	// full diff, even when it is pruned.
	LinesAdded int32 `protobuf:"varint,14,opt,name=lines_added,json=linesAdded,proto3" json:"lines_added,omitempty"`
	// lines_removed is the number of lines removed in the diff. This count always represents the
	// full diff, even when it is pruned.
	LinesRemoved  int32 `protobuf:"varint,15,opt,name=lines_removed,json=linesRemoved,proto3" json:"lines_removed,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitDiffResponse) ProtoMessage() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (x *CommitDiffResponse) GetLinesAdded() int32 {
	if x != nil {
		return x.LinesAdded
	}
	return 0
}

func (x *CommitDiffResponse) GetLinesRemoved() int32 {
	if x != nil {
		return x.LinesRemoved
	}
	return 0
}

// CommitDeltaRequest is a request for the CommitDelta RPC.
type CommitDeltaRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the one to get the commit deltas from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// left_commit_id is the left commit ID in <left commit>..<right commit>.
	LeftCommitId string `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
	// right_commit_id is the right commit ID in <left commit>..<right commit>.
	RightCommitId string `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId,proto3" json:"right_commit_id,omitempty"`
	// paths is a list of paths that limits the diff to those specific paths.
	Paths         [][]byte `protobuf:"bytes,4,rep,name=paths,proto3" json:"paths,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitDeltaRequest) ProtoMessage() {}

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

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

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

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

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

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

// CommitDelta represents the metadata of a diff between two commits without the actual
// patch data.
type CommitDelta struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// from_path is the path that to_path is getting compared to.
	FromPath []byte `protobuf:"bytes,1,opt,name=from_path,json=fromPath,proto3" json:"from_path,omitempty"`
	// to_path is the path that from_path is getting compared against.
	ToPath []byte `protobuf:"bytes,2,opt,name=to_path,json=toPath,proto3" json:"to_path,omitempty"`
	// from_id is the id of the blob that is getting compared to.
	FromId string `protobuf:"bytes,3,opt,name=from_id,json=fromId,proto3" json:"from_id,omitempty"`
	// to_id is the id of the blob that is getting compared against.
	ToId string `protobuf:"bytes,4,opt,name=to_id,json=toId,proto3" json:"to_id,omitempty"`
	// old_mode is the mode of the blob getting compared against.
	OldMode int32 `protobuf:"varint,5,opt,name=old_mode,json=oldMode,proto3" json:"old_mode,omitempty"`
	// new_mode is the mode of the blob getting compared to.
	NewMode       int32 `protobuf:"varint,6,opt,name=new_mode,json=newMode,proto3" json:"new_mode,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitDelta) ProtoMessage() {}

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

// Deprecated: Use CommitDelta.ProtoReflect.Descriptor instead.
func (*CommitDelta) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{3}
}

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

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

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

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

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

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

// CommitDeltaResponse is the response from a CommitDelta RPC call.
type CommitDeltaResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// deltas is a list of CommitDeltas
	Deltas        []*CommitDelta `protobuf:"bytes,1,rep,name=deltas,proto3" json:"deltas,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CommitDeltaResponse) ProtoMessage() {}

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

// Deprecated: Use CommitDeltaResponse.ProtoReflect.Descriptor instead.
func (*CommitDeltaResponse) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{4}
}

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

// RawDiffRequest is a request for the RawDiff RPC.
type RawDiffRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the one to get the diff from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// left_commit_id is the left commit ID in <left commit>..<right commit>.
	LeftCommitId string `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
	// right_commit_id is the right commit ID in <left commit>..<right commit>.
	RightCommitId string `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId,proto3" json:"right_commit_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RawDiffRequest) ProtoMessage() {}

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

// Deprecated: Use RawDiffRequest.ProtoReflect.Descriptor instead.
func (*RawDiffRequest) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{5}
}

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

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

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

// RawDiffResponse is a response for the RawDiff RPC.
type RawDiffResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data is a sequence of bytes representing the unmodified diff patch data
	// returned from git-diff(1).
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RawDiffResponse) ProtoMessage() {}

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

// Deprecated: Use RawDiffResponse.ProtoReflect.Descriptor instead.
func (*RawDiffResponse) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{6}
}

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

// RawPatchRequest is a request for the RawPatch RPC.
type RawPatchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the one to get the patch from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// left_commit_id is the left commit ID in <left commit>..<right commit>.
	LeftCommitId string `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
	// right_commit_id is the right commit ID in <left commit>..<right commit>
	RightCommitId string `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId,proto3" json:"right_commit_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RawPatchRequest) ProtoMessage() {}

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

// Deprecated: Use RawPatchRequest.ProtoReflect.Descriptor instead.
func (*RawPatchRequest) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{7}
}

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

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

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

// RawPatchResponse is a response for the RawPatch RPC.
type RawPatchResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data is a sequence of bytes representing the unmodified diff patch data
	// returned from git-format-patch(1).
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RawPatchResponse) ProtoMessage() {}

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

// Deprecated: Use RawPatchResponse.ProtoReflect.Descriptor instead.
func (*RawPatchResponse) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{8}
}

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

// DiffStatsRequest is a request for the DiffStats RPC.
type DiffStatsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the one to get diff stats from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// left_commit_id is the left commit ID in <left commit>..<right commit>
	LeftCommitId string `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId,proto3" json:"left_commit_id,omitempty"`
	// right_commit_id is the right commit ID in <left commit>..<right commit>
	RightCommitId string `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId,proto3" json:"right_commit_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DiffStatsRequest) ProtoMessage() {}

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

// Deprecated: Use DiffStatsRequest.ProtoReflect.Descriptor instead.
func (*DiffStatsRequest) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{9}
}

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

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

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

// DiffStats represents diff statistics for a path.
type DiffStats struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// path is the path of the change.
	Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// additions is the number of additions in a diff.
	Additions int32 `protobuf:"varint,2,opt,name=additions,proto3" json:"additions,omitempty"`
	// deletions is the number of deletions in a diff.
	Deletions int32 `protobuf:"varint,3,opt,name=deletions,proto3" json:"deletions,omitempty"`
	// old_path is the original path in the event of a rename.
	OldPath       []byte `protobuf:"bytes,4,opt,name=old_path,json=oldPath,proto3" json:"old_path,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DiffStats) ProtoMessage() {}

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

// Deprecated: Use DiffStats.ProtoReflect.Descriptor instead.
func (*DiffStats) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{10}
}

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

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

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

func (x *DiffStats) GetOldPath() []byte {
	if x != nil {
		return x.OldPath
	}
	return nil
}

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

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

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

func (*DiffStatsResponse) ProtoMessage() {}

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

// Deprecated: Use DiffStatsResponse.ProtoReflect.Descriptor instead.
func (*DiffStatsResponse) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{11}
}

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

// FindChangedPathsRequest is the request for the FindChangedPaths RPC.
// Given a list of commits, return the files changed. Each commit is compared
// to its parent. Merge commits will show files which are different to all of
// its parents.
type FindChangedPathsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository the changed paths are computed in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// commits is the list of commits to compare to their parents. This field is deprecated. To adapt to the new calling
	// convention you can create one `CommitRequest` per commit, where each `CommitRequest` has only the `commit_revision`
	// field.
	//
	// Deprecated: Marked as deprecated in diff.proto.
	Commits []string `protobuf:"bytes,2,rep,name=commits,proto3" json:"commits,omitempty"`
	// requests specifies the requests of what to compare.
	// if all requests are of type CommitRequest, the associated commit_id will be
	// returned in the ChangedPaths messages.
	Requests []*FindChangedPathsRequest_Request `protobuf:"bytes,3,rep,name=requests,proto3" json:"requests,omitempty"`
	// merge_commit_diff_mode controls how merge commits are treated.
	MergeCommitDiffMode FindChangedPathsRequest_MergeCommitDiffMode `protobuf:"varint,4,opt,name=merge_commit_diff_mode,json=mergeCommitDiffMode,proto3,enum=gitaly.FindChangedPathsRequest_MergeCommitDiffMode" json:"merge_commit_diff_mode,omitempty"`
	// find_renames toggles rename detection on the files in the diff.
	FindRenames bool `protobuf:"varint,5,opt,name=find_renames,json=findRenames,proto3" json:"find_renames,omitempty"`
	// diff_filters allows the underlying git-diff-tree(1) to be configured with a specific
	// --diff-filter flag to filter output for specific diff statuses. When not specified, the
	// default is "AMDTCR".
	DiffFilters   []FindChangedPathsRequest_DiffStatus `protobuf:"varint,6,rep,packed,name=diff_filters,json=diffFilters,proto3,enum=gitaly.FindChangedPathsRequest_DiffStatus" json:"diff_filters,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindChangedPathsRequest) ProtoMessage() {}

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

// Deprecated: Use FindChangedPathsRequest.ProtoReflect.Descriptor instead.
func (*FindChangedPathsRequest) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{12}
}

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

// Deprecated: Marked as deprecated in diff.proto.
func (x *FindChangedPathsRequest) GetCommits() []string {
	if x != nil {
		return x.Commits
	}
	return nil
}

func (x *FindChangedPathsRequest) GetRequests() []*FindChangedPathsRequest_Request {
	if x != nil {
		return x.Requests
	}
	return nil
}

func (x *FindChangedPathsRequest) GetMergeCommitDiffMode() FindChangedPathsRequest_MergeCommitDiffMode {
	if x != nil {
		return x.MergeCommitDiffMode
	}
	return FindChangedPathsRequest_MERGE_COMMIT_DIFF_MODE_UNSPECIFIED
}

func (x *FindChangedPathsRequest) GetFindRenames() bool {
	if x != nil {
		return x.FindRenames
	}
	return false
}

func (x *FindChangedPathsRequest) GetDiffFilters() []FindChangedPathsRequest_DiffStatus {
	if x != nil {
		return x.DiffFilters
	}
	return nil
}

// FindChangedPathsResponse is the response for the FindChangedPaths RPC.
// Returns a list of files that have been changed in the commits given.
type FindChangedPathsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// paths contains the attributes for one changed file. In case of merge
	// commits, or when comparing three or more commits, a file might be included
	// more than once if it was changed between multiple commits.
	Paths         []*ChangedPaths `protobuf:"bytes,1,rep,name=paths,proto3" json:"paths,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindChangedPathsResponse) ProtoMessage() {}

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

// Deprecated: Use FindChangedPathsResponse.ProtoReflect.Descriptor instead.
func (*FindChangedPathsResponse) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{13}
}

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

// ChangedPaths contains information about a changed file. It includes the path
// of the file, and the status of the change.
type ChangedPaths struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// path is the path of the change in question.
	Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// status is the type of change.
	Status ChangedPaths_Status `protobuf:"varint,2,opt,name=status,proto3,enum=gitaly.ChangedPaths_Status" json:"status,omitempty"`
	// old_mode is the mode of the changed path previous to the change. May be one of the following values:
	//
	//   - 0o000000 if the path does not exist.
	//   - 0o100644 if the path refers to a normal file.
	//   - 0o100755 if the path refers to an executable file.
	//   - 0o040000 if the path refers to a tree entry.
	//   - 0o160000 if the path refers to a submodule.
	OldMode int32 `protobuf:"varint,3,opt,name=old_mode,json=oldMode,proto3" json:"old_mode,omitempty"`
	// new_mode is the mode of the changed path after the change. Please refer to `old_mode` for a list of potential values.
	NewMode int32 `protobuf:"varint,4,opt,name=new_mode,json=newMode,proto3" json:"new_mode,omitempty"`
	// old_blob_id is the blob oid of the changed path previous to the change.
	OldBlobId string `protobuf:"bytes,5,opt,name=old_blob_id,json=oldBlobId,proto3" json:"old_blob_id,omitempty"`
	// new_blob_id is the blob oid of the changed path after the changed.
	NewBlobId string `protobuf:"bytes,6,opt,name=new_blob_id,json=newBlobId,proto3" json:"new_blob_id,omitempty"`
	// old_path is the pre-image path of a renamed or copied object. This field is empty for all other
	// change types.
	OldPath []byte `protobuf:"bytes,7,opt,name=old_path,json=oldPath,proto3" json:"old_path,omitempty"`
	// score denotes the similarity between the source and target. Only present for renames and copies.
	Score int32 `protobuf:"varint,8,opt,name=score,proto3" json:"score,omitempty"`
	// commit_id refers to the commit that the changed path is associated with.
	// Only gets populated if all requests in a FindChangedPathsRequest are of
	// type CommitRequest
	CommitId      string `protobuf:"bytes,9,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ChangedPaths) ProtoMessage() {}

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

// Deprecated: Use ChangedPaths.ProtoReflect.Descriptor instead.
func (*ChangedPaths) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{14}
}

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

func (x *ChangedPaths) GetStatus() ChangedPaths_Status {
	if x != nil {
		return x.Status
	}
	return ChangedPaths_ADDED
}

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

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

func (x *ChangedPaths) GetOldBlobId() string {
	if x != nil {
		return x.OldBlobId
	}
	return ""
}

func (x *ChangedPaths) GetNewBlobId() string {
	if x != nil {
		return x.NewBlobId
	}
	return ""
}

func (x *ChangedPaths) GetOldPath() []byte {
	if x != nil {
		return x.OldPath
	}
	return nil
}

func (x *ChangedPaths) GetScore() int32 {
	if x != nil {
		return x.Score
	}
	return 0
}

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

// GetPatchIDRequest is a request for the GetPatchID RPC.
type GetPatchIDRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository the patch ID shall be computed in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// old_revision is the old revision that shall be used to compute the patch
	// from that will then be passed to git-patch-id(1). Accepts revisions as
	// specified in gitrevisions(5).
	OldRevision []byte `protobuf:"bytes,2,opt,name=old_revision,json=oldRevision,proto3" json:"old_revision,omitempty"`
	// new_revision is the new revision that shall be used to compute the patch
	// from that will then be passed to git-patch-id(1). Accepts revisions as
	// specified in gitrevisions(5).
	NewRevision []byte `protobuf:"bytes,3,opt,name=new_revision,json=newRevision,proto3" json:"new_revision,omitempty"`
	// context_free computes the diff with zero context lines (-U0) before
	// hashing. This produces patch IDs that remain stable across rebases
	// where only the merge base changes but the actual code modifications
	// are identical. When false (default), uses the standard 3 context lines.
	ContextFree   bool `protobuf:"varint,4,opt,name=context_free,json=contextFree,proto3" json:"context_free,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetPatchIDRequest) ProtoMessage() {}

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

// Deprecated: Use GetPatchIDRequest.ProtoReflect.Descriptor instead.
func (*GetPatchIDRequest) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{15}
}

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

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

func (x *GetPatchIDRequest) GetNewRevision() []byte {
	if x != nil {
		return x.NewRevision
	}
	return nil
}

func (x *GetPatchIDRequest) GetContextFree() bool {
	if x != nil {
		return x.ContextFree
	}
	return false
}

// GetPatchIDResponse is a response for the GetPatchID RPC.
type GetPatchIDResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// patch_id is the patch ID that was generated by hashing the diff of the
	// given old and new revision.
	PatchId       string `protobuf:"bytes,1,opt,name=patch_id,json=patchId,proto3" json:"patch_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetPatchIDResponse) ProtoMessage() {}

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

// Deprecated: Use GetPatchIDResponse.ProtoReflect.Descriptor instead.
func (*GetPatchIDResponse) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{16}
}

func (x *GetPatchIDResponse) GetPatchId() string {
	if x != nil {
		return x.PatchId
	}
	return ""
}

// RangePair is a pair of commit ranges.
type RangePair struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// range1 is the first range, e.g. <base>..<rev>, <rev>^!
	Range1 string `protobuf:"bytes,1,opt,name=range1,proto3" json:"range1,omitempty"`
	// range2 is the second range.e.g. <base>..<rev>, <rev>^!
	Range2        string `protobuf:"bytes,2,opt,name=range2,proto3" json:"range2,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RangePair) ProtoMessage() {}

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

// Deprecated: Use RangePair.ProtoReflect.Descriptor instead.
func (*RangePair) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{17}
}

func (x *RangePair) GetRange1() string {
	if x != nil {
		return x.Range1
	}
	return ""
}

func (x *RangePair) GetRange2() string {
	if x != nil {
		return x.Range2
	}
	return ""
}

// RevisionRange is a specification of revisions using the '...' notation.
type RevisionRange struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// rev1 is the first revision.
	Rev1 string `protobuf:"bytes,1,opt,name=rev1,proto3" json:"rev1,omitempty"`
	// rev2 is the the second revision.
	Rev2          string `protobuf:"bytes,2,opt,name=rev2,proto3" json:"rev2,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RevisionRange) ProtoMessage() {}

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

// Deprecated: Use RevisionRange.ProtoReflect.Descriptor instead.
func (*RevisionRange) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{18}
}

func (x *RevisionRange) GetRev1() string {
	if x != nil {
		return x.Rev1
	}
	return ""
}

func (x *RevisionRange) GetRev2() string {
	if x != nil {
		return x.Rev2
	}
	return ""
}

// BaseWithRevisions is a specification with a base and two revisions.
type BaseWithRevisions struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// base is the merge base revision.
	Base string `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	// rev1 is the first revision.
	Rev1 string `protobuf:"bytes,2,opt,name=rev1,proto3" json:"rev1,omitempty"`
	// rev2 is the the second revision.
	Rev2          string `protobuf:"bytes,3,opt,name=rev2,proto3" json:"rev2,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BaseWithRevisions) ProtoMessage() {}

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

// Deprecated: Use BaseWithRevisions.ProtoReflect.Descriptor instead.
func (*BaseWithRevisions) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{19}
}

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

func (x *BaseWithRevisions) GetRev1() string {
	if x != nil {
		return x.Rev1
	}
	return ""
}

func (x *BaseWithRevisions) GetRev2() string {
	if x != nil {
		return x.Rev2
	}
	return ""
}

// RawRangeDiffRequest is the raw range diff request.
type RawRangeDiffRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the one to get range diff output from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// Types that are valid to be assigned to RangeSpec:
	//
	//	*RawRangeDiffRequest_RangePair
	//	*RawRangeDiffRequest_RevisionRange
	//	*RawRangeDiffRequest_BaseWithRevisions
	RangeSpec     isRawRangeDiffRequest_RangeSpec `protobuf_oneof:"range_spec"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RawRangeDiffRequest) ProtoMessage() {}

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

// Deprecated: Use RawRangeDiffRequest.ProtoReflect.Descriptor instead.
func (*RawRangeDiffRequest) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{20}
}

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

func (x *RawRangeDiffRequest) GetRangeSpec() isRawRangeDiffRequest_RangeSpec {
	if x != nil {
		return x.RangeSpec
	}
	return nil
}

func (x *RawRangeDiffRequest) GetRangePair() *RangePair {
	if x != nil {
		if x, ok := x.RangeSpec.(*RawRangeDiffRequest_RangePair); ok {
			return x.RangePair
		}
	}
	return nil
}

func (x *RawRangeDiffRequest) GetRevisionRange() *RevisionRange {
	if x != nil {
		if x, ok := x.RangeSpec.(*RawRangeDiffRequest_RevisionRange); ok {
			return x.RevisionRange
		}
	}
	return nil
}

func (x *RawRangeDiffRequest) GetBaseWithRevisions() *BaseWithRevisions {
	if x != nil {
		if x, ok := x.RangeSpec.(*RawRangeDiffRequest_BaseWithRevisions); ok {
			return x.BaseWithRevisions
		}
	}
	return nil
}

type isRawRangeDiffRequest_RangeSpec interface {
	isRawRangeDiffRequest_RangeSpec()
}

type RawRangeDiffRequest_RangePair struct {
	// range_pair specifies format: <range1> <range2>.
	RangePair *RangePair `protobuf:"bytes,2,opt,name=range_pair,json=rangePair,proto3,oneof"`
}

type RawRangeDiffRequest_RevisionRange struct {
	// revision_range specifies format: <rev1>...<rev2>.
	RevisionRange *RevisionRange `protobuf:"bytes,3,opt,name=revision_range,json=revisionRange,proto3,oneof"`
}

type RawRangeDiffRequest_BaseWithRevisions struct {
	// base_with_revisions specifies format: <base> <rev1> <rev2>.
	BaseWithRevisions *BaseWithRevisions `protobuf:"bytes,4,opt,name=base_with_revisions,json=baseWithRevisions,proto3,oneof"`
}

func (*RawRangeDiffRequest_RangePair) isRawRangeDiffRequest_RangeSpec() {}

func (*RawRangeDiffRequest_RevisionRange) isRawRangeDiffRequest_RangeSpec() {}

func (*RawRangeDiffRequest_BaseWithRevisions) isRawRangeDiffRequest_RangeSpec() {}

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

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

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

func (*RawRangeDiffResponse) ProtoMessage() {}

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

// Deprecated: Use RawRangeDiffResponse.ProtoReflect.Descriptor instead.
func (*RawRangeDiffResponse) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{21}
}

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

// RangeDiffRequest is the range diff request.
type RangeDiffRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the one to get range diff output from.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// range_spec specifies the range-diff commit ranges.
	//
	// Types that are valid to be assigned to RangeSpec:
	//
	//	*RangeDiffRequest_RangePair
	//	*RangeDiffRequest_RevisionRange
	//	*RangeDiffRequest_BaseWithRevisions
	RangeSpec     isRangeDiffRequest_RangeSpec `protobuf_oneof:"range_spec"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RangeDiffRequest) ProtoMessage() {}

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

// Deprecated: Use RangeDiffRequest.ProtoReflect.Descriptor instead.
func (*RangeDiffRequest) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{22}
}

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

func (x *RangeDiffRequest) GetRangeSpec() isRangeDiffRequest_RangeSpec {
	if x != nil {
		return x.RangeSpec
	}
	return nil
}

func (x *RangeDiffRequest) GetRangePair() *RangePair {
	if x != nil {
		if x, ok := x.RangeSpec.(*RangeDiffRequest_RangePair); ok {
			return x.RangePair
		}
	}
	return nil
}

func (x *RangeDiffRequest) GetRevisionRange() *RevisionRange {
	if x != nil {
		if x, ok := x.RangeSpec.(*RangeDiffRequest_RevisionRange); ok {
			return x.RevisionRange
		}
	}
	return nil
}

func (x *RangeDiffRequest) GetBaseWithRevisions() *BaseWithRevisions {
	if x != nil {
		if x, ok := x.RangeSpec.(*RangeDiffRequest_BaseWithRevisions); ok {
			return x.BaseWithRevisions
		}
	}
	return nil
}

type isRangeDiffRequest_RangeSpec interface {
	isRangeDiffRequest_RangeSpec()
}

type RangeDiffRequest_RangePair struct {
	// range_pair specifies format: <range1> <range2>.
	RangePair *RangePair `protobuf:"bytes,2,opt,name=range_pair,json=rangePair,proto3,oneof"`
}

type RangeDiffRequest_RevisionRange struct {
	// revision_range specifies format: <rev1>...<rev2>.
	RevisionRange *RevisionRange `protobuf:"bytes,3,opt,name=revision_range,json=revisionRange,proto3,oneof"`
}

type RangeDiffRequest_BaseWithRevisions struct {
	// base_with_revisions specifies format: <base> <rev1> <rev2>.
	BaseWithRevisions *BaseWithRevisions `protobuf:"bytes,4,opt,name=base_with_revisions,json=baseWithRevisions,proto3,oneof"`
}

func (*RangeDiffRequest_RangePair) isRangeDiffRequest_RangeSpec() {}

func (*RangeDiffRequest_RevisionRange) isRangeDiffRequest_RangeSpec() {}

func (*RangeDiffRequest_BaseWithRevisions) isRangeDiffRequest_RangeSpec() {}

// RangeDiffResponse contains the data from a commit pair line and its following patch if any.
type RangeDiffResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// from_commit_id is the left side commit id in the commit pair line.
	FromCommitId string `protobuf:"bytes,1,opt,name=from_commit_id,json=fromCommitId,proto3" json:"from_commit_id,omitempty"`
	// to_commit_id is the right side commit id  in the commit pair line.
	ToCommitId string `protobuf:"bytes,2,opt,name=to_commit_id,json=toCommitId,proto3" json:"to_commit_id,omitempty"`
	// comparison is the comparison result of the two commits.
	Comparison RangeDiffResponse_Comparator `protobuf:"varint,3,opt,name=comparison,proto3,enum=gitaly.RangeDiffResponse_Comparator" json:"comparison,omitempty"`
	// commit_message_title is the commit message title of the commit.
	CommitMessageTitle string `protobuf:"bytes,7,opt,name=commit_message_title,json=commitMessageTitle,proto3" json:"commit_message_title,omitempty"`
	// patch_data is the range diff patch data if two commits are not equal.
	PatchData []byte `protobuf:"bytes,8,opt,name=patch_data,json=patchData,proto3" json:"patch_data,omitempty"`
	// end_of_patch check if the patch data is the last one response of this commit pair.
	EndOfPatch    bool `protobuf:"varint,9,opt,name=end_of_patch,json=endOfPatch,proto3" json:"end_of_patch,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RangeDiffResponse) ProtoMessage() {}

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

// Deprecated: Use RangeDiffResponse.ProtoReflect.Descriptor instead.
func (*RangeDiffResponse) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{23}
}

func (x *RangeDiffResponse) GetFromCommitId() string {
	if x != nil {
		return x.FromCommitId
	}
	return ""
}

func (x *RangeDiffResponse) GetToCommitId() string {
	if x != nil {
		return x.ToCommitId
	}
	return ""
}

func (x *RangeDiffResponse) GetComparison() RangeDiffResponse_Comparator {
	if x != nil {
		return x.Comparison
	}
	return RangeDiffResponse_COMPARATOR_EQUAL_UNSPECIFIED
}

func (x *RangeDiffResponse) GetCommitMessageTitle() string {
	if x != nil {
		return x.CommitMessageTitle
	}
	return ""
}

func (x *RangeDiffResponse) GetPatchData() []byte {
	if x != nil {
		return x.PatchData
	}
	return nil
}

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

// DiffBlobsRequest is a request for the DiffBlobs RPC.
type DiffBlobsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository the blob diff is generated for.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// blob_pairs defines the set of blob pairs to generate diffs for.
	BlobPairs []*DiffBlobsRequest_BlobPair `protobuf:"bytes,2,rep,name=blob_pairs,json=blobPairs,proto3" json:"blob_pairs,omitempty"`
	// diff_mode is the mode used for generating the diff. Refer to the enum declaration above for
	// supported modes.
	DiffMode DiffBlobsRequest_DiffMode `protobuf:"varint,3,opt,name=diff_mode,json=diffMode,proto3,enum=gitaly.DiffBlobsRequest_DiffMode" json:"diff_mode,omitempty"`
	// whitespace_changes states which whitespace changes should be included in the diff. Refer to the
	// enum declaration above for supported modes.
	WhitespaceChanges DiffBlobsRequest_WhitespaceChanges `protobuf:"varint,4,opt,name=whitespace_changes,json=whitespaceChanges,proto3,enum=gitaly.DiffBlobsRequest_WhitespaceChanges" json:"whitespace_changes,omitempty"`
	// patch_bytes_limit is the max size in bytes of a single patch generated from a pair of blobs.
	// Patches surpassing this limit are pruned. If set to zero, no limit is enforced.
	PatchBytesLimit int32 `protobuf:"varint,5,opt,name=patch_bytes_limit,json=patchBytesLimit,proto3" json:"patch_bytes_limit,omitempty"`
	// raw_info is the set of file pairs in raw format used to compute diffs for.
	RawInfo       []*ChangedPaths `protobuf:"bytes,6,rep,name=raw_info,json=rawInfo,proto3" json:"raw_info,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DiffBlobsRequest) ProtoMessage() {}

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

// Deprecated: Use DiffBlobsRequest.ProtoReflect.Descriptor instead.
func (*DiffBlobsRequest) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{24}
}

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

func (x *DiffBlobsRequest) GetBlobPairs() []*DiffBlobsRequest_BlobPair {
	if x != nil {
		return x.BlobPairs
	}
	return nil
}

func (x *DiffBlobsRequest) GetDiffMode() DiffBlobsRequest_DiffMode {
	if x != nil {
		return x.DiffMode
	}
	return DiffBlobsRequest_DIFF_MODE_UNSPECIFIED
}

func (x *DiffBlobsRequest) GetWhitespaceChanges() DiffBlobsRequest_WhitespaceChanges {
	if x != nil {
		return x.WhitespaceChanges
	}
	return DiffBlobsRequest_WHITESPACE_CHANGES_UNSPECIFIED
}

func (x *DiffBlobsRequest) GetPatchBytesLimit() int32 {
	if x != nil {
		return x.PatchBytesLimit
	}
	return 0
}

func (x *DiffBlobsRequest) GetRawInfo() []*ChangedPaths {
	if x != nil {
		return x.RawInfo
	}
	return nil
}

// DiffBlobsResponse is a response for the DiffBlobs RPC.
type DiffBlobsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// left_blob_id is the left blob ID in in <left blob>..<right blob> of the diffed blob.
	LeftBlobId string `protobuf:"bytes,1,opt,name=left_blob_id,json=leftBlobId,proto3" json:"left_blob_id,omitempty"`
	// right_blob_id is the right blob ID in in <left blob>..<right blob> of the diffed blob.
	RightBlobId string `protobuf:"bytes,2,opt,name=right_blob_id,json=rightBlobId,proto3" json:"right_blob_id,omitempty"`
	// patch is the raw generated diff output.
	Patch []byte `protobuf:"bytes,3,opt,name=patch,proto3" json:"patch,omitempty"`
	// status is the current state of the patch being transmitted.
	Status DiffBlobsResponse_Status `protobuf:"varint,4,opt,name=status,proto3,enum=gitaly.DiffBlobsResponse_Status" json:"status,omitempty"`
	// binary indicates whether or not the diff compares binary data. If Git considers either blob to
	// be binary, Git only reports whether the files differ.
	Binary bool `protobuf:"varint,5,opt,name=binary,proto3" json:"binary,omitempty"`
	// over_patch_bytes_limit indicates the patch was pruned since it surpassed the set limit.
	OverPatchBytesLimit bool `protobuf:"varint,6,opt,name=over_patch_bytes_limit,json=overPatchBytesLimit,proto3" json:"over_patch_bytes_limit,omitempty"`
	// patch_size is the size of the patch in bytes and is always returned even if a patch is pruned.
	// To improve performance, a client may make an initial DiffBlobs request with a lower "soft"
	// patch_bytes_limit to avoid receiving large patches. If a patch exceeds this byte limit and gets
	// pruned, the patch size can be used by the client to determine whether it is sensible to make a
	// follow-up DiffBlobs request by increasing the patch_bytes_limit to a "hard" limit.
	PatchSize int32 `protobuf:"varint,7,opt,name=patch_size,json=patchSize,proto3" json:"patch_size,omitempty"`
	// lines_added is the number of lines added in the diff. This count always represents the
	// full diff, even when it is pruned.
	LinesAdded int32 `protobuf:"varint,8,opt,name=lines_added,json=linesAdded,proto3" json:"lines_added,omitempty"`
	// lines_removed is the number of lines removed in the diff. This count always represents the
	// full diff, even when it is pruned.
	LinesRemoved  int32 `protobuf:"varint,9,opt,name=lines_removed,json=linesRemoved,proto3" json:"lines_removed,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DiffBlobsResponse) ProtoMessage() {}

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

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

func (x *DiffBlobsResponse) GetLeftBlobId() string {
	if x != nil {
		return x.LeftBlobId
	}
	return ""
}

func (x *DiffBlobsResponse) GetRightBlobId() string {
	if x != nil {
		return x.RightBlobId
	}
	return ""
}

func (x *DiffBlobsResponse) GetPatch() []byte {
	if x != nil {
		return x.Patch
	}
	return nil
}

func (x *DiffBlobsResponse) GetStatus() DiffBlobsResponse_Status {
	if x != nil {
		return x.Status
	}
	return DiffBlobsResponse_STATUS_INCOMPLETE
}

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

func (x *DiffBlobsResponse) GetOverPatchBytesLimit() bool {
	if x != nil {
		return x.OverPatchBytesLimit
	}
	return false
}

func (x *DiffBlobsResponse) GetPatchSize() int32 {
	if x != nil {
		return x.PatchSize
	}
	return 0
}

func (x *DiffBlobsResponse) GetLinesAdded() int32 {
	if x != nil {
		return x.LinesAdded
	}
	return 0
}

func (x *DiffBlobsResponse) GetLinesRemoved() int32 {
	if x != nil {
		return x.LinesRemoved
	}
	return 0
}

// Request is a single request to pass to git diff-tree.
type FindChangedPathsRequest_Request struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Type:
	//
	//	*FindChangedPathsRequest_Request_TreeRequest_
	//	*FindChangedPathsRequest_Request_CommitRequest_
	Type          isFindChangedPathsRequest_Request_Type `protobuf_oneof:"type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FindChangedPathsRequest_Request) ProtoMessage() {}

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

// Deprecated: Use FindChangedPathsRequest_Request.ProtoReflect.Descriptor instead.
func (*FindChangedPathsRequest_Request) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{12, 0}
}

func (x *FindChangedPathsRequest_Request) GetType() isFindChangedPathsRequest_Request_Type {
	if x != nil {
		return x.Type
	}
	return nil
}

func (x *FindChangedPathsRequest_Request) GetTreeRequest() *FindChangedPathsRequest_Request_TreeRequest {
	if x != nil {
		if x, ok := x.Type.(*FindChangedPathsRequest_Request_TreeRequest_); ok {
			return x.TreeRequest
		}
	}
	return nil
}

func (x *FindChangedPathsRequest_Request) GetCommitRequest() *FindChangedPathsRequest_Request_CommitRequest {
	if x != nil {
		if x, ok := x.Type.(*FindChangedPathsRequest_Request_CommitRequest_); ok {
			return x.CommitRequest
		}
	}
	return nil
}

type isFindChangedPathsRequest_Request_Type interface {
	isFindChangedPathsRequest_Request_Type()
}

type FindChangedPathsRequest_Request_TreeRequest_ struct {
	// tree_request is a request comparing two trees with each other.
	TreeRequest *FindChangedPathsRequest_Request_TreeRequest `protobuf:"bytes,1,opt,name=tree_request,json=treeRequest,proto3,oneof"`
}

type FindChangedPathsRequest_Request_CommitRequest_ struct {
	// commit_request is a request comparing one or more commits with each other.
	CommitRequest *FindChangedPathsRequest_Request_CommitRequest `protobuf:"bytes,2,opt,name=commit_request,json=commitRequest,proto3,oneof"`
}

func (*FindChangedPathsRequest_Request_TreeRequest_) isFindChangedPathsRequest_Request_Type() {}

func (*FindChangedPathsRequest_Request_CommitRequest_) isFindChangedPathsRequest_Request_Type() {}

// TreeRequest compares two trees.
type FindChangedPathsRequest_Request_TreeRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// left_tree_revision is the revision of the left tree to compare. Accepts any revision that
	// peels to a tree object.
	LeftTreeRevision string `protobuf:"bytes,1,opt,name=left_tree_revision,json=leftTreeRevision,proto3" json:"left_tree_revision,omitempty"`
	// right_tree_revision is the revision of the right tree to compare. Accepts any revision that
	// peels to a tree object.
	RightTreeRevision string `protobuf:"bytes,2,opt,name=right_tree_revision,json=rightTreeRevision,proto3" json:"right_tree_revision,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*FindChangedPathsRequest_Request_TreeRequest) ProtoMessage() {}

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

// Deprecated: Use FindChangedPathsRequest_Request_TreeRequest.ProtoReflect.Descriptor instead.
func (*FindChangedPathsRequest_Request_TreeRequest) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{12, 0, 0}
}

func (x *FindChangedPathsRequest_Request_TreeRequest) GetLeftTreeRevision() string {
	if x != nil {
		return x.LeftTreeRevision
	}
	return ""
}

func (x *FindChangedPathsRequest_Request_TreeRequest) GetRightTreeRevision() string {
	if x != nil {
		return x.RightTreeRevision
	}
	return ""
}

// CommitRequest compares a commit to its parents (or some other commits.)
type FindChangedPathsRequest_Request_CommitRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit_revision is the revision of the commit that should be compared. If no `parent_commit_revisions`
	// are given, then the commit will be compared against its parents. The revision needs to peel to a
	// commit object.
	CommitRevision string `protobuf:"bytes,1,opt,name=commit_revision,json=commitRevision,proto3" json:"commit_revision,omitempty"`
	// parent_commit_revisions are the revisions of commits to treat as the commit's parents. This is an
	// optional field: if not specified, the actual parents of the commit referred to by `commit_revision`
	// are used.
	ParentCommitRevisions []string `protobuf:"bytes,2,rep,name=parent_commit_revisions,json=parentCommitRevisions,proto3" json:"parent_commit_revisions,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

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

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

func (*FindChangedPathsRequest_Request_CommitRequest) ProtoMessage() {}

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

// Deprecated: Use FindChangedPathsRequest_Request_CommitRequest.ProtoReflect.Descriptor instead.
func (*FindChangedPathsRequest_Request_CommitRequest) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{12, 0, 1}
}

func (x *FindChangedPathsRequest_Request_CommitRequest) GetCommitRevision() string {
	if x != nil {
		return x.CommitRevision
	}
	return ""
}

func (x *FindChangedPathsRequest_Request_CommitRequest) GetParentCommitRevisions() []string {
	if x != nil {
		return x.ParentCommitRevisions
	}
	return nil
}

// BlobPair defines a pair of blobs a patch is generated for.
type DiffBlobsRequest_BlobPair struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// left_blob is the left blob in <left blob>..<right blob>. Can be either a path-scoped
	// revision or blob ID.
	LeftBlob []byte `protobuf:"bytes,1,opt,name=left_blob,json=leftBlob,proto3" json:"left_blob,omitempty"`
	// right_blob is the right blob in <left blob>..<right blob>. Can be either a path-scoped
	// revision or blob ID.
	RightBlob     []byte `protobuf:"bytes,2,opt,name=right_blob,json=rightBlob,proto3" json:"right_blob,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DiffBlobsRequest_BlobPair) ProtoMessage() {}

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

// Deprecated: Use DiffBlobsRequest_BlobPair.ProtoReflect.Descriptor instead.
func (*DiffBlobsRequest_BlobPair) Descriptor() ([]byte, []int) {
	return file_diff_proto_rawDescGZIP(), []int{24, 0}
}

func (x *DiffBlobsRequest_BlobPair) GetLeftBlob() []byte {
	if x != nil {
		return x.LeftBlob
	}
	return nil
}

func (x *DiffBlobsRequest_BlobPair) GetRightBlob() []byte {
	if x != nil {
		return x.RightBlob
	}
	return nil
}

var File_diff_proto protoreflect.FileDescriptor

const file_diff_proto_rawDesc = "" +
	"\n" +
	"\n" +
	"diff.proto\x12\x06gitaly\x1a\n" +
	"lint.proto\x1a\fshared.proto\"\xd7\b\n" +
	"\x11CommitDiffRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12$\n" +
	"\x0eleft_commit_id\x18\x02 \x01(\tR\fleftCommitId\x12&\n" +
	"\x0fright_commit_id\x18\x03 \x01(\tR\rrightCommitId\x12\x14\n" +
	"\x05paths\x18\x05 \x03(\fR\x05paths\x12%\n" +
	"\x0ecollapse_diffs\x18\x06 \x01(\bR\rcollapseDiffs\x12%\n" +
	"\x0eenforce_limits\x18\a \x01(\bR\renforceLimits\x12\x1b\n" +
	"\tmax_files\x18\b \x01(\x05R\bmaxFiles\x12\x1b\n" +
	"\tmax_lines\x18\t \x01(\x05R\bmaxLines\x12\x1b\n" +
	"\tmax_bytes\x18\n" +
	" \x01(\x05R\bmaxBytes\x12$\n" +
	"\x0esafe_max_files\x18\v \x01(\x05R\fsafeMaxFiles\x12$\n" +
	"\x0esafe_max_lines\x18\f \x01(\x05R\fsafeMaxLines\x12$\n" +
	"\x0esafe_max_bytes\x18\r \x01(\x05R\fsafeMaxBytes\x12&\n" +
	"\x0fmax_patch_bytes\x18\x0e \x01(\x05R\rmaxPatchBytes\x12?\n" +
	"\tdiff_mode\x18\x0f \x01(\x0e2\".gitaly.CommitDiffRequest.DiffModeR\bdiffMode\x12\x87\x01\n" +
	"\"max_patch_bytes_for_file_extension\x18\x10 \x03(\v2<.gitaly.CommitDiffRequest.MaxPatchBytesForFileExtensionEntryR\x1dmaxPatchBytesForFileExtension\x12Z\n" +
	"\x12whitespace_changes\x18\x11 \x01(\x0e2+.gitaly.CommitDiffRequest.WhitespaceChangesR\x11whitespaceChanges\x12*\n" +
	"\x11collect_all_paths\x18\x12 \x01(\bR\x0fcollectAllPaths\x1aP\n" +
	"\"MaxPatchBytesForFileExtensionEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\"%\n" +
	"\bDiffMode\x12\v\n" +
	"\aDEFAULT\x10\x00\x12\f\n" +
	"\bWORDDIFF\x10\x01\"y\n" +
	"\x11WhitespaceChanges\x12\"\n" +
	"\x1eWHITESPACE_CHANGES_UNSPECIFIED\x10\x00\x12\x1d\n" +
	"\x19WHITESPACE_CHANGES_IGNORE\x10\x01\x12!\n" +
	"\x1dWHITESPACE_CHANGES_IGNORE_ALL\x10\x02J\x04\b\x04\x10\x05R\x18ignore_whitespace_change\"\xbe\x03\n" +
	"\x12CommitDiffResponse\x12\x1b\n" +
	"\tfrom_path\x18\x01 \x01(\fR\bfromPath\x12\x17\n" +
	"\ato_path\x18\x02 \x01(\fR\x06toPath\x12\x17\n" +
	"\afrom_id\x18\x03 \x01(\tR\x06fromId\x12\x13\n" +
	"\x05to_id\x18\x04 \x01(\tR\x04toId\x12\x19\n" +
	"\bold_mode\x18\x05 \x01(\x05R\aoldMode\x12\x19\n" +
	"\bnew_mode\x18\x06 \x01(\x05R\anewMode\x12\x16\n" +
	"\x06binary\x18\a \x01(\bR\x06binary\x12$\n" +
	"\x0eraw_patch_data\x18\t \x01(\fR\frawPatchData\x12 \n" +
	"\fend_of_patch\x18\n" +
	" \x01(\bR\n" +
	"endOfPatch\x12'\n" +
	"\x0foverflow_marker\x18\v \x01(\bR\x0eoverflowMarker\x12\x1c\n" +
	"\tcollapsed\x18\f \x01(\bR\tcollapsed\x12\x1b\n" +
	"\ttoo_large\x18\r \x01(\bR\btooLarge\x12\x1f\n" +
	"\vlines_added\x18\x0e \x01(\x05R\n" +
	"linesAdded\x12#\n" +
	"\rlines_removed\x18\x0f \x01(\x05R\flinesRemovedJ\x04\b\b\x10\t\"\xb2\x01\n" +
	"\x12CommitDeltaRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12$\n" +
	"\x0eleft_commit_id\x18\x02 \x01(\tR\fleftCommitId\x12&\n" +
	"\x0fright_commit_id\x18\x03 \x01(\tR\rrightCommitId\x12\x14\n" +
	"\x05paths\x18\x04 \x03(\fR\x05paths\"\xa7\x01\n" +
	"\vCommitDelta\x12\x1b\n" +
	"\tfrom_path\x18\x01 \x01(\fR\bfromPath\x12\x17\n" +
	"\ato_path\x18\x02 \x01(\fR\x06toPath\x12\x17\n" +
	"\afrom_id\x18\x03 \x01(\tR\x06fromId\x12\x13\n" +
	"\x05to_id\x18\x04 \x01(\tR\x04toId\x12\x19\n" +
	"\bold_mode\x18\x05 \x01(\x05R\aoldMode\x12\x19\n" +
	"\bnew_mode\x18\x06 \x01(\x05R\anewMode\"B\n" +
	"\x13CommitDeltaResponse\x12+\n" +
	"\x06deltas\x18\x01 \x03(\v2\x13.gitaly.CommitDeltaR\x06deltas\"\x98\x01\n" +
	"\x0eRawDiffRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12$\n" +
	"\x0eleft_commit_id\x18\x02 \x01(\tR\fleftCommitId\x12&\n" +
	"\x0fright_commit_id\x18\x03 \x01(\tR\rrightCommitId\"%\n" +
	"\x0fRawDiffResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"\x99\x01\n" +
	"\x0fRawPatchRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12$\n" +
	"\x0eleft_commit_id\x18\x02 \x01(\tR\fleftCommitId\x12&\n" +
	"\x0fright_commit_id\x18\x03 \x01(\tR\rrightCommitId\"&\n" +
	"\x10RawPatchResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"\x9a\x01\n" +
	"\x10DiffStatsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12$\n" +
	"\x0eleft_commit_id\x18\x02 \x01(\tR\fleftCommitId\x12&\n" +
	"\x0fright_commit_id\x18\x03 \x01(\tR\rrightCommitId\"v\n" +
	"\tDiffStats\x12\x12\n" +
	"\x04path\x18\x01 \x01(\fR\x04path\x12\x1c\n" +
	"\tadditions\x18\x02 \x01(\x05R\tadditions\x12\x1c\n" +
	"\tdeletions\x18\x03 \x01(\x05R\tdeletions\x12\x19\n" +
	"\bold_path\x18\x04 \x01(\fR\aoldPath\"<\n" +
	"\x11DiffStatsResponse\x12'\n" +
	"\x05stats\x18\x01 \x03(\v2\x11.gitaly.DiffStatsR\x05stats\"\x96\t\n" +
	"\x17FindChangedPathsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1c\n" +
	"\acommits\x18\x02 \x03(\tB\x02\x18\x01R\acommits\x12C\n" +
	"\brequests\x18\x03 \x03(\v2'.gitaly.FindChangedPathsRequest.RequestR\brequests\x12h\n" +
	"\x16merge_commit_diff_mode\x18\x04 \x01(\x0e23.gitaly.FindChangedPathsRequest.MergeCommitDiffModeR\x13mergeCommitDiffMode\x12!\n" +
	"\ffind_renames\x18\x05 \x01(\bR\vfindRenames\x12M\n" +
	"\fdiff_filters\x18\x06 \x03(\x0e2*.gitaly.FindChangedPathsRequest.DiffStatusR\vdiffFilters\x1a\xaa\x03\n" +
	"\aRequest\x12X\n" +
	"\ftree_request\x18\x01 \x01(\v23.gitaly.FindChangedPathsRequest.Request.TreeRequestH\x00R\vtreeRequest\x12^\n" +
	"\x0ecommit_request\x18\x02 \x01(\v25.gitaly.FindChangedPathsRequest.Request.CommitRequestH\x00R\rcommitRequest\x1ak\n" +
	"\vTreeRequest\x12,\n" +
	"\x12left_tree_revision\x18\x01 \x01(\tR\x10leftTreeRevision\x12.\n" +
	"\x13right_tree_revision\x18\x02 \x01(\tR\x11rightTreeRevision\x1ap\n" +
	"\rCommitRequest\x12'\n" +
	"\x0fcommit_revision\x18\x01 \x01(\tR\x0ecommitRevision\x126\n" +
	"\x17parent_commit_revisions\x18\x02 \x03(\tR\x15parentCommitRevisionsB\x06\n" +
	"\x04type\"\x90\x01\n" +
	"\x13MergeCommitDiffMode\x12&\n" +
	"\"MERGE_COMMIT_DIFF_MODE_UNSPECIFIED\x10\x00\x12)\n" +
	"%MERGE_COMMIT_DIFF_MODE_INCLUDE_MERGES\x10\x01\x12&\n" +
	"\"MERGE_COMMIT_DIFF_MODE_ALL_PARENTS\x10\x02\"\xc1\x01\n" +
	"\n" +
	"DiffStatus\x12\x1b\n" +
	"\x17DIFF_STATUS_UNSPECIFIED\x10\x00\x12\x15\n" +
	"\x11DIFF_STATUS_ADDED\x10\x01\x12\x18\n" +
	"\x14DIFF_STATUS_MODIFIED\x10\x02\x12\x17\n" +
	"\x13DIFF_STATUS_DELETED\x10\x03\x12\x1b\n" +
	"\x17DIFF_STATUS_TYPE_CHANGE\x10\x04\x12\x16\n" +
	"\x12DIFF_STATUS_COPIED\x10\x05\x12\x17\n" +
	"\x13DIFF_STATUS_RENAMED\x10\x06\"F\n" +
	"\x18FindChangedPathsResponse\x12*\n" +
	"\x05paths\x18\x01 \x03(\v2\x14.gitaly.ChangedPathsR\x05paths\"\xf5\x02\n" +
	"\fChangedPaths\x12\x12\n" +
	"\x04path\x18\x01 \x01(\fR\x04path\x123\n" +
	"\x06status\x18\x02 \x01(\x0e2\x1b.gitaly.ChangedPaths.StatusR\x06status\x12\x19\n" +
	"\bold_mode\x18\x03 \x01(\x05R\aoldMode\x12\x19\n" +
	"\bnew_mode\x18\x04 \x01(\x05R\anewMode\x12\x1e\n" +
	"\vold_blob_id\x18\x05 \x01(\tR\toldBlobId\x12\x1e\n" +
	"\vnew_blob_id\x18\x06 \x01(\tR\tnewBlobId\x12\x19\n" +
	"\bold_path\x18\a \x01(\fR\aoldPath\x12\x14\n" +
	"\x05score\x18\b \x01(\x05R\x05score\x12\x1b\n" +
	"\tcommit_id\x18\t \x01(\tR\bcommitId\"X\n" +
	"\x06Status\x12\t\n" +
	"\x05ADDED\x10\x00\x12\f\n" +
	"\bMODIFIED\x10\x01\x12\v\n" +
	"\aDELETED\x10\x02\x12\x0f\n" +
	"\vTYPE_CHANGE\x10\x03\x12\n" +
	"\n" +
	"\x06COPIED\x10\x04\x12\v\n" +
	"\aRENAMED\x10\x05\"\xb6\x01\n" +
	"\x11GetPatchIDRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12!\n" +
	"\fold_revision\x18\x02 \x01(\fR\voldRevision\x12!\n" +
	"\fnew_revision\x18\x03 \x01(\fR\vnewRevision\x12!\n" +
	"\fcontext_free\x18\x04 \x01(\bR\vcontextFree\"/\n" +
	"\x12GetPatchIDResponse\x12\x19\n" +
	"\bpatch_id\x18\x01 \x01(\tR\apatchId\";\n" +
	"\tRangePair\x12\x16\n" +
	"\x06range1\x18\x01 \x01(\tR\x06range1\x12\x16\n" +
	"\x06range2\x18\x02 \x01(\tR\x06range2\"7\n" +
	"\rRevisionRange\x12\x12\n" +
	"\x04rev1\x18\x01 \x01(\tR\x04rev1\x12\x12\n" +
	"\x04rev2\x18\x02 \x01(\tR\x04rev2\"O\n" +
	"\x11BaseWithRevisions\x12\x12\n" +
	"\x04base\x18\x01 \x01(\tR\x04base\x12\x12\n" +
	"\x04rev1\x18\x02 \x01(\tR\x04rev1\x12\x12\n" +
	"\x04rev2\x18\x03 \x01(\tR\x04rev2\"\x9e\x02\n" +
	"\x13RawRangeDiffRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x122\n" +
	"\n" +
	"range_pair\x18\x02 \x01(\v2\x11.gitaly.RangePairH\x00R\trangePair\x12>\n" +
	"\x0erevision_range\x18\x03 \x01(\v2\x15.gitaly.RevisionRangeH\x00R\rrevisionRange\x12K\n" +
	"\x13base_with_revisions\x18\x04 \x01(\v2\x19.gitaly.BaseWithRevisionsH\x00R\x11baseWithRevisionsB\f\n" +
	"\n" +
	"range_spec\"*\n" +
	"\x14RawRangeDiffResponse\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"\x9b\x02\n" +
	"\x10RangeDiffRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x122\n" +
	"\n" +
	"range_pair\x18\x02 \x01(\v2\x11.gitaly.RangePairH\x00R\trangePair\x12>\n" +
	"\x0erevision_range\x18\x03 \x01(\v2\x15.gitaly.RevisionRangeH\x00R\rrevisionRange\x12K\n" +
	"\x13base_with_revisions\x18\x04 \x01(\v2\x19.gitaly.BaseWithRevisionsH\x00R\x11baseWithRevisionsB\f\n" +
	"\n" +
	"range_spec\"\x95\x03\n" +
	"\x11RangeDiffResponse\x12$\n" +
	"\x0efrom_commit_id\x18\x01 \x01(\tR\ffromCommitId\x12 \n" +
	"\fto_commit_id\x18\x02 \x01(\tR\n" +
	"toCommitId\x12D\n" +
	"\n" +
	"comparison\x18\x03 \x01(\x0e2$.gitaly.RangeDiffResponse.ComparatorR\n" +
	"comparison\x120\n" +
	"\x14commit_message_title\x18\a \x01(\tR\x12commitMessageTitle\x12\x1d\n" +
	"\n" +
	"patch_data\x18\b \x01(\fR\tpatchData\x12 \n" +
	"\fend_of_patch\x18\t \x01(\bR\n" +
	"endOfPatch\"\x7f\n" +
	"\n" +
	"Comparator\x12 \n" +
	"\x1cCOMPARATOR_EQUAL_UNSPECIFIED\x10\x00\x12\x1b\n" +
	"\x17COMPARATOR_GREATER_THAN\x10\x01\x12\x18\n" +
	"\x14COMPARATOR_LESS_THAN\x10\x02\x12\x18\n" +
	"\x14COMPARATOR_NOT_EQUAL\x10\x03\"\x84\x05\n" +
	"\x10DiffBlobsRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12@\n" +
	"\n" +
	"blob_pairs\x18\x02 \x03(\v2!.gitaly.DiffBlobsRequest.BlobPairR\tblobPairs\x12>\n" +
	"\tdiff_mode\x18\x03 \x01(\x0e2!.gitaly.DiffBlobsRequest.DiffModeR\bdiffMode\x12Y\n" +
	"\x12whitespace_changes\x18\x04 \x01(\x0e2*.gitaly.DiffBlobsRequest.WhitespaceChangesR\x11whitespaceChanges\x12*\n" +
	"\x11patch_bytes_limit\x18\x05 \x01(\x05R\x0fpatchBytesLimit\x12/\n" +
	"\braw_info\x18\x06 \x03(\v2\x14.gitaly.ChangedPathsR\arawInfo\x1aF\n" +
	"\bBlobPair\x12\x1b\n" +
	"\tleft_blob\x18\x01 \x01(\fR\bleftBlob\x12\x1d\n" +
	"\n" +
	"right_blob\x18\x02 \x01(\fR\trightBlob\"9\n" +
	"\bDiffMode\x12\x19\n" +
	"\x15DIFF_MODE_UNSPECIFIED\x10\x00\x12\x12\n" +
	"\x0eDIFF_MODE_WORD\x10\x01\"y\n" +
	"\x11WhitespaceChanges\x12\"\n" +
	"\x1eWHITESPACE_CHANGES_UNSPECIFIED\x10\x00\x12\x1d\n" +
	"\x19WHITESPACE_CHANGES_IGNORE\x10\x01\x12!\n" +
	"\x1dWHITESPACE_CHANGES_IGNORE_ALL\x10\x02\"\x95\x03\n" +
	"\x11DiffBlobsResponse\x12 \n" +
	"\fleft_blob_id\x18\x01 \x01(\tR\n" +
	"leftBlobId\x12\"\n" +
	"\rright_blob_id\x18\x02 \x01(\tR\vrightBlobId\x12\x14\n" +
	"\x05patch\x18\x03 \x01(\fR\x05patch\x128\n" +
	"\x06status\x18\x04 \x01(\x0e2 .gitaly.DiffBlobsResponse.StatusR\x06status\x12\x16\n" +
	"\x06binary\x18\x05 \x01(\bR\x06binary\x123\n" +
	"\x16over_patch_bytes_limit\x18\x06 \x01(\bR\x13overPatchBytesLimit\x12\x1d\n" +
	"\n" +
	"patch_size\x18\a \x01(\x05R\tpatchSize\x12\x1f\n" +
	"\vlines_added\x18\b \x01(\x05R\n" +
	"linesAdded\x12#\n" +
	"\rlines_removed\x18\t \x01(\x05R\flinesRemoved\"8\n" +
	"\x06Status\x12\x15\n" +
	"\x11STATUS_INCOMPLETE\x10\x00\x12\x17\n" +
	"\x13STATUS_END_OF_PATCH\x10\x012\xa4\x06\n" +
	"\vDiffService\x12M\n" +
	"\n" +
	"CommitDiff\x12\x19.gitaly.CommitDiffRequest\x1a\x1a.gitaly.CommitDiffResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12P\n" +
	"\vCommitDelta\x12\x1a.gitaly.CommitDeltaRequest\x1a\x1b.gitaly.CommitDeltaResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12D\n" +
	"\aRawDiff\x12\x16.gitaly.RawDiffRequest\x1a\x17.gitaly.RawDiffResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12G\n" +
	"\bRawPatch\x12\x17.gitaly.RawPatchRequest\x1a\x18.gitaly.RawPatchResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12J\n" +
	"\tDiffStats\x12\x18.gitaly.DiffStatsRequest\x1a\x19.gitaly.DiffStatsResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12_\n" +
	"\x10FindChangedPaths\x12\x1f.gitaly.FindChangedPathsRequest\x1a .gitaly.FindChangedPathsResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12K\n" +
	"\n" +
	"GetPatchID\x12\x19.gitaly.GetPatchIDRequest\x1a\x1a.gitaly.GetPatchIDResponse\"\x06\xfa\x97(\x02\b\x02\x12S\n" +
	"\fRawRangeDiff\x12\x1b.gitaly.RawRangeDiffRequest\x1a\x1c.gitaly.RawRangeDiffResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12J\n" +
	"\tRangeDiff\x12\x18.gitaly.RangeDiffRequest\x1a\x19.gitaly.RangeDiffResponse\"\x06\xfa\x97(\x02\b\x020\x01\x12J\n" +
	"\tDiffBlobs\x12\x18.gitaly.DiffBlobsRequest\x1a\x19.gitaly.DiffBlobsResponse\"\x06\xfa\x97(\x02\b\x020\x01B4Z2gitlab.com/gitlab-org/gitaly/v18/proto/go/gitalypbb\x06proto3"

var (
	file_diff_proto_rawDescOnce sync.Once
	file_diff_proto_rawDescData []byte
)

func file_diff_proto_rawDescGZIP() []byte {
	file_diff_proto_rawDescOnce.Do(func() {
		file_diff_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_diff_proto_rawDesc), len(file_diff_proto_rawDesc)))
	})
	return file_diff_proto_rawDescData
}

var file_diff_proto_enumTypes = make([]protoimpl.EnumInfo, 9)
var file_diff_proto_msgTypes = make([]protoimpl.MessageInfo, 31)
var file_diff_proto_goTypes = []any{
	(CommitDiffRequest_DiffMode)(0),                       // 0: gitaly.CommitDiffRequest.DiffMode
	(CommitDiffRequest_WhitespaceChanges)(0),              // 1: gitaly.CommitDiffRequest.WhitespaceChanges
	(FindChangedPathsRequest_MergeCommitDiffMode)(0),      // 2: gitaly.FindChangedPathsRequest.MergeCommitDiffMode
	(FindChangedPathsRequest_DiffStatus)(0),               // 3: gitaly.FindChangedPathsRequest.DiffStatus
	(ChangedPaths_Status)(0),                              // 4: gitaly.ChangedPaths.Status
	(RangeDiffResponse_Comparator)(0),                     // 5: gitaly.RangeDiffResponse.Comparator
	(DiffBlobsRequest_DiffMode)(0),                        // 6: gitaly.DiffBlobsRequest.DiffMode
	(DiffBlobsRequest_WhitespaceChanges)(0),               // 7: gitaly.DiffBlobsRequest.WhitespaceChanges
	(DiffBlobsResponse_Status)(0),                         // 8: gitaly.DiffBlobsResponse.Status
	(*CommitDiffRequest)(nil),                             // 9: gitaly.CommitDiffRequest
	(*CommitDiffResponse)(nil),                            // 10: gitaly.CommitDiffResponse
	(*CommitDeltaRequest)(nil),                            // 11: gitaly.CommitDeltaRequest
	(*CommitDelta)(nil),                                   // 12: gitaly.CommitDelta
	(*CommitDeltaResponse)(nil),                           // 13: gitaly.CommitDeltaResponse
	(*RawDiffRequest)(nil),                                // 14: gitaly.RawDiffRequest
	(*RawDiffResponse)(nil),                               // 15: gitaly.RawDiffResponse
	(*RawPatchRequest)(nil),                               // 16: gitaly.RawPatchRequest
	(*RawPatchResponse)(nil),                              // 17: gitaly.RawPatchResponse
	(*DiffStatsRequest)(nil),                              // 18: gitaly.DiffStatsRequest
	(*DiffStats)(nil),                                     // 19: gitaly.DiffStats
	(*DiffStatsResponse)(nil),                             // 20: gitaly.DiffStatsResponse
	(*FindChangedPathsRequest)(nil),                       // 21: gitaly.FindChangedPathsRequest
	(*FindChangedPathsResponse)(nil),                      // 22: gitaly.FindChangedPathsResponse
	(*ChangedPaths)(nil),                                  // 23: gitaly.ChangedPaths
	(*GetPatchIDRequest)(nil),                             // 24: gitaly.GetPatchIDRequest
	(*GetPatchIDResponse)(nil),                            // 25: gitaly.GetPatchIDResponse
	(*RangePair)(nil),                                     // 26: gitaly.RangePair
	(*RevisionRange)(nil),                                 // 27: gitaly.RevisionRange
	(*BaseWithRevisions)(nil),                             // 28: gitaly.BaseWithRevisions
	(*RawRangeDiffRequest)(nil),                           // 29: gitaly.RawRangeDiffRequest
	(*RawRangeDiffResponse)(nil),                          // 30: gitaly.RawRangeDiffResponse
	(*RangeDiffRequest)(nil),                              // 31: gitaly.RangeDiffRequest
	(*RangeDiffResponse)(nil),                             // 32: gitaly.RangeDiffResponse
	(*DiffBlobsRequest)(nil),                              // 33: gitaly.DiffBlobsRequest
	(*DiffBlobsResponse)(nil),                             // 34: gitaly.DiffBlobsResponse
	nil,                                                   // 35: gitaly.CommitDiffRequest.MaxPatchBytesForFileExtensionEntry
	(*FindChangedPathsRequest_Request)(nil),               // 36: gitaly.FindChangedPathsRequest.Request
	(*FindChangedPathsRequest_Request_TreeRequest)(nil),   // 37: gitaly.FindChangedPathsRequest.Request.TreeRequest
	(*FindChangedPathsRequest_Request_CommitRequest)(nil), // 38: gitaly.FindChangedPathsRequest.Request.CommitRequest
	(*DiffBlobsRequest_BlobPair)(nil),                     // 39: gitaly.DiffBlobsRequest.BlobPair
	(*Repository)(nil),                                    // 40: gitaly.Repository
}
var file_diff_proto_depIdxs = []int32{
	40, // 0: gitaly.CommitDiffRequest.repository:type_name -> gitaly.Repository
	0,  // 1: gitaly.CommitDiffRequest.diff_mode:type_name -> gitaly.CommitDiffRequest.DiffMode
	35, // 2: gitaly.CommitDiffRequest.max_patch_bytes_for_file_extension:type_name -> gitaly.CommitDiffRequest.MaxPatchBytesForFileExtensionEntry
	1,  // 3: gitaly.CommitDiffRequest.whitespace_changes:type_name -> gitaly.CommitDiffRequest.WhitespaceChanges
	40, // 4: gitaly.CommitDeltaRequest.repository:type_name -> gitaly.Repository
	12, // 5: gitaly.CommitDeltaResponse.deltas:type_name -> gitaly.CommitDelta
	40, // 6: gitaly.RawDiffRequest.repository:type_name -> gitaly.Repository
	40, // 7: gitaly.RawPatchRequest.repository:type_name -> gitaly.Repository
	40, // 8: gitaly.DiffStatsRequest.repository:type_name -> gitaly.Repository
	19, // 9: gitaly.DiffStatsResponse.stats:type_name -> gitaly.DiffStats
	40, // 10: gitaly.FindChangedPathsRequest.repository:type_name -> gitaly.Repository
	36, // 11: gitaly.FindChangedPathsRequest.requests:type_name -> gitaly.FindChangedPathsRequest.Request
	2,  // 12: gitaly.FindChangedPathsRequest.merge_commit_diff_mode:type_name -> gitaly.FindChangedPathsRequest.MergeCommitDiffMode
	3,  // 13: gitaly.FindChangedPathsRequest.diff_filters:type_name -> gitaly.FindChangedPathsRequest.DiffStatus
	23, // 14: gitaly.FindChangedPathsResponse.paths:type_name -> gitaly.ChangedPaths
	4,  // 15: gitaly.ChangedPaths.status:type_name -> gitaly.ChangedPaths.Status
	40, // 16: gitaly.GetPatchIDRequest.repository:type_name -> gitaly.Repository
	40, // 17: gitaly.RawRangeDiffRequest.repository:type_name -> gitaly.Repository
	26, // 18: gitaly.RawRangeDiffRequest.range_pair:type_name -> gitaly.RangePair
	27, // 19: gitaly.RawRangeDiffRequest.revision_range:type_name -> gitaly.RevisionRange
	28, // 20: gitaly.RawRangeDiffRequest.base_with_revisions:type_name -> gitaly.BaseWithRevisions
	40, // 21: gitaly.RangeDiffRequest.repository:type_name -> gitaly.Repository
	26, // 22: gitaly.RangeDiffRequest.range_pair:type_name -> gitaly.RangePair
	27, // 23: gitaly.RangeDiffRequest.revision_range:type_name -> gitaly.RevisionRange
	28, // 24: gitaly.RangeDiffRequest.base_with_revisions:type_name -> gitaly.BaseWithRevisions
	5,  // 25: gitaly.RangeDiffResponse.comparison:type_name -> gitaly.RangeDiffResponse.Comparator
	40, // 26: gitaly.DiffBlobsRequest.repository:type_name -> gitaly.Repository
	39, // 27: gitaly.DiffBlobsRequest.blob_pairs:type_name -> gitaly.DiffBlobsRequest.BlobPair
	6,  // 28: gitaly.DiffBlobsRequest.diff_mode:type_name -> gitaly.DiffBlobsRequest.DiffMode
	7,  // 29: gitaly.DiffBlobsRequest.whitespace_changes:type_name -> gitaly.DiffBlobsRequest.WhitespaceChanges
	23, // 30: gitaly.DiffBlobsRequest.raw_info:type_name -> gitaly.ChangedPaths
	8,  // 31: gitaly.DiffBlobsResponse.status:type_name -> gitaly.DiffBlobsResponse.Status
	37, // 32: gitaly.FindChangedPathsRequest.Request.tree_request:type_name -> gitaly.FindChangedPathsRequest.Request.TreeRequest
	38, // 33: gitaly.FindChangedPathsRequest.Request.commit_request:type_name -> gitaly.FindChangedPathsRequest.Request.CommitRequest
	9,  // 34: gitaly.DiffService.CommitDiff:input_type -> gitaly.CommitDiffRequest
	11, // 35: gitaly.DiffService.CommitDelta:input_type -> gitaly.CommitDeltaRequest
	14, // 36: gitaly.DiffService.RawDiff:input_type -> gitaly.RawDiffRequest
	16, // 37: gitaly.DiffService.RawPatch:input_type -> gitaly.RawPatchRequest
	18, // 38: gitaly.DiffService.DiffStats:input_type -> gitaly.DiffStatsRequest
	21, // 39: gitaly.DiffService.FindChangedPaths:input_type -> gitaly.FindChangedPathsRequest
	24, // 40: gitaly.DiffService.GetPatchID:input_type -> gitaly.GetPatchIDRequest
	29, // 41: gitaly.DiffService.RawRangeDiff:input_type -> gitaly.RawRangeDiffRequest
	31, // 42: gitaly.DiffService.RangeDiff:input_type -> gitaly.RangeDiffRequest
	33, // 43: gitaly.DiffService.DiffBlobs:input_type -> gitaly.DiffBlobsRequest
	10, // 44: gitaly.DiffService.CommitDiff:output_type -> gitaly.CommitDiffResponse
	13, // 45: gitaly.DiffService.CommitDelta:output_type -> gitaly.CommitDeltaResponse
	15, // 46: gitaly.DiffService.RawDiff:output_type -> gitaly.RawDiffResponse
	17, // 47: gitaly.DiffService.RawPatch:output_type -> gitaly.RawPatchResponse
	20, // 48: gitaly.DiffService.DiffStats:output_type -> gitaly.DiffStatsResponse
	22, // 49: gitaly.DiffService.FindChangedPaths:output_type -> gitaly.FindChangedPathsResponse
	25, // 50: gitaly.DiffService.GetPatchID:output_type -> gitaly.GetPatchIDResponse
	30, // 51: gitaly.DiffService.RawRangeDiff:output_type -> gitaly.RawRangeDiffResponse
	32, // 52: gitaly.DiffService.RangeDiff:output_type -> gitaly.RangeDiffResponse
	34, // 53: gitaly.DiffService.DiffBlobs:output_type -> gitaly.DiffBlobsResponse
	44, // [44:54] is the sub-list for method output_type
	34, // [34:44] is the sub-list for method input_type
	34, // [34:34] is the sub-list for extension type_name
	34, // [34:34] is the sub-list for extension extendee
	0,  // [0:34] is the sub-list for field type_name
}

func init() { file_diff_proto_init() }
func file_diff_proto_init() {
	if File_diff_proto != nil {
		return
	}
	file_lint_proto_init()
	file_shared_proto_init()
	file_diff_proto_msgTypes[20].OneofWrappers = []any{
		(*RawRangeDiffRequest_RangePair)(nil),
		(*RawRangeDiffRequest_RevisionRange)(nil),
		(*RawRangeDiffRequest_BaseWithRevisions)(nil),
	}
	file_diff_proto_msgTypes[22].OneofWrappers = []any{
		(*RangeDiffRequest_RangePair)(nil),
		(*RangeDiffRequest_RevisionRange)(nil),
		(*RangeDiffRequest_BaseWithRevisions)(nil),
	}
	file_diff_proto_msgTypes[27].OneofWrappers = []any{
		(*FindChangedPathsRequest_Request_TreeRequest_)(nil),
		(*FindChangedPathsRequest_Request_CommitRequest_)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_diff_proto_rawDesc), len(file_diff_proto_rawDesc)),
			NumEnums:      9,
			NumMessages:   31,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_diff_proto_goTypes,
		DependencyIndexes: file_diff_proto_depIdxs,
		EnumInfos:         file_diff_proto_enumTypes,
		MessageInfos:      file_diff_proto_msgTypes,
	}.Build()
	File_diff_proto = out.File
	file_diff_proto_goTypes = nil
	file_diff_proto_depIdxs = nil
}
