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

package gitalypb

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

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

// CreateTreeError represents an error which happened when computing the
// revert.
type UserRevertResponse_CreateTreeError int32

const (
	// NONE denotes that no error occurred.
	UserRevertResponse_NONE UserRevertResponse_CreateTreeError = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// EMPTY denotes that the revert would've resulted in an empty commit,
	// typically because it has already been applied to the target branch.
	UserRevertResponse_EMPTY UserRevertResponse_CreateTreeError = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// CONFLICT denotes that the revert resulted in a conflict.
	UserRevertResponse_CONFLICT UserRevertResponse_CreateTreeError = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for UserRevertResponse_CreateTreeError.
var (
	UserRevertResponse_CreateTreeError_name = map[int32]string{
		0: "NONE",
		1: "EMPTY",
		2: "CONFLICT",
	}
	UserRevertResponse_CreateTreeError_value = map[string]int32{
		"NONE":     0,
		"EMPTY":    1,
		"CONFLICT": 2,
	}
)

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

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

func (UserRevertResponse_CreateTreeError) Descriptor() protoreflect.EnumDescriptor {
	return file_operations_proto_enumTypes[0].Descriptor()
}

func (UserRevertResponse_CreateTreeError) Type() protoreflect.EnumType {
	return &file_operations_proto_enumTypes[0]
}

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

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

// ActionType is the type of action to perform.
type UserCommitFilesActionHeader_ActionType int32

const (
	// CREATE creates a new file.
	UserCommitFilesActionHeader_CREATE UserCommitFilesActionHeader_ActionType = 0 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
	// CREATE_DIR creates a new directory.
	UserCommitFilesActionHeader_CREATE_DIR UserCommitFilesActionHeader_ActionType = 1 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// UPDATE updates an existing file.
	UserCommitFilesActionHeader_UPDATE UserCommitFilesActionHeader_ActionType = 2 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// MOVE moves an existing file to a new path.
	UserCommitFilesActionHeader_MOVE UserCommitFilesActionHeader_ActionType = 3 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// DELETE deletes an existing file.
	UserCommitFilesActionHeader_DELETE UserCommitFilesActionHeader_ActionType = 4 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
	// CHMOD changes the permissions of an existing file.
	UserCommitFilesActionHeader_CHMOD UserCommitFilesActionHeader_ActionType = 5 // protolint:disable:this ENUM_FIELD_NAMES_PREFIX
)

// Enum value maps for UserCommitFilesActionHeader_ActionType.
var (
	UserCommitFilesActionHeader_ActionType_name = map[int32]string{
		0: "CREATE",
		1: "CREATE_DIR",
		2: "UPDATE",
		3: "MOVE",
		4: "DELETE",
		5: "CHMOD",
	}
	UserCommitFilesActionHeader_ActionType_value = map[string]int32{
		"CREATE":     0,
		"CREATE_DIR": 1,
		"UPDATE":     2,
		"MOVE":       3,
		"DELETE":     4,
		"CHMOD":      5,
	}
)

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

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

func (UserCommitFilesActionHeader_ActionType) Descriptor() protoreflect.EnumDescriptor {
	return file_operations_proto_enumTypes[1].Descriptor()
}

func (UserCommitFilesActionHeader_ActionType) Type() protoreflect.EnumType {
	return &file_operations_proto_enumTypes[1]
}

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

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

// UserCreateBranchRequest is a request for the UserCreateBranch RPC.
type UserCreateBranchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which the branch should be created.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// branch_name is the name of the branch to create.
	BranchName []byte `protobuf:"bytes,2,opt,name=branch_name,json=branchName,proto3" json:"branch_name,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	// start_point is the Git revision to start the branch at. See the gitrevisions(1)
	// man pages for supported syntax.
	StartPoint    []byte `protobuf:"bytes,4,opt,name=start_point,json=startPoint,proto3" json:"start_point,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserCreateBranchRequest) ProtoMessage() {}

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

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

func (x *UserCreateBranchRequest) GetBranchName() []byte {
	if x != nil {
		return x.BranchName
	}
	return nil
}

func (x *UserCreateBranchRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserCreateBranchRequest) GetStartPoint() []byte {
	if x != nil {
		return x.StartPoint
	}
	return nil
}

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

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

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

func (*UserCreateBranchResponse) ProtoMessage() {}

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

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

// UserCreateBranchError is an error returned by the UserCreateBranch RPC in some specific well
// defined error cases.
type UserCreateBranchError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserCreateBranchError_CustomHook
	Error         isUserCreateBranchError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserCreateBranchError) ProtoMessage() {}

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

func (x *UserCreateBranchError) GetError() isUserCreateBranchError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserCreateBranchError) GetCustomHook() *CustomHookError {
	if x != nil {
		if x, ok := x.Error.(*UserCreateBranchError_CustomHook); ok {
			return x.CustomHook
		}
	}
	return nil
}

type isUserCreateBranchError_Error interface {
	isUserCreateBranchError_Error()
}

type UserCreateBranchError_CustomHook struct {
	// custom_hookError is set if any custom hook which has running as part of
	// this RPC call has returned a non-zero exit code.
	CustomHook *CustomHookError `protobuf:"bytes,1,opt,name=custom_hook,json=customHook,proto3,oneof"`
}

func (*UserCreateBranchError_CustomHook) isUserCreateBranchError_Error() {}

// UserUpdateBranchRequest is a request for the UserUpdateBranch RPC.
type UserUpdateBranchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to update the branch in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// branch_name is the name of the branch to update.
	BranchName []byte `protobuf:"bytes,2,opt,name=branch_name,json=branchName,proto3" json:"branch_name,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	// newrev is the Git revision which the branch will point to.
	Newrev []byte `protobuf:"bytes,4,opt,name=newrev,proto3" json:"newrev,omitempty"`
	// oldrev is the Git revision which the branch currently points to.
	Oldrev        []byte `protobuf:"bytes,5,opt,name=oldrev,proto3" json:"oldrev,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserUpdateBranchRequest) ProtoMessage() {}

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

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

func (x *UserUpdateBranchRequest) GetBranchName() []byte {
	if x != nil {
		return x.BranchName
	}
	return nil
}

func (x *UserUpdateBranchRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserUpdateBranchRequest) GetNewrev() []byte {
	if x != nil {
		return x.Newrev
	}
	return nil
}

func (x *UserUpdateBranchRequest) GetOldrev() []byte {
	if x != nil {
		return x.Oldrev
	}
	return nil
}

// UserUpdateBranchResponse is a response for the UserUpdateBranch RPC.
type UserUpdateBranchResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// pre_receive_error indicates an error that occurred while executing custom hooks.
	PreReceiveError string `protobuf:"bytes,1,opt,name=pre_receive_error,json=preReceiveError,proto3" json:"pre_receive_error,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*UserUpdateBranchResponse) ProtoMessage() {}

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

func (x *UserUpdateBranchResponse) GetPreReceiveError() string {
	if x != nil {
		return x.PreReceiveError
	}
	return ""
}

// UserDeleteBranchRequest is a request for the UserDeleteBranch RPC.
type UserDeleteBranchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to delete the branch in.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// branch_name is the name of the branch that shall be deleted. This is expected to be the branch
	// name only, e.g. in case you want to delete `refs/heads/main` the request needs to only contain
	// `main` as the branch name.
	BranchName []byte `protobuf:"bytes,2,opt,name=branch_name,json=branchName,proto3" json:"branch_name,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	// expected_old_oid is the object ID which branch is expected to point to.
	// This is used as a safety guard to avoid races when branch has been
	// updated meanwhile to point to a different object ID.
	//
	// If unset, the target branch will be deleted regardless of its current
	// state. If set, it must contain a valid, full object ID. Otherwise, this
	// RPC will return an error.
	ExpectedOldOid string `protobuf:"bytes,4,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*UserDeleteBranchRequest) ProtoMessage() {}

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

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

func (x *UserDeleteBranchRequest) GetBranchName() []byte {
	if x != nil {
		return x.BranchName
	}
	return nil
}

func (x *UserDeleteBranchRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserDeleteBranchRequest) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

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

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

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

func (*UserDeleteBranchResponse) ProtoMessage() {}

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

// UserDeleteBranchError is an error returned by the UserDeleteBranch RPC in some specific well
// defined error cases.
type UserDeleteBranchError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserDeleteBranchError_AccessCheck
	//	*UserDeleteBranchError_ReferenceUpdate
	//	*UserDeleteBranchError_CustomHook
	Error         isUserDeleteBranchError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserDeleteBranchError) ProtoMessage() {}

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

func (x *UserDeleteBranchError) GetError() isUserDeleteBranchError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserDeleteBranchError) GetAccessCheck() *AccessCheckError {
	if x != nil {
		if x, ok := x.Error.(*UserDeleteBranchError_AccessCheck); ok {
			return x.AccessCheck
		}
	}
	return nil
}

func (x *UserDeleteBranchError) GetReferenceUpdate() *ReferenceUpdateError {
	if x != nil {
		if x, ok := x.Error.(*UserDeleteBranchError_ReferenceUpdate); ok {
			return x.ReferenceUpdate
		}
	}
	return nil
}

func (x *UserDeleteBranchError) GetCustomHook() *CustomHookError {
	if x != nil {
		if x, ok := x.Error.(*UserDeleteBranchError_CustomHook); ok {
			return x.CustomHook
		}
	}
	return nil
}

type isUserDeleteBranchError_Error interface {
	isUserDeleteBranchError_Error()
}

type UserDeleteBranchError_AccessCheck struct {
	// access_check is set if the RPC failed due to an external access check.
	AccessCheck *AccessCheckError `protobuf:"bytes,1,opt,name=access_check,json=accessCheck,proto3,oneof"`
}

type UserDeleteBranchError_ReferenceUpdate struct {
	// reference_updateError is set if the RPC failed because updating the
	// reference to the new object ID has failed.
	ReferenceUpdate *ReferenceUpdateError `protobuf:"bytes,2,opt,name=reference_update,json=referenceUpdate,proto3,oneof"`
}

type UserDeleteBranchError_CustomHook struct {
	// custom_hook is set if any custom hook which has running as part of this RPC call has returned
	// a non-zero exit code.
	CustomHook *CustomHookError `protobuf:"bytes,3,opt,name=custom_hook,json=customHook,proto3,oneof"`
}

func (*UserDeleteBranchError_AccessCheck) isUserDeleteBranchError_Error() {}

func (*UserDeleteBranchError_ReferenceUpdate) isUserDeleteBranchError_Error() {}

func (*UserDeleteBranchError_CustomHook) isUserDeleteBranchError_Error() {}

// UserDeleteTagRequest is a request for the UserDeleteTag RPC.
type UserDeleteTagRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository from which the tag should be deleted.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// tag_name is the name of the tag to delete.
	TagName []byte `protobuf:"bytes,2,opt,name=tag_name,json=tagName,proto3" json:"tag_name,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	// expected_old_oid is the object ID which tag is expected to point to.
	// This is used as a safety guard to avoid races when tag has been
	// updated meanwhile to point to a different object ID.
	//
	// If unset, the target tag will be deleted regardless of its current
	// state. If set, it must contain a valid, full object ID. Otherwise,
	// this RPC will return an error.
	ExpectedOldOid string `protobuf:"bytes,4,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*UserDeleteTagRequest) ProtoMessage() {}

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

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

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

func (x *UserDeleteTagRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserDeleteTagRequest) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

// UserDeleteTagResponse is a response for the UserDeleteTag RPC.
type UserDeleteTagResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// pre_receive_error indicates an error that occurred while executing custom hooks.
	PreReceiveError string `protobuf:"bytes,1,opt,name=pre_receive_error,json=preReceiveError,proto3" json:"pre_receive_error,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*UserDeleteTagResponse) ProtoMessage() {}

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

func (x *UserDeleteTagResponse) GetPreReceiveError() string {
	if x != nil {
		return x.PreReceiveError
	}
	return ""
}

// UserCreateTagRequest is a request for the UserCreateTag RPC.
type UserCreateTagRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which the tag shall be created.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// tag_name is the name of the tag that shall be created. Note that this should be set to the name
	// only: if you want to create a tag `refs/heads/v1.0`, you need to pass `v1.0` as TagName.
	TagName []byte `protobuf:"bytes,2,opt,name=tag_name,json=tagName,proto3" json:"tag_name,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	// target_revision is the revision that the newly created tag should be pointing to. Note that if
	// the revision points to a tag, that tag will be peeled to the commit it is pointing to. If the
	// target_revision does not point to a commit then the RPC will return an error.
	TargetRevision []byte `protobuf:"bytes,4,opt,name=target_revision,json=targetRevision,proto3" json:"target_revision,omitempty"`
	// message is the message of the tag. If it is empty, a lightweight tag is created. Otherwise, an
	// annotated tag is created.
	Message []byte `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
	// timestamp is the optional timestamp to use for the created tag tags. If it's not set, the
	// current time will be used. It's only used if an annotated tag is being created.
	Timestamp     *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserCreateTagRequest) ProtoMessage() {}

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

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

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

func (x *UserCreateTagRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserCreateTagRequest) GetTargetRevision() []byte {
	if x != nil {
		return x.TargetRevision
	}
	return nil
}

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

func (x *UserCreateTagRequest) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

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

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

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

func (*UserCreateTagResponse) ProtoMessage() {}

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

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

// UserCreateTagError includes error descriptions which may be set as error details in case
// userCreateTag fails.
type UserCreateTagError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserCreateTagError_AccessCheck
	//	*UserCreateTagError_ReferenceUpdate
	//	*UserCreateTagError_CustomHook
	//	*UserCreateTagError_ReferenceExists
	Error         isUserCreateTagError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserCreateTagError) ProtoMessage() {}

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

func (x *UserCreateTagError) GetError() isUserCreateTagError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserCreateTagError) GetAccessCheck() *AccessCheckError {
	if x != nil {
		if x, ok := x.Error.(*UserCreateTagError_AccessCheck); ok {
			return x.AccessCheck
		}
	}
	return nil
}

func (x *UserCreateTagError) GetReferenceUpdate() *ReferenceUpdateError {
	if x != nil {
		if x, ok := x.Error.(*UserCreateTagError_ReferenceUpdate); ok {
			return x.ReferenceUpdate
		}
	}
	return nil
}

func (x *UserCreateTagError) GetCustomHook() *CustomHookError {
	if x != nil {
		if x, ok := x.Error.(*UserCreateTagError_CustomHook); ok {
			return x.CustomHook
		}
	}
	return nil
}

func (x *UserCreateTagError) GetReferenceExists() *ReferenceExistsError {
	if x != nil {
		if x, ok := x.Error.(*UserCreateTagError_ReferenceExists); ok {
			return x.ReferenceExists
		}
	}
	return nil
}

type isUserCreateTagError_Error interface {
	isUserCreateTagError_Error()
}

type UserCreateTagError_AccessCheck struct {
	// access_check is set if the RPC failed due to an external access check.
	AccessCheck *AccessCheckError `protobuf:"bytes,1,opt,name=access_check,json=accessCheck,proto3,oneof"`
}

type UserCreateTagError_ReferenceUpdate struct {
	// reference_updateError is set if the RPC failed because updating the
	// reference to the new object ID has failed.
	ReferenceUpdate *ReferenceUpdateError `protobuf:"bytes,2,opt,name=reference_update,json=referenceUpdate,proto3,oneof"`
}

type UserCreateTagError_CustomHook struct {
	// custom_hook is set if any custom hook which has running as part of this RPC call has returned
	// a non-zero exit code.
	CustomHook *CustomHookError `protobuf:"bytes,3,opt,name=custom_hook,json=customHook,proto3,oneof"`
}

type UserCreateTagError_ReferenceExists struct {
	// reference_existsError is set if the tag reference exists already.
	ReferenceExists *ReferenceExistsError `protobuf:"bytes,4,opt,name=reference_exists,json=referenceExists,proto3,oneof"`
}

func (*UserCreateTagError_AccessCheck) isUserCreateTagError_Error() {}

func (*UserCreateTagError_ReferenceUpdate) isUserCreateTagError_Error() {}

func (*UserCreateTagError_CustomHook) isUserCreateTagError_Error() {}

func (*UserCreateTagError_ReferenceExists) isUserCreateTagError_Error() {}

// UserMergeBranchRequest is a request for the UserMergeBranch RPC.
// All mandatory parameters except for `apply` should be set in the first
// message.
type UserMergeBranchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to compute the merge for.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// commit_id is the object ID (hash) of the object that shall be merged into
	// the target branch.
	CommitId string `protobuf:"bytes,3,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// branch is the branch into which the given commit shall be merged and whose
	// reference is going to be updated.
	Branch []byte `protobuf:"bytes,4,opt,name=branch,proto3" json:"branch,omitempty"`
	// message is the message to use for the merge commit.
	Message []byte `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
	// apply is used in the second message. Setting it to true will proceed with
	// the merge. Setting it to false will abort the merge.
	Apply bool `protobuf:"varint,6,opt,name=apply,proto3" json:"apply,omitempty"`
	// timestamp is the optional timestamp to use for the merge commit. If it's
	// not set, the current time will be used.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// expected_old_oid is the object ID which branch is expected to point to.
	// This is used as a safety guard to avoid races when branch has been
	// updated meanwhile to point to a different object ID.
	//
	// If unset, the target branch will be overwritten regardless of its current
	// state. If set, it must either contain a valid, full object ID  or the
	// zero object ID in case the branch should be created. Otherwise, this RPC
	// will return an error.
	ExpectedOldOid string `protobuf:"bytes,8,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	// squash is a flag to indicate that `commit_id` is a squash commit.
	// When set to `true`, it merges only the squash commit without creating
	// the merge commit.
	Squash bool `protobuf:"varint,9,opt,name=squash,proto3" json:"squash,omitempty"`
	// sign signifies whether the commit is to be signed
	Sign          bool `protobuf:"varint,10,opt,name=sign,proto3" json:"sign,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserMergeBranchRequest) ProtoMessage() {}

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

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

func (x *UserMergeBranchRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

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

func (x *UserMergeBranchRequest) GetBranch() []byte {
	if x != nil {
		return x.Branch
	}
	return nil
}

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

func (x *UserMergeBranchRequest) GetApply() bool {
	if x != nil {
		return x.Apply
	}
	return false
}

func (x *UserMergeBranchRequest) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *UserMergeBranchRequest) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

func (x *UserMergeBranchRequest) GetSquash() bool {
	if x != nil {
		return x.Squash
	}
	return false
}

func (x *UserMergeBranchRequest) GetSign() bool {
	if x != nil {
		return x.Sign
	}
	return false
}

// UserMergeBranchResponse is a response for the UserMergeBranch RPC.
type UserMergeBranchResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit_id is the merge commit the branch will be updated to. This is sent
	// as the response to the first request.
	CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// branch_update contains the commit ID of the merge commit if the merge has
	// been applied to the branch. This is sent as the response to the second
	// request.
	BranchUpdate  *OperationBranchUpdate `protobuf:"bytes,3,opt,name=branch_update,json=branchUpdate,proto3" json:"branch_update,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserMergeBranchResponse) ProtoMessage() {}

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

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

func (x *UserMergeBranchResponse) GetBranchUpdate() *OperationBranchUpdate {
	if x != nil {
		return x.BranchUpdate
	}
	return nil
}

// UserMergeBranchError includes error descriptions which may be set as error
// details in case UserMergeBranch fails.
type UserMergeBranchError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserMergeBranchError_AccessCheck
	//	*UserMergeBranchError_ReferenceUpdate
	//	*UserMergeBranchError_CustomHook
	//	*UserMergeBranchError_MergeConflict
	Error         isUserMergeBranchError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserMergeBranchError) ProtoMessage() {}

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

func (x *UserMergeBranchError) GetError() isUserMergeBranchError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserMergeBranchError) GetAccessCheck() *AccessCheckError {
	if x != nil {
		if x, ok := x.Error.(*UserMergeBranchError_AccessCheck); ok {
			return x.AccessCheck
		}
	}
	return nil
}

func (x *UserMergeBranchError) GetReferenceUpdate() *ReferenceUpdateError {
	if x != nil {
		if x, ok := x.Error.(*UserMergeBranchError_ReferenceUpdate); ok {
			return x.ReferenceUpdate
		}
	}
	return nil
}

func (x *UserMergeBranchError) GetCustomHook() *CustomHookError {
	if x != nil {
		if x, ok := x.Error.(*UserMergeBranchError_CustomHook); ok {
			return x.CustomHook
		}
	}
	return nil
}

func (x *UserMergeBranchError) GetMergeConflict() *MergeConflictError {
	if x != nil {
		if x, ok := x.Error.(*UserMergeBranchError_MergeConflict); ok {
			return x.MergeConflict
		}
	}
	return nil
}

type isUserMergeBranchError_Error interface {
	isUserMergeBranchError_Error()
}

type UserMergeBranchError_AccessCheck struct {
	// access_check is set if the RPC failed due to an external access check.
	AccessCheck *AccessCheckError `protobuf:"bytes,1,opt,name=access_check,json=accessCheck,proto3,oneof"`
}

type UserMergeBranchError_ReferenceUpdate struct {
	// reference_updateError is set if the RPC failed because updating the
	// reference to the new object ID has failed.
	ReferenceUpdate *ReferenceUpdateError `protobuf:"bytes,2,opt,name=reference_update,json=referenceUpdate,proto3,oneof"`
}

type UserMergeBranchError_CustomHook struct {
	// custom_hook is set if any custom hook which has running as part of this RPC call has returned
	// a non-zero exit code.
	CustomHook *CustomHookError `protobuf:"bytes,3,opt,name=custom_hook,json=customHook,proto3,oneof"`
}

type UserMergeBranchError_MergeConflict struct {
	// merge_conflictError is set if merging the revisions has resulted in conflicting files.
	MergeConflict *MergeConflictError `protobuf:"bytes,4,opt,name=merge_conflict,json=mergeConflict,proto3,oneof"`
}

func (*UserMergeBranchError_AccessCheck) isUserMergeBranchError_Error() {}

func (*UserMergeBranchError_ReferenceUpdate) isUserMergeBranchError_Error() {}

func (*UserMergeBranchError_CustomHook) isUserMergeBranchError_Error() {}

func (*UserMergeBranchError_MergeConflict) isUserMergeBranchError_Error() {}

// UserMergeToRefRequest is a request for the UserMergeToRef RPC.
type UserMergeToRefRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which the merge shall be computed.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// source_sha is the object ID of the second parent of the computed merge.
	SourceSha string `protobuf:"bytes,3,opt,name=source_sha,json=sourceSha,proto3" json:"source_sha,omitempty"`
	// branch contains the name of the branch which should be used as the first
	// parent of the computed merge. It is deprecated in favor of
	// `first_parent_ref` and will be ignored in case it is set.
	//
	// Deprecated: Marked as deprecated in operations.proto.
	Branch []byte `protobuf:"bytes,4,opt,name=branch,proto3" json:"branch,omitempty"`
	// target_ref contains the fully qualified reference which should be updated
	// with the computed merge commit.
	TargetRef []byte `protobuf:"bytes,5,opt,name=target_ref,json=targetRef,proto3" json:"target_ref,omitempty"`
	// message is the message to use for the merge commit.
	Message []byte `protobuf:"bytes,6,opt,name=message,proto3" json:"message,omitempty"`
	// first_parent_ref is the name of the reference which should be used as the
	// first parent of the computed merge. Overrides `branch`.
	FirstParentRef []byte `protobuf:"bytes,7,opt,name=first_parent_ref,json=firstParentRef,proto3" json:"first_parent_ref,omitempty"`
	// allow_conflicts if set, used to allow the merge to go ahead when there were
	// conflicts.  The code would simply write the conflict markers in the code.
	// This has since been deprecated in Rails and is no longer needed.
	//
	// Deprecated: Marked as deprecated in operations.proto.
	AllowConflicts bool `protobuf:"varint,8,opt,name=allow_conflicts,json=allowConflicts,proto3" json:"allow_conflicts,omitempty"`
	// timestamp is the optional timestamp to use for the merge commit. If it's
	// not set, the current time will be used.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// expected_old_oid is the object ID that is expected to be at target_ref. It
	// is used as an optimistic lock on concurrent updates of target_ref: If
	// target_ref no longer points to this ID, then the update is rejected.
	//
	// expected_old_oid is the object ID which branch is expected to point to.
	// This is used as a safety guard to avoid races when branch has been
	// updated meanwhile to point to a different object ID.
	//
	// If unset, the target branch will be overwritten regardless of its current
	// state. If set, it must either contain a valid, full object ID  or the
	// zero object ID in case the branch should be created. Otherwise, this RPC
	// will return an error.
	ExpectedOldOid string `protobuf:"bytes,10,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	// sign signifies whether the commit is to be signed
	Sign          bool `protobuf:"varint,11,opt,name=sign,proto3" json:"sign,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserMergeToRefRequest) ProtoMessage() {}

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

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

func (x *UserMergeToRefRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserMergeToRefRequest) GetSourceSha() string {
	if x != nil {
		return x.SourceSha
	}
	return ""
}

// Deprecated: Marked as deprecated in operations.proto.
func (x *UserMergeToRefRequest) GetBranch() []byte {
	if x != nil {
		return x.Branch
	}
	return nil
}

func (x *UserMergeToRefRequest) GetTargetRef() []byte {
	if x != nil {
		return x.TargetRef
	}
	return nil
}

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

func (x *UserMergeToRefRequest) GetFirstParentRef() []byte {
	if x != nil {
		return x.FirstParentRef
	}
	return nil
}

// Deprecated: Marked as deprecated in operations.proto.
func (x *UserMergeToRefRequest) GetAllowConflicts() bool {
	if x != nil {
		return x.AllowConflicts
	}
	return false
}

func (x *UserMergeToRefRequest) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *UserMergeToRefRequest) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

func (x *UserMergeToRefRequest) GetSign() bool {
	if x != nil {
		return x.Sign
	}
	return false
}

// UserMergeToRefResponse is a response for the UserMergeToRef RPC.
type UserMergeToRefResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit_id is the object ID of the computed merge commit.
	CommitId      string `protobuf:"bytes,1,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserMergeToRefResponse) ProtoMessage() {}

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

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

// UserRebaseToRefRequest contains the request parameters for the UserRebaseToRef RPC
type UserRebaseToRefRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which the rebase shall be computed.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// source_sha is the object ID of the commit to be rebased.
	SourceSha string `protobuf:"bytes,3,opt,name=source_sha,json=sourceSha,proto3" json:"source_sha,omitempty"`
	// target_ref is the fully qualified reference that will be overwritten or created
	// with the rebased commits.
	TargetRef []byte `protobuf:"bytes,5,opt,name=target_ref,json=targetRef,proto3" json:"target_ref,omitempty"`
	// first_parent_ref is the name of the reference on top of which SourceSha
	// should be rebased.
	FirstParentRef []byte `protobuf:"bytes,7,opt,name=first_parent_ref,json=firstParentRef,proto3" json:"first_parent_ref,omitempty"`
	// timestamp is the optional timestamp to use for the rebased commits as
	// committer date. If it's not set, the current time will be used.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// expected_old_oid is the object ID to which TargetRef is expected to point.
	// This is used as a safety guard to avoid races when TargetRef has been
	// updated meanwhile to point to a different object ID.
	//
	// If unset, TargetRef will be overwritten regardless of its current state.
	// If set, it must either contain a valid, full object ID or the zero object
	// ID in case the ref should be created. Otherwise, this RPC will return an
	// error.
	ExpectedOldOid string `protobuf:"bytes,10,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*UserRebaseToRefRequest) ProtoMessage() {}

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

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

func (x *UserRebaseToRefRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserRebaseToRefRequest) GetSourceSha() string {
	if x != nil {
		return x.SourceSha
	}
	return ""
}

func (x *UserRebaseToRefRequest) GetTargetRef() []byte {
	if x != nil {
		return x.TargetRef
	}
	return nil
}

func (x *UserRebaseToRefRequest) GetFirstParentRef() []byte {
	if x != nil {
		return x.FirstParentRef
	}
	return nil
}

func (x *UserRebaseToRefRequest) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *UserRebaseToRefRequest) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

// UserRebaseToRefResponse contains the response data for the UserRebaseToRef RPC
type UserRebaseToRefResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit_id is the object ID of the HEAD of the rebased ref.
	CommitId      string `protobuf:"bytes,1,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserRebaseToRefResponse) ProtoMessage() {}

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

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

// OperationBranchUpdate contains the details of a branch update.
type OperationBranchUpdate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// commit_id is set to the OID of the created commit if a branch was created or updated.
	CommitId string `protobuf:"bytes,1,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// repo_created indicates whether the branch created was the first one in the repository.
	// Used for cache invalidation in GitLab.
	RepoCreated bool `protobuf:"varint,2,opt,name=repo_created,json=repoCreated,proto3" json:"repo_created,omitempty"`
	// branch_created indicates whether the branch already existed in the repository
	// and was updated or whether it was created. Used for cache invalidation in GitLab.
	BranchCreated bool `protobuf:"varint,3,opt,name=branch_created,json=branchCreated,proto3" json:"branch_created,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*OperationBranchUpdate) ProtoMessage() {}

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

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

func (x *OperationBranchUpdate) GetRepoCreated() bool {
	if x != nil {
		return x.RepoCreated
	}
	return false
}

func (x *OperationBranchUpdate) GetBranchCreated() bool {
	if x != nil {
		return x.BranchCreated
	}
	return false
}

// UserFFBranchError is an error returned by the UserFFBranch RPC in some specific well
// defined error cases.
type UserFFBranchError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserFFBranchError_CustomHook
	//	*UserFFBranchError_ReferenceUpdate
	Error         isUserFFBranchError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserFFBranchError) ProtoMessage() {}

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

func (x *UserFFBranchError) GetError() isUserFFBranchError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserFFBranchError) GetCustomHook() *CustomHookError {
	if x != nil {
		if x, ok := x.Error.(*UserFFBranchError_CustomHook); ok {
			return x.CustomHook
		}
	}
	return nil
}

func (x *UserFFBranchError) GetReferenceUpdate() *ReferenceUpdateError {
	if x != nil {
		if x, ok := x.Error.(*UserFFBranchError_ReferenceUpdate); ok {
			return x.ReferenceUpdate
		}
	}
	return nil
}

type isUserFFBranchError_Error interface {
	isUserFFBranchError_Error()
}

type UserFFBranchError_CustomHook struct {
	// custom_hook is set if any custom hook which was running as part of this RPC call
	// has returned a non-zero exit code.
	CustomHook *CustomHookError `protobuf:"bytes,1,opt,name=custom_hook,json=customHook,proto3,oneof"`
}

type UserFFBranchError_ReferenceUpdate struct {
	// reference_update is set if the RPC failed because updating the reference to the new
	// object ID has failed.
	ReferenceUpdate *ReferenceUpdateError `protobuf:"bytes,2,opt,name=reference_update,json=referenceUpdate,proto3,oneof"`
}

func (*UserFFBranchError_CustomHook) isUserFFBranchError_Error() {}

func (*UserFFBranchError_ReferenceUpdate) isUserFFBranchError_Error() {}

// UserFFBranchRequest is a request for the UserFFBranch RPC.
type UserFFBranchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository for which to perform the fast-forward merge.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// commit_id is the commit ID to fast-forward the branch to.
	CommitId string `protobuf:"bytes,3,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// branch is the name of the branch to fast-forward. This must be the
	// branch name only and not a fully qualified reference, e.g. "master"
	// instead of "refs/heads/master".
	Branch []byte `protobuf:"bytes,4,opt,name=branch,proto3" json:"branch,omitempty"`
	// expected_old_oid is the object ID which branch is expected to point to.
	// This is used as a safety guard to avoid races when branch has been
	// updated meanwhile to point to a different object ID.
	//
	// If unset, the target branch will be overwritten regardless of its current
	// state. If set, it must either contain a valid, full object ID  or the
	// zero object ID in case the branch should be created. Otherwise, this RPC
	// will return an error.
	ExpectedOldOid string `protobuf:"bytes,5,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*UserFFBranchRequest) ProtoMessage() {}

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

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

func (x *UserFFBranchRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

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

func (x *UserFFBranchRequest) GetBranch() []byte {
	if x != nil {
		return x.Branch
	}
	return nil
}

func (x *UserFFBranchRequest) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

// UserFFBranchResponse is a response for the UserFFBranch RPC.
type UserFFBranchResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// branch_update contains details of the fast-forwarded branch.
	BranchUpdate *OperationBranchUpdate `protobuf:"bytes,1,opt,name=branch_update,json=branchUpdate,proto3" json:"branch_update,omitempty"`
	// pre_receive_error is set in the case of an `Internal` error and contains
	// details of the failed custom hook.
	PreReceiveError string `protobuf:"bytes,2,opt,name=pre_receive_error,json=preReceiveError,proto3" json:"pre_receive_error,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*UserFFBranchResponse) ProtoMessage() {}

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

func (x *UserFFBranchResponse) GetBranchUpdate() *OperationBranchUpdate {
	if x != nil {
		return x.BranchUpdate
	}
	return nil
}

func (x *UserFFBranchResponse) GetPreReceiveError() string {
	if x != nil {
		return x.PreReceiveError
	}
	return ""
}

// UserCherryPickRequest is a request for the UserCherryPick RPC.
type UserCherryPickRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository into which the cherry-pick shall be
	// performed.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// commit is the commit to cherry-pick onto the given branch.
	Commit *GitCommit `protobuf:"bytes,3,opt,name=commit,proto3" json:"commit,omitempty"`
	// branch_name is the name of the branch onto which the cherry-pick shall be
	// executed.
	BranchName []byte `protobuf:"bytes,4,opt,name=branch_name,json=branchName,proto3" json:"branch_name,omitempty"`
	// message is the message to use for the cherry-picked commit.
	Message []byte `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
	// start_branch_name is is used in case the branch_name branch does not
	// exist. In that case, it will be created from the start_branch_name.
	StartBranchName []byte `protobuf:"bytes,6,opt,name=start_branch_name,json=startBranchName,proto3" json:"start_branch_name,omitempty"`
	// start_repository is used in case the branch_name branch does not exist. In
	// that case, it will be created from start_branch_name in the
	// start_repository.
	StartRepository *Repository `protobuf:"bytes,7,opt,name=start_repository,json=startRepository,proto3" json:"start_repository,omitempty"`
	// dry_run will compute the cherry-pick, but not update the target branch.
	DryRun bool `protobuf:"varint,8,opt,name=dry_run,json=dryRun,proto3" json:"dry_run,omitempty"`
	// timestamp is the optional timestamp to use for the created cherry-picked
	// commit's committer date. If it's not set, the current time will be used.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// expected_old_oid is the object ID which branch is expected to point to.
	// This is used as a safety guard to avoid races when branch has been
	// updated meanwhile to point to a different object ID. Only applicable when
	// branch_name is set.
	//
	// If unset, the target branch will be overwritten regardless of its current
	// state. If set, it must either contain a valid, full object ID  or the
	// zero object ID in case the branch should be created. Otherwise, this RPC
	// will return an error.
	ExpectedOldOid string `protobuf:"bytes,10,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	// commit_author_name is the author to be applied to the cherry-picked commit. If not provided, the original commit's author name is
	// used instead.
	CommitAuthorName []byte `protobuf:"bytes,11,opt,name=commit_author_name,json=commitAuthorName,proto3" json:"commit_author_name,omitempty"`
	// commit_author_email is the author email to be applied to the cherry-picked commit. If not provided, the original commit's author email is
	// used instead.
	CommitAuthorEmail []byte `protobuf:"bytes,12,opt,name=commit_author_email,json=commitAuthorEmail,proto3" json:"commit_author_email,omitempty"`
	// sign signifies whether the commit is to be signed
	Sign          bool `protobuf:"varint,13,opt,name=sign,proto3" json:"sign,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserCherryPickRequest) ProtoMessage() {}

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

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

func (x *UserCherryPickRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

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

func (x *UserCherryPickRequest) GetBranchName() []byte {
	if x != nil {
		return x.BranchName
	}
	return nil
}

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

func (x *UserCherryPickRequest) GetStartBranchName() []byte {
	if x != nil {
		return x.StartBranchName
	}
	return nil
}

func (x *UserCherryPickRequest) GetStartRepository() *Repository {
	if x != nil {
		return x.StartRepository
	}
	return nil
}

func (x *UserCherryPickRequest) GetDryRun() bool {
	if x != nil {
		return x.DryRun
	}
	return false
}

func (x *UserCherryPickRequest) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *UserCherryPickRequest) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

func (x *UserCherryPickRequest) GetCommitAuthorName() []byte {
	if x != nil {
		return x.CommitAuthorName
	}
	return nil
}

func (x *UserCherryPickRequest) GetCommitAuthorEmail() []byte {
	if x != nil {
		return x.CommitAuthorEmail
	}
	return nil
}

func (x *UserCherryPickRequest) GetSign() bool {
	if x != nil {
		return x.Sign
	}
	return false
}

// UserCherryPickResponse is a response for the UserCherryPick RPC.
type UserCherryPickResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// branch_update represents details about the updated branch.
	BranchUpdate  *OperationBranchUpdate `protobuf:"bytes,1,opt,name=branch_update,json=branchUpdate,proto3" json:"branch_update,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserCherryPickResponse) ProtoMessage() {}

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

func (x *UserCherryPickResponse) GetBranchUpdate() *OperationBranchUpdate {
	if x != nil {
		return x.BranchUpdate
	}
	return nil
}

// UserCherryPickError is an error returned by the UserCherryPick RPC.
type UserCherryPickError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserCherryPickError_CherryPickConflict
	//	*UserCherryPickError_TargetBranchDiverged
	//	*UserCherryPickError_ChangesAlreadyApplied
	//	*UserCherryPickError_AccessCheck
	Error         isUserCherryPickError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserCherryPickError) ProtoMessage() {}

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

// Deprecated: Use UserCherryPickError.ProtoReflect.Descriptor instead.
func (*UserCherryPickError) Descriptor() ([]byte, []int) {
	return file_operations_proto_rawDescGZIP(), []int{26}
}

func (x *UserCherryPickError) GetError() isUserCherryPickError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserCherryPickError) GetCherryPickConflict() *MergeConflictError {
	if x != nil {
		if x, ok := x.Error.(*UserCherryPickError_CherryPickConflict); ok {
			return x.CherryPickConflict
		}
	}
	return nil
}

func (x *UserCherryPickError) GetTargetBranchDiverged() *NotAncestorError {
	if x != nil {
		if x, ok := x.Error.(*UserCherryPickError_TargetBranchDiverged); ok {
			return x.TargetBranchDiverged
		}
	}
	return nil
}

func (x *UserCherryPickError) GetChangesAlreadyApplied() *ChangesAlreadyAppliedError {
	if x != nil {
		if x, ok := x.Error.(*UserCherryPickError_ChangesAlreadyApplied); ok {
			return x.ChangesAlreadyApplied
		}
	}
	return nil
}

func (x *UserCherryPickError) GetAccessCheck() *AccessCheckError {
	if x != nil {
		if x, ok := x.Error.(*UserCherryPickError_AccessCheck); ok {
			return x.AccessCheck
		}
	}
	return nil
}

type isUserCherryPickError_Error interface {
	isUserCherryPickError_Error()
}

type UserCherryPickError_CherryPickConflict struct {
	// cherry_pick_conflict is returned if there is a conflict when applying the cherry
	// pick.
	CherryPickConflict *MergeConflictError `protobuf:"bytes,1,opt,name=cherry_pick_conflict,json=cherryPickConflict,proto3,oneof"`
}

type UserCherryPickError_TargetBranchDiverged struct {
	// target_branch_diverged is returned whenever the tip commit of the branch we're
	// about to apply the new commit on is not a direct ancestor of the newly created
	// cherry-picked commit. This may happen either due to a race where the reference
	// is modified while we compute the cherry-picked commit, or alternatively if the
	// commit fetched from the start branch of the remote repository is not an ancestor
	// of of the local target branch.
	TargetBranchDiverged *NotAncestorError `protobuf:"bytes,2,opt,name=target_branch_diverged,json=targetBranchDiverged,proto3,oneof"`
}

type UserCherryPickError_ChangesAlreadyApplied struct {
	// changes_already_applied is returned if the result after applying the cherry pick is empty.
	ChangesAlreadyApplied *ChangesAlreadyAppliedError `protobuf:"bytes,3,opt,name=changes_already_applied,json=changesAlreadyApplied,proto3,oneof"`
}

type UserCherryPickError_AccessCheck struct {
	// access_check is set if the RPC failed due to an external access check.
	AccessCheck *AccessCheckError `protobuf:"bytes,4,opt,name=access_check,json=accessCheck,proto3,oneof"`
}

func (*UserCherryPickError_CherryPickConflict) isUserCherryPickError_Error() {}

func (*UserCherryPickError_TargetBranchDiverged) isUserCherryPickError_Error() {}

func (*UserCherryPickError_ChangesAlreadyApplied) isUserCherryPickError_Error() {}

func (*UserCherryPickError_AccessCheck) isUserCherryPickError_Error() {}

// UserRevertRequest is a request for the UserRevert RPC.
type UserRevertRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which the revert shall be applied.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// commit is the commit to revert. Only the `id` field is required.
	Commit *GitCommit `protobuf:"bytes,3,opt,name=commit,proto3" json:"commit,omitempty"`
	// branch_name is the name of the branch onto which the reverted commit shall
	// be committed.
	BranchName []byte `protobuf:"bytes,4,opt,name=branch_name,json=branchName,proto3" json:"branch_name,omitempty"`
	// message is the message to use for the revert commit.
	Message []byte `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
	// start_branch_name is is used in case the branch_name branch does not
	// exist. In that case, it will be created from the start_branch_name.
	StartBranchName []byte `protobuf:"bytes,6,opt,name=start_branch_name,json=startBranchName,proto3" json:"start_branch_name,omitempty"`
	// start_repository is used in case the branch_name branch does not exist. In
	// that case, it will be created from start_branch_name in the
	// start_repository.
	StartRepository *Repository `protobuf:"bytes,7,opt,name=start_repository,json=startRepository,proto3" json:"start_repository,omitempty"`
	// dry_run  will compute the revert, but not update the target branch.
	DryRun bool `protobuf:"varint,8,opt,name=dry_run,json=dryRun,proto3" json:"dry_run,omitempty"`
	// timestamp is the optional timestamp to use for the created cherry-picked
	// commit's committer date. If it's not set, the current time will be used.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// expected_old_oid is the object ID which branch is expected to point to.
	// This is used as a safety guard to avoid races when branch has been
	// updated meanwhile to point to a different object ID. Only applicable when
	// branch_name is set.
	//
	// If unset, the target branch will be overwritten regardless of its current
	// state. If set, it must either contain a valid, full object ID  or the
	// zero object ID in case the branch should be created. Otherwise, this RPC
	// will return an error.
	ExpectedOldOid string `protobuf:"bytes,10,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	// sign controls whether a commit created by Gitaly must be signed using
	// a signing key configured system-wide.
	Sign          bool `protobuf:"varint,11,opt,name=sign,proto3" json:"sign,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserRevertRequest) ProtoMessage() {}

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

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

func (x *UserRevertRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

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

func (x *UserRevertRequest) GetBranchName() []byte {
	if x != nil {
		return x.BranchName
	}
	return nil
}

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

func (x *UserRevertRequest) GetStartBranchName() []byte {
	if x != nil {
		return x.StartBranchName
	}
	return nil
}

func (x *UserRevertRequest) GetStartRepository() *Repository {
	if x != nil {
		return x.StartRepository
	}
	return nil
}

func (x *UserRevertRequest) GetDryRun() bool {
	if x != nil {
		return x.DryRun
	}
	return false
}

func (x *UserRevertRequest) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *UserRevertRequest) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

func (x *UserRevertRequest) GetSign() bool {
	if x != nil {
		return x.Sign
	}
	return false
}

// UserRevertResponse is a response for the UserRevert RPC.
type UserRevertResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// branch_update represents details about the updated branch.
	BranchUpdate *OperationBranchUpdate `protobuf:"bytes,1,opt,name=branch_update,json=branchUpdate,proto3" json:"branch_update,omitempty"`
	// create_tree_error contains the error message if creation of the tree
	// failed.
	CreateTreeError string `protobuf:"bytes,2,opt,name=create_tree_error,json=createTreeError,proto3" json:"create_tree_error,omitempty"`
	// commit_error contains the error message if updating the reference failed.
	CommitError string `protobuf:"bytes,3,opt,name=commit_error,json=commitError,proto3" json:"commit_error,omitempty"`
	// pre_receive_error contains the error message if the pre-receive hook
	// failed.
	PreReceiveError string `protobuf:"bytes,4,opt,name=pre_receive_error,json=preReceiveError,proto3" json:"pre_receive_error,omitempty"`
	// create_tree_error_code contains the error code if creation of the tree
	// failed.
	CreateTreeErrorCode UserRevertResponse_CreateTreeError `protobuf:"varint,5,opt,name=create_tree_error_code,json=createTreeErrorCode,proto3,enum=gitaly.UserRevertResponse_CreateTreeError" json:"create_tree_error_code,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*UserRevertResponse) ProtoMessage() {}

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

func (x *UserRevertResponse) GetBranchUpdate() *OperationBranchUpdate {
	if x != nil {
		return x.BranchUpdate
	}
	return nil
}

func (x *UserRevertResponse) GetCreateTreeError() string {
	if x != nil {
		return x.CreateTreeError
	}
	return ""
}

func (x *UserRevertResponse) GetCommitError() string {
	if x != nil {
		return x.CommitError
	}
	return ""
}

func (x *UserRevertResponse) GetPreReceiveError() string {
	if x != nil {
		return x.PreReceiveError
	}
	return ""
}

func (x *UserRevertResponse) GetCreateTreeErrorCode() UserRevertResponse_CreateTreeError {
	if x != nil {
		return x.CreateTreeErrorCode
	}
	return UserRevertResponse_NONE
}

// UserRevertError is an error returned by the UserRevert RPC.
type UserRevertError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserRevertError_MergeConflict
	//	*UserRevertError_ChangesAlreadyApplied
	//	*UserRevertError_CustomHook
	//	*UserRevertError_NotAncestor
	Error         isUserRevertError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserRevertError) ProtoMessage() {}

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

func (x *UserRevertError) GetError() isUserRevertError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserRevertError) GetMergeConflict() *MergeConflictError {
	if x != nil {
		if x, ok := x.Error.(*UserRevertError_MergeConflict); ok {
			return x.MergeConflict
		}
	}
	return nil
}

func (x *UserRevertError) GetChangesAlreadyApplied() *ChangesAlreadyAppliedError {
	if x != nil {
		if x, ok := x.Error.(*UserRevertError_ChangesAlreadyApplied); ok {
			return x.ChangesAlreadyApplied
		}
	}
	return nil
}

func (x *UserRevertError) GetCustomHook() *CustomHookError {
	if x != nil {
		if x, ok := x.Error.(*UserRevertError_CustomHook); ok {
			return x.CustomHook
		}
	}
	return nil
}

func (x *UserRevertError) GetNotAncestor() *NotAncestorError {
	if x != nil {
		if x, ok := x.Error.(*UserRevertError_NotAncestor); ok {
			return x.NotAncestor
		}
	}
	return nil
}

type isUserRevertError_Error interface {
	isUserRevertError_Error()
}

type UserRevertError_MergeConflict struct {
	// merge_conflict is returned if there is a conflict when applying the revert.
	MergeConflict *MergeConflictError `protobuf:"bytes,1,opt,name=merge_conflict,json=mergeConflict,proto3,oneof"`
}

type UserRevertError_ChangesAlreadyApplied struct {
	// changes_already_applied is returned if the result after applying the revert is empty.
	ChangesAlreadyApplied *ChangesAlreadyAppliedError `protobuf:"bytes,2,opt,name=changes_already_applied,json=changesAlreadyApplied,proto3,oneof"`
}

type UserRevertError_CustomHook struct {
	// custom_hook contains the error message if the pre-receive hook failed.
	CustomHook *CustomHookError `protobuf:"bytes,3,opt,name=custom_hook,json=customHook,proto3,oneof"`
}

type UserRevertError_NotAncestor struct {
	// not_ancestor is returned if the old tip of the target branch is not an ancestor of the new commit.
	NotAncestor *NotAncestorError `protobuf:"bytes,4,opt,name=not_ancestor,json=notAncestor,proto3,oneof"`
}

func (*UserRevertError_MergeConflict) isUserRevertError_Error() {}

func (*UserRevertError_ChangesAlreadyApplied) isUserRevertError_Error() {}

func (*UserRevertError_CustomHook) isUserRevertError_Error() {}

func (*UserRevertError_NotAncestor) isUserRevertError_Error() {}

// UserCommitFilesActionHeader contains the details of the action to be performed.
type UserCommitFilesActionHeader struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// action is the type of the action taken to build a commit. Not all fields are
	// used for all of the actions.
	Action UserCommitFilesActionHeader_ActionType `protobuf:"varint,1,opt,name=action,proto3,enum=gitaly.UserCommitFilesActionHeader_ActionType" json:"action,omitempty"`
	// file_path refers to the file or directory being modified. The meaning differs for each
	// action:
	//  1. CREATE: path of the file to create
	//  2. CREATE_DIR: path of the directory to create
	//  3. UPDATE: path of the file to update
	//  4. MOVE: the new path of the moved file
	//  5. DELETE: path of the file to delete
	//  6. CHMOD: path of the file to modify permissions for
	FilePath []byte `protobuf:"bytes,2,opt,name=file_path,json=filePath,proto3" json:"file_path,omitempty"`
	// previous_path is used in MOVE action to specify the path of the file to move.
	PreviousPath []byte `protobuf:"bytes,3,opt,name=previous_path,json=previousPath,proto3" json:"previous_path,omitempty"`
	// base64_content indicates the content of the file is base64 encoded. The encoding
	// must be the standard base64 encoding defined in RFC 4648. Only used for CREATE and
	// UPDATE actions.
	Base64Content bool `protobuf:"varint,4,opt,name=base64_content,json=base64Content,proto3" json:"base64_content,omitempty"`
	// execute_filemode determines whether the file is created with execute permissions.
	// The field is only used in CREATE and CHMOD actions.
	ExecuteFilemode bool `protobuf:"varint,5,opt,name=execute_filemode,json=executeFilemode,proto3" json:"execute_filemode,omitempty"`
	// infer_content should be set to true for move actions that change the file path, but not
	// its content. It should be set instead of populating the content field. Ignored for
	// other action types.
	InferContent  bool `protobuf:"varint,6,opt,name=infer_content,json=inferContent,proto3" json:"infer_content,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserCommitFilesActionHeader) ProtoMessage() {}

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

func (x *UserCommitFilesActionHeader) GetAction() UserCommitFilesActionHeader_ActionType {
	if x != nil {
		return x.Action
	}
	return UserCommitFilesActionHeader_CREATE
}

func (x *UserCommitFilesActionHeader) GetFilePath() []byte {
	if x != nil {
		return x.FilePath
	}
	return nil
}

func (x *UserCommitFilesActionHeader) GetPreviousPath() []byte {
	if x != nil {
		return x.PreviousPath
	}
	return nil
}

func (x *UserCommitFilesActionHeader) GetBase64Content() bool {
	if x != nil {
		return x.Base64Content
	}
	return false
}

func (x *UserCommitFilesActionHeader) GetExecuteFilemode() bool {
	if x != nil {
		return x.ExecuteFilemode
	}
	return false
}

func (x *UserCommitFilesActionHeader) GetInferContent() bool {
	if x != nil {
		return x.InferContent
	}
	return false
}

// UserCommitFilesAction is the request message used to stream in the actions to build a commit.
type UserCommitFilesAction struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to UserCommitFilesActionPayload:
	//
	//	*UserCommitFilesAction_Header
	//	*UserCommitFilesAction_Content
	UserCommitFilesActionPayload isUserCommitFilesAction_UserCommitFilesActionPayload `protobuf_oneof:"user_commit_files_action_payload"`
	unknownFields                protoimpl.UnknownFields
	sizeCache                    protoimpl.SizeCache
}

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

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

func (*UserCommitFilesAction) ProtoMessage() {}

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

// Deprecated: Use UserCommitFilesAction.ProtoReflect.Descriptor instead.
func (*UserCommitFilesAction) Descriptor() ([]byte, []int) {
	return file_operations_proto_rawDescGZIP(), []int{31}
}

func (x *UserCommitFilesAction) GetUserCommitFilesActionPayload() isUserCommitFilesAction_UserCommitFilesActionPayload {
	if x != nil {
		return x.UserCommitFilesActionPayload
	}
	return nil
}

func (x *UserCommitFilesAction) GetHeader() *UserCommitFilesActionHeader {
	if x != nil {
		if x, ok := x.UserCommitFilesActionPayload.(*UserCommitFilesAction_Header); ok {
			return x.Header
		}
	}
	return nil
}

func (x *UserCommitFilesAction) GetContent() []byte {
	if x != nil {
		if x, ok := x.UserCommitFilesActionPayload.(*UserCommitFilesAction_Content); ok {
			return x.Content
		}
	}
	return nil
}

type isUserCommitFilesAction_UserCommitFilesActionPayload interface {
	isUserCommitFilesAction_UserCommitFilesActionPayload()
}

type UserCommitFilesAction_Header struct {
	// header contains the details of action being performed. Header must be sent before the
	// content if content is used by the action.
	Header *UserCommitFilesActionHeader `protobuf:"bytes,1,opt,name=header,proto3,oneof"`
}

type UserCommitFilesAction_Content struct {
	// content is the content of the file streamed in one or more messages. Only used with CREATE
	// and UPDATE actions.
	Content []byte `protobuf:"bytes,2,opt,name=content,proto3,oneof"`
}

func (*UserCommitFilesAction_Header) isUserCommitFilesAction_UserCommitFilesActionPayload() {}

func (*UserCommitFilesAction_Content) isUserCommitFilesAction_UserCommitFilesActionPayload() {}

// UserCommitFilesRequestHeader is the header of the UserCommitFiles that defines the commit details,
// parent and other information related to the call.
type UserCommitFilesRequestHeader struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the target repository where to apply the commit.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// branch_name is the name of the branch to point to the new commit. If start_sha and start_branch_name
	// are not defined, the commit of branch_name is used as the parent commit.
	BranchName []byte `protobuf:"bytes,3,opt,name=branch_name,json=branchName,proto3" json:"branch_name,omitempty"`
	// commit_message is the message to use in the commit.
	CommitMessage []byte `protobuf:"bytes,4,opt,name=commit_message,json=commitMessage,proto3" json:"commit_message,omitempty"`
	// commit_author_name is the commit author's name. If not provided, the user's name is
	// used instead.
	CommitAuthorName []byte `protobuf:"bytes,5,opt,name=commit_author_name,json=commitAuthorName,proto3" json:"commit_author_name,omitempty"`
	// commit_author_email is the commit author's email. If not provided, the user's email is
	// used instead.
	CommitAuthorEmail []byte `protobuf:"bytes,6,opt,name=commit_author_email,json=commitAuthorEmail,proto3" json:"commit_author_email,omitempty"`
	// start_branch_name specifies the branch whose commit to use as the parent commit. Takes priority
	// over branch_name. Optional.
	StartBranchName []byte `protobuf:"bytes,7,opt,name=start_branch_name,json=startBranchName,proto3" json:"start_branch_name,omitempty"`
	// start_repository specifies which contains the parent commit. If not specified, repository itself
	// is used to look up the parent commit. Optional.
	StartRepository *Repository `protobuf:"bytes,8,opt,name=start_repository,json=startRepository,proto3" json:"start_repository,omitempty"`
	// force determines whether to force update the target branch specified by branch_name to
	// point to the new commit.
	Force bool `protobuf:"varint,9,opt,name=force,proto3" json:"force,omitempty"`
	// start_sha specifies the SHA of the commit to use as the parent of new commit. Takes priority
	// over start_branch_name and branch_name. Optional.
	StartSha string `protobuf:"bytes,10,opt,name=start_sha,json=startSha,proto3" json:"start_sha,omitempty"`
	// timestamp is the optional timestamp to use for the commits as author and
	// committer date. If it's not set, the current time will be used.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// expected_old_oid is the object ID which branch is expected to point to.
	// This is used as a safety guard to avoid races when branch has been
	// updated meanwhile to point to a different object ID. Only applicable when
	// branch_name is set.
	//
	// If unset, the target branch will be overwritten regardless of its current
	// state. If set, it must either contain a valid, full object ID  or the
	// zero object ID in case the branch should be created. Otherwise, this RPC
	// will return an error.
	ExpectedOldOid string `protobuf:"bytes,12,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	// sign controls whether a commit created by Gitaly must be signed using
	// a signing key configured system-wide.
	Sign          bool `protobuf:"varint,13,opt,name=sign,proto3" json:"sign,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserCommitFilesRequestHeader) ProtoMessage() {}

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

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

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

func (x *UserCommitFilesRequestHeader) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserCommitFilesRequestHeader) GetBranchName() []byte {
	if x != nil {
		return x.BranchName
	}
	return nil
}

func (x *UserCommitFilesRequestHeader) GetCommitMessage() []byte {
	if x != nil {
		return x.CommitMessage
	}
	return nil
}

func (x *UserCommitFilesRequestHeader) GetCommitAuthorName() []byte {
	if x != nil {
		return x.CommitAuthorName
	}
	return nil
}

func (x *UserCommitFilesRequestHeader) GetCommitAuthorEmail() []byte {
	if x != nil {
		return x.CommitAuthorEmail
	}
	return nil
}

func (x *UserCommitFilesRequestHeader) GetStartBranchName() []byte {
	if x != nil {
		return x.StartBranchName
	}
	return nil
}

func (x *UserCommitFilesRequestHeader) GetStartRepository() *Repository {
	if x != nil {
		return x.StartRepository
	}
	return nil
}

func (x *UserCommitFilesRequestHeader) GetForce() bool {
	if x != nil {
		return x.Force
	}
	return false
}

func (x *UserCommitFilesRequestHeader) GetStartSha() string {
	if x != nil {
		return x.StartSha
	}
	return ""
}

func (x *UserCommitFilesRequestHeader) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *UserCommitFilesRequestHeader) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

func (x *UserCommitFilesRequestHeader) GetSign() bool {
	if x != nil {
		return x.Sign
	}
	return false
}

// UserCommitFilesRequest is the request of UserCommitFiles.
type UserCommitFilesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to UserCommitFilesRequestPayload:
	//
	//	*UserCommitFilesRequest_Header
	//	*UserCommitFilesRequest_Action
	UserCommitFilesRequestPayload isUserCommitFilesRequest_UserCommitFilesRequestPayload `protobuf_oneof:"user_commit_files_request_payload"`
	unknownFields                 protoimpl.UnknownFields
	sizeCache                     protoimpl.SizeCache
}

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

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

func (*UserCommitFilesRequest) ProtoMessage() {}

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

// Deprecated: Use UserCommitFilesRequest.ProtoReflect.Descriptor instead.
func (*UserCommitFilesRequest) Descriptor() ([]byte, []int) {
	return file_operations_proto_rawDescGZIP(), []int{33}
}

func (x *UserCommitFilesRequest) GetUserCommitFilesRequestPayload() isUserCommitFilesRequest_UserCommitFilesRequestPayload {
	if x != nil {
		return x.UserCommitFilesRequestPayload
	}
	return nil
}

func (x *UserCommitFilesRequest) GetHeader() *UserCommitFilesRequestHeader {
	if x != nil {
		if x, ok := x.UserCommitFilesRequestPayload.(*UserCommitFilesRequest_Header); ok {
			return x.Header
		}
	}
	return nil
}

func (x *UserCommitFilesRequest) GetAction() *UserCommitFilesAction {
	if x != nil {
		if x, ok := x.UserCommitFilesRequestPayload.(*UserCommitFilesRequest_Action); ok {
			return x.Action
		}
	}
	return nil
}

type isUserCommitFilesRequest_UserCommitFilesRequestPayload interface {
	isUserCommitFilesRequest_UserCommitFilesRequestPayload()
}

type UserCommitFilesRequest_Header struct {
	// header defines the details of where to commit, the details and which commit to use as the parent.
	// header must always be sent as the first request of the stream.
	Header *UserCommitFilesRequestHeader `protobuf:"bytes,1,opt,name=header,proto3,oneof"`
}

type UserCommitFilesRequest_Action struct {
	// action contains an action to build a commit. There can be multiple actions per stream.
	Action *UserCommitFilesAction `protobuf:"bytes,2,opt,name=action,proto3,oneof"`
}

func (*UserCommitFilesRequest_Header) isUserCommitFilesRequest_UserCommitFilesRequestPayload() {}

func (*UserCommitFilesRequest_Action) isUserCommitFilesRequest_UserCommitFilesRequestPayload() {}

// UserCommitFilesResponse is the response object of UserCommitFiles.
type UserCommitFilesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// branch_update contains the details of the commit and the branch update.
	BranchUpdate *OperationBranchUpdate `protobuf:"bytes,1,opt,name=branch_update,json=branchUpdate,proto3" json:"branch_update,omitempty"`
	// index_error is set to the error message when an invalid action was attempted, such as
	// trying to create a file that already existed.
	IndexError string `protobuf:"bytes,2,opt,name=index_error,json=indexError,proto3" json:"index_error,omitempty"`
	// pre_receive_error is set when the pre-receive hook errored.
	PreReceiveError string `protobuf:"bytes,3,opt,name=pre_receive_error,json=preReceiveError,proto3" json:"pre_receive_error,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*UserCommitFilesResponse) ProtoMessage() {}

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

// Deprecated: Use UserCommitFilesResponse.ProtoReflect.Descriptor instead.
func (*UserCommitFilesResponse) Descriptor() ([]byte, []int) {
	return file_operations_proto_rawDescGZIP(), []int{34}
}

func (x *UserCommitFilesResponse) GetBranchUpdate() *OperationBranchUpdate {
	if x != nil {
		return x.BranchUpdate
	}
	return nil
}

func (x *UserCommitFilesResponse) GetIndexError() string {
	if x != nil {
		return x.IndexError
	}
	return ""
}

func (x *UserCommitFilesResponse) GetPreReceiveError() string {
	if x != nil {
		return x.PreReceiveError
	}
	return ""
}

// UserCommitFilesError is an error returned by the UserCommitFiles RPC in some specific well
// defined error cases.
type UserCommitFilesError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserCommitFilesError_AccessCheck
	//	*UserCommitFilesError_IndexUpdate
	//	*UserCommitFilesError_CustomHook
	Error         isUserCommitFilesError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserCommitFilesError) ProtoMessage() {}

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

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

func (x *UserCommitFilesError) GetError() isUserCommitFilesError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserCommitFilesError) GetAccessCheck() *AccessCheckError {
	if x != nil {
		if x, ok := x.Error.(*UserCommitFilesError_AccessCheck); ok {
			return x.AccessCheck
		}
	}
	return nil
}

func (x *UserCommitFilesError) GetIndexUpdate() *IndexError {
	if x != nil {
		if x, ok := x.Error.(*UserCommitFilesError_IndexUpdate); ok {
			return x.IndexUpdate
		}
	}
	return nil
}

func (x *UserCommitFilesError) GetCustomHook() *CustomHookError {
	if x != nil {
		if x, ok := x.Error.(*UserCommitFilesError_CustomHook); ok {
			return x.CustomHook
		}
	}
	return nil
}

type isUserCommitFilesError_Error interface {
	isUserCommitFilesError_Error()
}

type UserCommitFilesError_AccessCheck struct {
	// access_check is set if the RPC failed due to an external access check.
	AccessCheck *AccessCheckError `protobuf:"bytes,1,opt,name=access_check,json=accessCheck,proto3,oneof"`
}

type UserCommitFilesError_IndexUpdate struct {
	// index_update is set to the error message when an operation conflicts with the repository
	// index, such as creating a file that already exists.
	IndexUpdate *IndexError `protobuf:"bytes,2,opt,name=index_update,json=indexUpdate,proto3,oneof"`
}

type UserCommitFilesError_CustomHook struct {
	// custom_hook is set if any custom hook which has running as part of this RPC call has returned
	// a non-zero exit code.
	CustomHook *CustomHookError `protobuf:"bytes,3,opt,name=custom_hook,json=customHook,proto3,oneof"`
}

func (*UserCommitFilesError_AccessCheck) isUserCommitFilesError_Error() {}

func (*UserCommitFilesError_IndexUpdate) isUserCommitFilesError_Error() {}

func (*UserCommitFilesError_CustomHook) isUserCommitFilesError_Error() {}

// UserRebaseConfirmableRequest is a request for the UserRebaseConfirmable RPC.
type UserRebaseConfirmableRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to UserRebaseConfirmableRequestPayload:
	//
	//	*UserRebaseConfirmableRequest_Header_
	//	*UserRebaseConfirmableRequest_Apply
	UserRebaseConfirmableRequestPayload isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload `protobuf_oneof:"user_rebase_confirmable_request_payload"`
	unknownFields                       protoimpl.UnknownFields
	sizeCache                           protoimpl.SizeCache
}

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

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

func (*UserRebaseConfirmableRequest) ProtoMessage() {}

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

// Deprecated: Use UserRebaseConfirmableRequest.ProtoReflect.Descriptor instead.
func (*UserRebaseConfirmableRequest) Descriptor() ([]byte, []int) {
	return file_operations_proto_rawDescGZIP(), []int{36}
}

func (x *UserRebaseConfirmableRequest) GetUserRebaseConfirmableRequestPayload() isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload {
	if x != nil {
		return x.UserRebaseConfirmableRequestPayload
	}
	return nil
}

func (x *UserRebaseConfirmableRequest) GetHeader() *UserRebaseConfirmableRequest_Header {
	if x != nil {
		if x, ok := x.UserRebaseConfirmableRequestPayload.(*UserRebaseConfirmableRequest_Header_); ok {
			return x.Header
		}
	}
	return nil
}

func (x *UserRebaseConfirmableRequest) GetApply() bool {
	if x != nil {
		if x, ok := x.UserRebaseConfirmableRequestPayload.(*UserRebaseConfirmableRequest_Apply); ok {
			return x.Apply
		}
	}
	return false
}

type isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload interface {
	isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload()
}

type UserRebaseConfirmableRequest_Header_ struct {
	// header must be the first request for each request stream
	// containing details about the rebase to perform.
	Header *UserRebaseConfirmableRequest_Header `protobuf:"bytes,1,opt,name=header,proto3,oneof"`
}

type UserRebaseConfirmableRequest_Apply struct {
	// apply is the second request that must be made to confirm that
	// the rebase should be applied to the branch.
	Apply bool `protobuf:"varint,2,opt,name=apply,proto3,oneof"`
}

func (*UserRebaseConfirmableRequest_Header_) isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload() {
}

func (*UserRebaseConfirmableRequest_Apply) isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload() {
}

// UserRebaseConfirmableResponse is a response for the UserRebaseConfirmable RPC.
type UserRebaseConfirmableResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to UserRebaseConfirmableResponsePayload:
	//
	//	*UserRebaseConfirmableResponse_RebaseSha
	//	*UserRebaseConfirmableResponse_RebaseApplied
	UserRebaseConfirmableResponsePayload isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload `protobuf_oneof:"user_rebase_confirmable_response_payload"`
	unknownFields                        protoimpl.UnknownFields
	sizeCache                            protoimpl.SizeCache
}

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

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

func (*UserRebaseConfirmableResponse) ProtoMessage() {}

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

// Deprecated: Use UserRebaseConfirmableResponse.ProtoReflect.Descriptor instead.
func (*UserRebaseConfirmableResponse) Descriptor() ([]byte, []int) {
	return file_operations_proto_rawDescGZIP(), []int{37}
}

func (x *UserRebaseConfirmableResponse) GetUserRebaseConfirmableResponsePayload() isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload {
	if x != nil {
		return x.UserRebaseConfirmableResponsePayload
	}
	return nil
}

func (x *UserRebaseConfirmableResponse) GetRebaseSha() string {
	if x != nil {
		if x, ok := x.UserRebaseConfirmableResponsePayload.(*UserRebaseConfirmableResponse_RebaseSha); ok {
			return x.RebaseSha
		}
	}
	return ""
}

func (x *UserRebaseConfirmableResponse) GetRebaseApplied() bool {
	if x != nil {
		if x, ok := x.UserRebaseConfirmableResponsePayload.(*UserRebaseConfirmableResponse_RebaseApplied); ok {
			return x.RebaseApplied
		}
	}
	return false
}

type isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload interface {
	isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload()
}

type UserRebaseConfirmableResponse_RebaseSha struct {
	// rebase_sha is the commit the branch will be updated to, it will be present
	// in the first response. The caller can still abort the rebase.
	RebaseSha string `protobuf:"bytes,1,opt,name=rebase_sha,json=rebaseSha,proto3,oneof"`
}

type UserRebaseConfirmableResponse_RebaseApplied struct {
	// rebase_applied confirms that the rebase has been applied to the branch.
	// It is present in the second response.
	RebaseApplied bool `protobuf:"varint,2,opt,name=rebase_applied,json=rebaseApplied,proto3,oneof"`
}

func (*UserRebaseConfirmableResponse_RebaseSha) isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload() {
}

func (*UserRebaseConfirmableResponse_RebaseApplied) isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload() {
}

// UserSquashRequest is a request for the UserSquash RPC.
type UserSquashRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository into which the squashed commit shall be
	// written.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// start_sha is the object ID of the start commit of the range which shall be
	// squashed. Must be an ancestor of end_sha.
	StartSha string `protobuf:"bytes,5,opt,name=start_sha,json=startSha,proto3" json:"start_sha,omitempty"`
	// end_sha is the object ID of the end commit of the range which shall be
	// squashed.
	EndSha string `protobuf:"bytes,6,opt,name=end_sha,json=endSha,proto3" json:"end_sha,omitempty"`
	// author will be used as the author of the squashed commit.
	Author *User `protobuf:"bytes,7,opt,name=author,proto3" json:"author,omitempty"`
	// commit_message is the message to be used for the squashed commit.
	CommitMessage []byte `protobuf:"bytes,8,opt,name=commit_message,json=commitMessage,proto3" json:"commit_message,omitempty"`
	// timestamp is the optional timestamp to use for the squashed commit as
	// committer date. If it's not set, the current time will be used.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// sign signifies whether the commit is to be signed
	Sign          bool `protobuf:"varint,10,opt,name=sign,proto3" json:"sign,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserSquashRequest) ProtoMessage() {}

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

// Deprecated: Use UserSquashRequest.ProtoReflect.Descriptor instead.
func (*UserSquashRequest) Descriptor() ([]byte, []int) {
	return file_operations_proto_rawDescGZIP(), []int{38}
}

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

func (x *UserSquashRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserSquashRequest) GetStartSha() string {
	if x != nil {
		return x.StartSha
	}
	return ""
}

func (x *UserSquashRequest) GetEndSha() string {
	if x != nil {
		return x.EndSha
	}
	return ""
}

func (x *UserSquashRequest) GetAuthor() *User {
	if x != nil {
		return x.Author
	}
	return nil
}

func (x *UserSquashRequest) GetCommitMessage() []byte {
	if x != nil {
		return x.CommitMessage
	}
	return nil
}

func (x *UserSquashRequest) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *UserSquashRequest) GetSign() bool {
	if x != nil {
		return x.Sign
	}
	return false
}

// UserSquashResponse is a response for the UserSquash RPC.
type UserSquashResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// squash_sha is the object ID of the squashed commit.
	SquashSha     string `protobuf:"bytes,1,opt,name=squash_sha,json=squashSha,proto3" json:"squash_sha,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserSquashResponse) ProtoMessage() {}

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

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

func (x *UserSquashResponse) GetSquashSha() string {
	if x != nil {
		return x.SquashSha
	}
	return ""
}

// UserRebaseConfirmableError is a structured error for the UserRebaseConfirmable RPC.
type UserRebaseConfirmableError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserRebaseConfirmableError_RebaseConflict
	//	*UserRebaseConfirmableError_AccessCheck
	Error         isUserRebaseConfirmableError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserRebaseConfirmableError) ProtoMessage() {}

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

// Deprecated: Use UserRebaseConfirmableError.ProtoReflect.Descriptor instead.
func (*UserRebaseConfirmableError) Descriptor() ([]byte, []int) {
	return file_operations_proto_rawDescGZIP(), []int{40}
}

func (x *UserRebaseConfirmableError) GetError() isUserRebaseConfirmableError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserRebaseConfirmableError) GetRebaseConflict() *MergeConflictError {
	if x != nil {
		if x, ok := x.Error.(*UserRebaseConfirmableError_RebaseConflict); ok {
			return x.RebaseConflict
		}
	}
	return nil
}

func (x *UserRebaseConfirmableError) GetAccessCheck() *AccessCheckError {
	if x != nil {
		if x, ok := x.Error.(*UserRebaseConfirmableError_AccessCheck); ok {
			return x.AccessCheck
		}
	}
	return nil
}

type isUserRebaseConfirmableError_Error interface {
	isUserRebaseConfirmableError_Error()
}

type UserRebaseConfirmableError_RebaseConflict struct {
	// rebase_conflict is returned in case rebasing commits on top of the start
	// commit fails with a merge conflict and in case merge squashing commits
	// fails with a merge conflict.
	RebaseConflict *MergeConflictError `protobuf:"bytes,1,opt,name=rebase_conflict,json=rebaseConflict,proto3,oneof"`
}

type UserRebaseConfirmableError_AccessCheck struct {
	// access_check is set if the RPC failed due to an external access check.
	AccessCheck *AccessCheckError `protobuf:"bytes,2,opt,name=access_check,json=accessCheck,proto3,oneof"`
}

func (*UserRebaseConfirmableError_RebaseConflict) isUserRebaseConfirmableError_Error() {}

func (*UserRebaseConfirmableError_AccessCheck) isUserRebaseConfirmableError_Error() {}

// UserSquashError is an error that may be returned when the UserSquash RPC
// fails.
type UserSquashError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserSquashError_ResolveRevision
	//	*UserSquashError_RebaseConflict
	Error         isUserSquashError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserSquashError) ProtoMessage() {}

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

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

func (x *UserSquashError) GetError() isUserSquashError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserSquashError) GetResolveRevision() *ResolveRevisionError {
	if x != nil {
		if x, ok := x.Error.(*UserSquashError_ResolveRevision); ok {
			return x.ResolveRevision
		}
	}
	return nil
}

func (x *UserSquashError) GetRebaseConflict() *MergeConflictError {
	if x != nil {
		if x, ok := x.Error.(*UserSquashError_RebaseConflict); ok {
			return x.RebaseConflict
		}
	}
	return nil
}

type isUserSquashError_Error interface {
	isUserSquashError_Error()
}

type UserSquashError_ResolveRevision struct {
	// resolve_revision is returned in case resolving either the start or end
	// revision has failed.
	ResolveRevision *ResolveRevisionError `protobuf:"bytes,1,opt,name=resolve_revision,json=resolveRevision,proto3,oneof"`
}

type UserSquashError_RebaseConflict struct {
	// rebase_conflict is returned in case rebasing commits on top of the start
	// commit fails with a merge conflict.
	RebaseConflict *MergeConflictError `protobuf:"bytes,2,opt,name=rebase_conflict,json=rebaseConflict,proto3,oneof"`
}

func (*UserSquashError_ResolveRevision) isUserSquashError_Error() {}

func (*UserSquashError_RebaseConflict) isUserSquashError_Error() {}

// UserApplyPatchRequest is a request for the UserApplyPatch RPC.
type UserApplyPatchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to UserApplyPatchRequestPayload:
	//
	//	*UserApplyPatchRequest_Header_
	//	*UserApplyPatchRequest_Patches
	UserApplyPatchRequestPayload isUserApplyPatchRequest_UserApplyPatchRequestPayload `protobuf_oneof:"user_apply_patch_request_payload"`
	unknownFields                protoimpl.UnknownFields
	sizeCache                    protoimpl.SizeCache
}

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

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

func (*UserApplyPatchRequest) ProtoMessage() {}

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

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

func (x *UserApplyPatchRequest) GetUserApplyPatchRequestPayload() isUserApplyPatchRequest_UserApplyPatchRequestPayload {
	if x != nil {
		return x.UserApplyPatchRequestPayload
	}
	return nil
}

func (x *UserApplyPatchRequest) GetHeader() *UserApplyPatchRequest_Header {
	if x != nil {
		if x, ok := x.UserApplyPatchRequestPayload.(*UserApplyPatchRequest_Header_); ok {
			return x.Header
		}
	}
	return nil
}

func (x *UserApplyPatchRequest) GetPatches() []byte {
	if x != nil {
		if x, ok := x.UserApplyPatchRequestPayload.(*UserApplyPatchRequest_Patches); ok {
			return x.Patches
		}
	}
	return nil
}

type isUserApplyPatchRequest_UserApplyPatchRequestPayload interface {
	isUserApplyPatchRequest_UserApplyPatchRequestPayload()
}

type UserApplyPatchRequest_Header_ struct {
	// header must be sent as the first message and contains information about
	// how to apply the patches.
	Header *UserApplyPatchRequest_Header `protobuf:"bytes,1,opt,name=header,proto3,oneof"`
}

type UserApplyPatchRequest_Patches struct {
	// patches contains the patch data.
	Patches []byte `protobuf:"bytes,2,opt,name=patches,proto3,oneof"`
}

func (*UserApplyPatchRequest_Header_) isUserApplyPatchRequest_UserApplyPatchRequestPayload() {}

func (*UserApplyPatchRequest_Patches) isUserApplyPatchRequest_UserApplyPatchRequestPayload() {}

// UserApplyPatchError is an error returned by the UserApplyPatch RPC in some specific well
// defined error cases.
type UserApplyPatchError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserApplyPatchError_CustomHook
	Error         isUserApplyPatchError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserApplyPatchError) ProtoMessage() {}

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

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

func (x *UserApplyPatchError) GetError() isUserApplyPatchError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserApplyPatchError) GetCustomHook() *CustomHookError {
	if x != nil {
		if x, ok := x.Error.(*UserApplyPatchError_CustomHook); ok {
			return x.CustomHook
		}
	}
	return nil
}

type isUserApplyPatchError_Error interface {
	isUserApplyPatchError_Error()
}

type UserApplyPatchError_CustomHook struct {
	// custom_hook is set if any custom hook which has running as part of this RPC call has returned
	// a non-zero exit code.
	CustomHook *CustomHookError `protobuf:"bytes,1,opt,name=custom_hook,json=customHook,proto3,oneof"`
}

func (*UserApplyPatchError_CustomHook) isUserApplyPatchError_Error() {}

// UserApplyPatchResponse is a response for the UserApplyPatch RPC.
type UserApplyPatchResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// branch_update contains information about the updated branch.
	BranchUpdate  *OperationBranchUpdate `protobuf:"bytes,1,opt,name=branch_update,json=branchUpdate,proto3" json:"branch_update,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserApplyPatchResponse) ProtoMessage() {}

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

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

func (x *UserApplyPatchResponse) GetBranchUpdate() *OperationBranchUpdate {
	if x != nil {
		return x.BranchUpdate
	}
	return nil
}

// UserUpdateSubmoduleRequest is a request for the UserUpdateSubmodule RPC.
type UserUpdateSubmoduleRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which the submodule shall be updated.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// commit_sha is the object ID the submodule shall be updated to.
	CommitSha string `protobuf:"bytes,3,opt,name=commit_sha,json=commitSha,proto3" json:"commit_sha,omitempty"`
	// branch is the branch which shall be updated. This is the unqualified name
	// of the branch, it must not have a "refs/heads/" prefix.
	Branch []byte `protobuf:"bytes,4,opt,name=branch,proto3" json:"branch,omitempty"`
	// submodule is the path to the submodule which shall be updated.
	Submodule []byte `protobuf:"bytes,5,opt,name=submodule,proto3" json:"submodule,omitempty"`
	// commit_message is the message updating the submodule.
	CommitMessage []byte `protobuf:"bytes,6,opt,name=commit_message,json=commitMessage,proto3" json:"commit_message,omitempty"`
	// timestamp is the optional timestamp to use for the commit updating the
	// submodule as committer date. If it's not set, the current time will be
	// used.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// expected_old_oid is the object ID which branch is expected to point to.
	// This is used as a safety guard to avoid races when branch has been
	// updated meanwhile to point to a different object ID.
	//
	// If unset, the target branch will be overwritten regardless of its current
	// state. If set, it must either contain a valid, full object ID  or the
	// zero object ID in case the branch should be created. Otherwise, this RPC
	// will return an error.
	ExpectedOldOid string `protobuf:"bytes,8,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*UserUpdateSubmoduleRequest) ProtoMessage() {}

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

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

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

func (x *UserUpdateSubmoduleRequest) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserUpdateSubmoduleRequest) GetCommitSha() string {
	if x != nil {
		return x.CommitSha
	}
	return ""
}

func (x *UserUpdateSubmoduleRequest) GetBranch() []byte {
	if x != nil {
		return x.Branch
	}
	return nil
}

func (x *UserUpdateSubmoduleRequest) GetSubmodule() []byte {
	if x != nil {
		return x.Submodule
	}
	return nil
}

func (x *UserUpdateSubmoduleRequest) GetCommitMessage() []byte {
	if x != nil {
		return x.CommitMessage
	}
	return nil
}

func (x *UserUpdateSubmoduleRequest) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *UserUpdateSubmoduleRequest) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

// UserUpdateSubmoduleResponse is a response for the UserUpdateSubmodule RPC.
type UserUpdateSubmoduleResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// branch_update contains information about the updated branch.
	BranchUpdate *OperationBranchUpdate `protobuf:"bytes,1,opt,name=branch_update,json=branchUpdate,proto3" json:"branch_update,omitempty"`
	// pre_receive_error contains an error message if the pre-receive hook
	// rejects the update.
	PreReceiveError string `protobuf:"bytes,2,opt,name=pre_receive_error,json=preReceiveError,proto3" json:"pre_receive_error,omitempty"`
	// commit_error contains an error message if committing the update fails.
	CommitError   string `protobuf:"bytes,4,opt,name=commit_error,json=commitError,proto3" json:"commit_error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserUpdateSubmoduleResponse) ProtoMessage() {}

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

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

func (x *UserUpdateSubmoduleResponse) GetBranchUpdate() *OperationBranchUpdate {
	if x != nil {
		return x.BranchUpdate
	}
	return nil
}

func (x *UserUpdateSubmoduleResponse) GetPreReceiveError() string {
	if x != nil {
		return x.PreReceiveError
	}
	return ""
}

func (x *UserUpdateSubmoduleResponse) GetCommitError() string {
	if x != nil {
		return x.CommitError
	}
	return ""
}

// UserUpdateSubmoduleError is a structured error for the UserUpdateSubmodule RPC.
type UserUpdateSubmoduleError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Error:
	//
	//	*UserUpdateSubmoduleError_CustomHook
	//	*UserUpdateSubmoduleError_ReferenceUpdate
	//	*UserUpdateSubmoduleError_PathError
	Error         isUserUpdateSubmoduleError_Error `protobuf_oneof:"error"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserUpdateSubmoduleError) ProtoMessage() {}

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

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

func (x *UserUpdateSubmoduleError) GetError() isUserUpdateSubmoduleError_Error {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *UserUpdateSubmoduleError) GetCustomHook() *CustomHookError {
	if x != nil {
		if x, ok := x.Error.(*UserUpdateSubmoduleError_CustomHook); ok {
			return x.CustomHook
		}
	}
	return nil
}

func (x *UserUpdateSubmoduleError) GetReferenceUpdate() *ReferenceUpdateError {
	if x != nil {
		if x, ok := x.Error.(*UserUpdateSubmoduleError_ReferenceUpdate); ok {
			return x.ReferenceUpdate
		}
	}
	return nil
}

func (x *UserUpdateSubmoduleError) GetPathError() *PathError {
	if x != nil {
		if x, ok := x.Error.(*UserUpdateSubmoduleError_PathError); ok {
			return x.PathError
		}
	}
	return nil
}

type isUserUpdateSubmoduleError_Error interface {
	isUserUpdateSubmoduleError_Error()
}

type UserUpdateSubmoduleError_CustomHook struct {
	// custom_hook is set if any custom hook which has running as part of this RPC call has returned
	// a non-zero exit code.
	CustomHook *CustomHookError `protobuf:"bytes,1,opt,name=custom_hook,json=customHook,proto3,oneof"`
}

type UserUpdateSubmoduleError_ReferenceUpdate struct {
	// reference_update is set if the RPC failed because updating the
	// reference to the new object ID has failed (commiting the update).
	ReferenceUpdate *ReferenceUpdateError `protobuf:"bytes,2,opt,name=reference_update,json=referenceUpdate,proto3,oneof"`
}

type UserUpdateSubmoduleError_PathError struct {
	// path_error is set if there was a failure in reading or updatinggl the submodule path
	PathError *PathError `protobuf:"bytes,3,opt,name=path_error,json=pathError,proto3,oneof"`
}

func (*UserUpdateSubmoduleError_CustomHook) isUserUpdateSubmoduleError_Error() {}

func (*UserUpdateSubmoduleError_ReferenceUpdate) isUserUpdateSubmoduleError_Error() {}

func (*UserUpdateSubmoduleError_PathError) isUserUpdateSubmoduleError_Error() {}

// Header contains information to compute the rebase and must be sent as
// first message.
type UserRebaseConfirmableRequest_Header struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository in which the rebase will be computed and
	// applied.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// rebase_id does nothing anymore.
	//
	// Deprecated: Marked as deprecated in operations.proto.
	RebaseId string `protobuf:"bytes,3,opt,name=rebase_id,json=rebaseId,proto3" json:"rebase_id,omitempty"`
	// branch is the branch onto which the rebase shall happen.
	Branch []byte `protobuf:"bytes,4,opt,name=branch,proto3" json:"branch,omitempty"`
	// branch_sha is the expected object ID which branch currently points to.
	// This is used as a safety guard to avoid races when branch has been
	// updated meanwhile.
	BranchSha string `protobuf:"bytes,5,opt,name=branch_sha,json=branchSha,proto3" json:"branch_sha,omitempty"`
	// remote_repository is the repository which contains the branch which
	// shall be rebased onto the local branch.
	RemoteRepository *Repository `protobuf:"bytes,6,opt,name=remote_repository,json=remoteRepository,proto3" json:"remote_repository,omitempty"`
	// remote_branch contains the branch name which shall re rebased onto the
	// local branch.
	RemoteBranch []byte `protobuf:"bytes,7,opt,name=remote_branch,json=remoteBranch,proto3" json:"remote_branch,omitempty"`
	// git_push_options contain options which shall be passed to the git hooks
	// when the local branch gets updated.
	GitPushOptions []string `protobuf:"bytes,8,rep,name=git_push_options,json=gitPushOptions,proto3" json:"git_push_options,omitempty"`
	// timestamp is the optional timestamp to use for the rebased commits as
	// committer date. If it's not set, the current time will be used.
	Timestamp     *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UserRebaseConfirmableRequest_Header) ProtoMessage() {}

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

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

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

func (x *UserRebaseConfirmableRequest_Header) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

// Deprecated: Marked as deprecated in operations.proto.
func (x *UserRebaseConfirmableRequest_Header) GetRebaseId() string {
	if x != nil {
		return x.RebaseId
	}
	return ""
}

func (x *UserRebaseConfirmableRequest_Header) GetBranch() []byte {
	if x != nil {
		return x.Branch
	}
	return nil
}

func (x *UserRebaseConfirmableRequest_Header) GetBranchSha() string {
	if x != nil {
		return x.BranchSha
	}
	return ""
}

func (x *UserRebaseConfirmableRequest_Header) GetRemoteRepository() *Repository {
	if x != nil {
		return x.RemoteRepository
	}
	return nil
}

func (x *UserRebaseConfirmableRequest_Header) GetRemoteBranch() []byte {
	if x != nil {
		return x.RemoteBranch
	}
	return nil
}

func (x *UserRebaseConfirmableRequest_Header) GetGitPushOptions() []string {
	if x != nil {
		return x.GitPushOptions
	}
	return nil
}

func (x *UserRebaseConfirmableRequest_Header) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

// Header contains information about how to apply the patches.
type UserApplyPatchRequest_Header struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// repository is the repository to which the patches shall be applied to.
	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// user to execute the action as. Also used to perform authentication and
	// authorization via an external endpoint.
	User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	// target_branch is the branch onto which the patches shall be applied.
	TargetBranch []byte `protobuf:"bytes,3,opt,name=target_branch,json=targetBranch,proto3" json:"target_branch,omitempty"`
	// timestamp is the optional timestamp to use for the squashed commit as
	// committer date. If it's not set, the current time will be used.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// expected_old_oid is the object ID which branch is expected to point to.
	// This is used as a safety guard to avoid races when branch has been
	// updated meanwhile to point to a different object ID.
	//
	// If unset, the target branch will be overwritten regardless of its current
	// state. If set, it must either contain a valid, full object ID  or the
	// zero object ID in case the branch should be created. Otherwise, this RPC
	// will return an error.
	ExpectedOldOid string `protobuf:"bytes,5,opt,name=expected_old_oid,json=expectedOldOid,proto3" json:"expected_old_oid,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*UserApplyPatchRequest_Header) ProtoMessage() {}

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

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

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

func (x *UserApplyPatchRequest_Header) GetUser() *User {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *UserApplyPatchRequest_Header) GetTargetBranch() []byte {
	if x != nil {
		return x.TargetBranch
	}
	return nil
}

func (x *UserApplyPatchRequest_Header) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *UserApplyPatchRequest_Header) GetExpectedOldOid() string {
	if x != nil {
		return x.ExpectedOldOid
	}
	return ""
}

var File_operations_proto protoreflect.FileDescriptor

const file_operations_proto_rawDesc = "" +
	"\n" +
	"\x10operations.proto\x12\x06gitaly\x1a\ferrors.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\n" +
	"lint.proto\x1a\fshared.proto\"\xb7\x01\n" +
	"\x17UserCreateBranchRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1f\n" +
	"\vbranch_name\x18\x02 \x01(\fR\n" +
	"branchName\x12 \n" +
	"\x04user\x18\x03 \x01(\v2\f.gitaly.UserR\x04user\x12\x1f\n" +
	"\vstart_point\x18\x04 \x01(\fR\n" +
	"startPoint\"[\n" +
	"\x18UserCreateBranchResponse\x12&\n" +
	"\x06branch\x18\x01 \x01(\v2\x0e.gitaly.BranchR\x06branchJ\x04\b\x02\x10\x03R\x11pre_receive_error\"\\\n" +
	"\x15UserCreateBranchError\x12:\n" +
	"\vcustom_hook\x18\x01 \x01(\v2\x17.gitaly.CustomHookErrorH\x00R\n" +
	"customHookB\a\n" +
	"\x05error\"\xc6\x01\n" +
	"\x17UserUpdateBranchRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1f\n" +
	"\vbranch_name\x18\x02 \x01(\fR\n" +
	"branchName\x12 \n" +
	"\x04user\x18\x03 \x01(\v2\f.gitaly.UserR\x04user\x12\x16\n" +
	"\x06newrev\x18\x04 \x01(\fR\x06newrev\x12\x16\n" +
	"\x06oldrev\x18\x05 \x01(\fR\x06oldrev\"F\n" +
	"\x18UserUpdateBranchResponse\x12*\n" +
	"\x11pre_receive_error\x18\x01 \x01(\tR\x0fpreReceiveError\"\xc0\x01\n" +
	"\x17UserDeleteBranchRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x1f\n" +
	"\vbranch_name\x18\x02 \x01(\fR\n" +
	"branchName\x12 \n" +
	"\x04user\x18\x03 \x01(\v2\f.gitaly.UserR\x04user\x12(\n" +
	"\x10expected_old_oid\x18\x04 \x01(\tR\x0eexpectedOldOid\"3\n" +
	"\x18UserDeleteBranchResponseJ\x04\b\x01\x10\x02R\x11pre_receive_error\"\xe6\x01\n" +
	"\x15UserDeleteBranchError\x12=\n" +
	"\faccess_check\x18\x01 \x01(\v2\x18.gitaly.AccessCheckErrorH\x00R\vaccessCheck\x12I\n" +
	"\x10reference_update\x18\x02 \x01(\v2\x1c.gitaly.ReferenceUpdateErrorH\x00R\x0freferenceUpdate\x12:\n" +
	"\vcustom_hook\x18\x03 \x01(\v2\x17.gitaly.CustomHookErrorH\x00R\n" +
	"customHookB\a\n" +
	"\x05error\"\xb7\x01\n" +
	"\x14UserDeleteTagRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x19\n" +
	"\btag_name\x18\x02 \x01(\fR\atagName\x12 \n" +
	"\x04user\x18\x03 \x01(\v2\f.gitaly.UserR\x04user\x12(\n" +
	"\x10expected_old_oid\x18\x04 \x01(\tR\x0eexpectedOldOid\"C\n" +
	"\x15UserDeleteTagResponse\x12*\n" +
	"\x11pre_receive_error\x18\x01 \x01(\tR\x0fpreReceiveError\"\x8a\x02\n" +
	"\x14UserCreateTagRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12\x19\n" +
	"\btag_name\x18\x02 \x01(\fR\atagName\x12 \n" +
	"\x04user\x18\x03 \x01(\v2\f.gitaly.UserR\x04user\x12'\n" +
	"\x0ftarget_revision\x18\x04 \x01(\fR\x0etargetRevision\x12\x18\n" +
	"\amessage\x18\x05 \x01(\fR\amessage\x128\n" +
	"\ttimestamp\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\"]\n" +
	"\x15UserCreateTagResponse\x12\x1d\n" +
	"\x03tag\x18\x01 \x01(\v2\v.gitaly.TagR\x03tagJ\x04\b\x02\x10\x03J\x04\b\x03\x10\x04R\x06existsR\x11pre_receive_error\"\xae\x02\n" +
	"\x12UserCreateTagError\x12=\n" +
	"\faccess_check\x18\x01 \x01(\v2\x18.gitaly.AccessCheckErrorH\x00R\vaccessCheck\x12I\n" +
	"\x10reference_update\x18\x02 \x01(\v2\x1c.gitaly.ReferenceUpdateErrorH\x00R\x0freferenceUpdate\x12:\n" +
	"\vcustom_hook\x18\x03 \x01(\v2\x17.gitaly.CustomHookErrorH\x00R\n" +
	"customHook\x12I\n" +
	"\x10reference_exists\x18\x04 \x01(\v2\x1c.gitaly.ReferenceExistsErrorH\x00R\x0freferenceExistsB\a\n" +
	"\x05error\"\xe9\x02\n" +
	"\x16UserMergeBranchRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12\x1b\n" +
	"\tcommit_id\x18\x03 \x01(\tR\bcommitId\x12\x16\n" +
	"\x06branch\x18\x04 \x01(\fR\x06branch\x12\x18\n" +
	"\amessage\x18\x05 \x01(\fR\amessage\x12\x14\n" +
	"\x05apply\x18\x06 \x01(\bR\x05apply\x128\n" +
	"\ttimestamp\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12(\n" +
	"\x10expected_old_oid\x18\b \x01(\tR\x0eexpectedOldOid\x12\x16\n" +
	"\x06squash\x18\t \x01(\bR\x06squash\x12\x12\n" +
	"\x04sign\x18\n" +
	" \x01(\bR\x04sign\"\x99\x01\n" +
	"\x17UserMergeBranchResponse\x12\x1b\n" +
	"\tcommit_id\x18\x01 \x01(\tR\bcommitId\x12B\n" +
	"\rbranch_update\x18\x03 \x01(\v2\x1d.gitaly.OperationBranchUpdateR\fbranchUpdateJ\x04\b\x02\x10\x03J\x04\b\x04\x10\x05R\x11pre_receive_error\"\xaa\x02\n" +
	"\x14UserMergeBranchError\x12=\n" +
	"\faccess_check\x18\x01 \x01(\v2\x18.gitaly.AccessCheckErrorH\x00R\vaccessCheck\x12I\n" +
	"\x10reference_update\x18\x02 \x01(\v2\x1c.gitaly.ReferenceUpdateErrorH\x00R\x0freferenceUpdate\x12:\n" +
	"\vcustom_hook\x18\x03 \x01(\v2\x17.gitaly.CustomHookErrorH\x00R\n" +
	"customHook\x12C\n" +
	"\x0emerge_conflict\x18\x04 \x01(\v2\x1a.gitaly.MergeConflictErrorH\x00R\rmergeConflictB\a\n" +
	"\x05error\"\xb6\x03\n" +
	"\x15UserMergeToRefRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12\x1d\n" +
	"\n" +
	"source_sha\x18\x03 \x01(\tR\tsourceSha\x12\x1a\n" +
	"\x06branch\x18\x04 \x01(\fB\x02\x18\x01R\x06branch\x12\x1d\n" +
	"\n" +
	"target_ref\x18\x05 \x01(\fR\ttargetRef\x12\x18\n" +
	"\amessage\x18\x06 \x01(\fR\amessage\x12(\n" +
	"\x10first_parent_ref\x18\a \x01(\fR\x0efirstParentRef\x12+\n" +
	"\x0fallow_conflicts\x18\b \x01(\bB\x02\x18\x01R\x0eallowConflicts\x128\n" +
	"\ttimestamp\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12(\n" +
	"\x10expected_old_oid\x18\n" +
	" \x01(\tR\x0eexpectedOldOid\x12\x12\n" +
	"\x04sign\x18\v \x01(\bR\x04sign\"N\n" +
	"\x16UserMergeToRefResponse\x12\x1b\n" +
	"\tcommit_id\x18\x01 \x01(\tR\bcommitIdJ\x04\b\x02\x10\x03R\x11pre_receive_error\"\xc0\x02\n" +
	"\x16UserRebaseToRefRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12\x1d\n" +
	"\n" +
	"source_sha\x18\x03 \x01(\tR\tsourceSha\x12\x1d\n" +
	"\n" +
	"target_ref\x18\x05 \x01(\fR\ttargetRef\x12(\n" +
	"\x10first_parent_ref\x18\a \x01(\fR\x0efirstParentRef\x128\n" +
	"\ttimestamp\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12(\n" +
	"\x10expected_old_oid\x18\n" +
	" \x01(\tR\x0eexpectedOldOid\"6\n" +
	"\x17UserRebaseToRefResponse\x12\x1b\n" +
	"\tcommit_id\x18\x01 \x01(\tR\bcommitId\"~\n" +
	"\x15OperationBranchUpdate\x12\x1b\n" +
	"\tcommit_id\x18\x01 \x01(\tR\bcommitId\x12!\n" +
	"\frepo_created\x18\x02 \x01(\bR\vrepoCreated\x12%\n" +
	"\x0ebranch_created\x18\x03 \x01(\bR\rbranchCreated\"\xa3\x01\n" +
	"\x11UserFFBranchError\x12:\n" +
	"\vcustom_hook\x18\x01 \x01(\v2\x17.gitaly.CustomHookErrorH\x00R\n" +
	"customHook\x12I\n" +
	"\x10reference_update\x18\x02 \x01(\v2\x1c.gitaly.ReferenceUpdateErrorH\x00R\x0freferenceUpdateB\a\n" +
	"\x05error\"\xd0\x01\n" +
	"\x13UserFFBranchRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12\x1b\n" +
	"\tcommit_id\x18\x03 \x01(\tR\bcommitId\x12\x16\n" +
	"\x06branch\x18\x04 \x01(\fR\x06branch\x12(\n" +
	"\x10expected_old_oid\x18\x05 \x01(\tR\x0eexpectedOldOid\"\x86\x01\n" +
	"\x14UserFFBranchResponse\x12B\n" +
	"\rbranch_update\x18\x01 \x01(\v2\x1d.gitaly.OperationBranchUpdateR\fbranchUpdate\x12*\n" +
	"\x11pre_receive_error\x18\x02 \x01(\tR\x0fpreReceiveError\"\xb3\x04\n" +
	"\x15UserCherryPickRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12)\n" +
	"\x06commit\x18\x03 \x01(\v2\x11.gitaly.GitCommitR\x06commit\x12\x1f\n" +
	"\vbranch_name\x18\x04 \x01(\fR\n" +
	"branchName\x12\x18\n" +
	"\amessage\x18\x05 \x01(\fR\amessage\x12*\n" +
	"\x11start_branch_name\x18\x06 \x01(\fR\x0fstartBranchName\x12=\n" +
	"\x10start_repository\x18\a \x01(\v2\x12.gitaly.RepositoryR\x0fstartRepository\x12\x17\n" +
	"\adry_run\x18\b \x01(\bR\x06dryRun\x128\n" +
	"\ttimestamp\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12(\n" +
	"\x10expected_old_oid\x18\n" +
	" \x01(\tR\x0eexpectedOldOid\x12,\n" +
	"\x12commit_author_name\x18\v \x01(\fR\x10commitAuthorName\x12.\n" +
	"\x13commit_author_email\x18\f \x01(\fR\x11commitAuthorEmail\x12\x12\n" +
	"\x04sign\x18\r \x01(\bR\x04sign\"\xc0\x01\n" +
	"\x16UserCherryPickResponse\x12B\n" +
	"\rbranch_update\x18\x01 \x01(\v2\x1d.gitaly.OperationBranchUpdateR\fbranchUpdateJ\x04\b\x02\x10\x03J\x04\b\x03\x10\x04J\x04\b\x04\x10\x05J\x04\b\x05\x10\x06R\x11create_tree_errorR\fcommit_errorR\x11pre_receive_errorR\x16create_tree_error_code\"\xdd\x02\n" +
	"\x13UserCherryPickError\x12N\n" +
	"\x14cherry_pick_conflict\x18\x01 \x01(\v2\x1a.gitaly.MergeConflictErrorH\x00R\x12cherryPickConflict\x12P\n" +
	"\x16target_branch_diverged\x18\x02 \x01(\v2\x18.gitaly.NotAncestorErrorH\x00R\x14targetBranchDiverged\x12\\\n" +
	"\x17changes_already_applied\x18\x03 \x01(\v2\".gitaly.ChangesAlreadyAppliedErrorH\x00R\x15changesAlreadyApplied\x12=\n" +
	"\faccess_check\x18\x04 \x01(\v2\x18.gitaly.AccessCheckErrorH\x00R\vaccessCheckB\a\n" +
	"\x05error\"\xd1\x03\n" +
	"\x11UserRevertRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12)\n" +
	"\x06commit\x18\x03 \x01(\v2\x11.gitaly.GitCommitR\x06commit\x12\x1f\n" +
	"\vbranch_name\x18\x04 \x01(\fR\n" +
	"branchName\x12\x18\n" +
	"\amessage\x18\x05 \x01(\fR\amessage\x12*\n" +
	"\x11start_branch_name\x18\x06 \x01(\fR\x0fstartBranchName\x12=\n" +
	"\x10start_repository\x18\a \x01(\v2\x12.gitaly.RepositoryR\x0fstartRepository\x12\x17\n" +
	"\adry_run\x18\b \x01(\bR\x06dryRun\x128\n" +
	"\ttimestamp\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12(\n" +
	"\x10expected_old_oid\x18\n" +
	" \x01(\tR\x0eexpectedOldOid\x12\x12\n" +
	"\x04sign\x18\v \x01(\bR\x04sign\"\xea\x02\n" +
	"\x12UserRevertResponse\x12B\n" +
	"\rbranch_update\x18\x01 \x01(\v2\x1d.gitaly.OperationBranchUpdateR\fbranchUpdate\x12*\n" +
	"\x11create_tree_error\x18\x02 \x01(\tR\x0fcreateTreeError\x12!\n" +
	"\fcommit_error\x18\x03 \x01(\tR\vcommitError\x12*\n" +
	"\x11pre_receive_error\x18\x04 \x01(\tR\x0fpreReceiveError\x12_\n" +
	"\x16create_tree_error_code\x18\x05 \x01(\x0e2*.gitaly.UserRevertResponse.CreateTreeErrorR\x13createTreeErrorCode\"4\n" +
	"\x0fCreateTreeError\x12\b\n" +
	"\x04NONE\x10\x00\x12\t\n" +
	"\x05EMPTY\x10\x01\x12\f\n" +
	"\bCONFLICT\x10\x02\"\xb8\x02\n" +
	"\x0fUserRevertError\x12C\n" +
	"\x0emerge_conflict\x18\x01 \x01(\v2\x1a.gitaly.MergeConflictErrorH\x00R\rmergeConflict\x12\\\n" +
	"\x17changes_already_applied\x18\x02 \x01(\v2\".gitaly.ChangesAlreadyAppliedErrorH\x00R\x15changesAlreadyApplied\x12:\n" +
	"\vcustom_hook\x18\x03 \x01(\v2\x17.gitaly.CustomHookErrorH\x00R\n" +
	"customHook\x12=\n" +
	"\fnot_ancestor\x18\x04 \x01(\v2\x18.gitaly.NotAncestorErrorH\x00R\vnotAncestorB\a\n" +
	"\x05error\"\xf5\x02\n" +
	"\x1bUserCommitFilesActionHeader\x12F\n" +
	"\x06action\x18\x01 \x01(\x0e2..gitaly.UserCommitFilesActionHeader.ActionTypeR\x06action\x12\x1b\n" +
	"\tfile_path\x18\x02 \x01(\fR\bfilePath\x12#\n" +
	"\rprevious_path\x18\x03 \x01(\fR\fpreviousPath\x12%\n" +
	"\x0ebase64_content\x18\x04 \x01(\bR\rbase64Content\x12)\n" +
	"\x10execute_filemode\x18\x05 \x01(\bR\x0fexecuteFilemode\x12#\n" +
	"\rinfer_content\x18\x06 \x01(\bR\finferContent\"U\n" +
	"\n" +
	"ActionType\x12\n" +
	"\n" +
	"\x06CREATE\x10\x00\x12\x0e\n" +
	"\n" +
	"CREATE_DIR\x10\x01\x12\n" +
	"\n" +
	"\x06UPDATE\x10\x02\x12\b\n" +
	"\x04MOVE\x10\x03\x12\n" +
	"\n" +
	"\x06DELETE\x10\x04\x12\t\n" +
	"\x05CHMOD\x10\x05\"\x96\x01\n" +
	"\x15UserCommitFilesAction\x12=\n" +
	"\x06header\x18\x01 \x01(\v2#.gitaly.UserCommitFilesActionHeaderH\x00R\x06header\x12\x1a\n" +
	"\acontent\x18\x02 \x01(\fH\x00R\acontentB\"\n" +
	" user_commit_files_action_payload\"\xb6\x04\n" +
	"\x1cUserCommitFilesRequestHeader\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12\x1f\n" +
	"\vbranch_name\x18\x03 \x01(\fR\n" +
	"branchName\x12%\n" +
	"\x0ecommit_message\x18\x04 \x01(\fR\rcommitMessage\x12,\n" +
	"\x12commit_author_name\x18\x05 \x01(\fR\x10commitAuthorName\x12.\n" +
	"\x13commit_author_email\x18\x06 \x01(\fR\x11commitAuthorEmail\x12*\n" +
	"\x11start_branch_name\x18\a \x01(\fR\x0fstartBranchName\x12=\n" +
	"\x10start_repository\x18\b \x01(\v2\x12.gitaly.RepositoryR\x0fstartRepository\x12\x14\n" +
	"\x05force\x18\t \x01(\bR\x05force\x12\x1b\n" +
	"\tstart_sha\x18\n" +
	" \x01(\tR\bstartSha\x128\n" +
	"\ttimestamp\x18\v \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12(\n" +
	"\x10expected_old_oid\x18\f \x01(\tR\x0eexpectedOldOid\x12\x12\n" +
	"\x04sign\x18\r \x01(\bR\x04sign\"\xb6\x01\n" +
	"\x16UserCommitFilesRequest\x12>\n" +
	"\x06header\x18\x01 \x01(\v2$.gitaly.UserCommitFilesRequestHeaderH\x00R\x06header\x127\n" +
	"\x06action\x18\x02 \x01(\v2\x1d.gitaly.UserCommitFilesActionH\x00R\x06actionB#\n" +
	"!user_commit_files_request_payload\"\xaa\x01\n" +
	"\x17UserCommitFilesResponse\x12B\n" +
	"\rbranch_update\x18\x01 \x01(\v2\x1d.gitaly.OperationBranchUpdateR\fbranchUpdate\x12\x1f\n" +
	"\vindex_error\x18\x02 \x01(\tR\n" +
	"indexError\x12*\n" +
	"\x11pre_receive_error\x18\x03 \x01(\tR\x0fpreReceiveError\"\xd3\x01\n" +
	"\x14UserCommitFilesError\x12=\n" +
	"\faccess_check\x18\x01 \x01(\v2\x18.gitaly.AccessCheckErrorH\x00R\vaccessCheck\x127\n" +
	"\findex_update\x18\x02 \x01(\v2\x12.gitaly.IndexErrorH\x00R\vindexUpdate\x12:\n" +
	"\vcustom_hook\x18\x03 \x01(\v2\x17.gitaly.CustomHookErrorH\x00R\n" +
	"customHookB\a\n" +
	"\x05error\"\xb1\x04\n" +
	"\x1cUserRebaseConfirmableRequest\x12E\n" +
	"\x06header\x18\x01 \x01(\v2+.gitaly.UserRebaseConfirmableRequest.HeaderH\x00R\x06header\x12\x16\n" +
	"\x05apply\x18\x02 \x01(\bH\x00R\x05apply\x1a\x86\x03\n" +
	"\x06Header\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12\x1f\n" +
	"\trebase_id\x18\x03 \x01(\tB\x02\x18\x01R\brebaseId\x12\x16\n" +
	"\x06branch\x18\x04 \x01(\fR\x06branch\x12\x1d\n" +
	"\n" +
	"branch_sha\x18\x05 \x01(\tR\tbranchSha\x12?\n" +
	"\x11remote_repository\x18\x06 \x01(\v2\x12.gitaly.RepositoryR\x10remoteRepository\x12#\n" +
	"\rremote_branch\x18\a \x01(\fR\fremoteBranch\x12(\n" +
	"\x10git_push_options\x18\b \x03(\tR\x0egitPushOptions\x128\n" +
	"\ttimestamp\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\ttimestampB)\n" +
	"'user_rebase_confirmable_request_payload\"\xbf\x01\n" +
	"\x1dUserRebaseConfirmableResponse\x12\x1f\n" +
	"\n" +
	"rebase_sha\x18\x01 \x01(\tH\x00R\trebaseSha\x12'\n" +
	"\x0erebase_applied\x18\x02 \x01(\bH\x00R\rrebaseAppliedB*\n" +
	"(user_rebase_confirmable_response_payloadJ\x04\b\x03\x10\x04J\x04\b\x04\x10\x05R\x11pre_receive_errorR\tgit_error\"\xd7\x02\n" +
	"\x11UserSquashRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12\x1b\n" +
	"\tstart_sha\x18\x05 \x01(\tR\bstartSha\x12\x17\n" +
	"\aend_sha\x18\x06 \x01(\tR\x06endSha\x12$\n" +
	"\x06author\x18\a \x01(\v2\f.gitaly.UserR\x06author\x12%\n" +
	"\x0ecommit_message\x18\b \x01(\fR\rcommitMessage\x128\n" +
	"\ttimestamp\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12\x12\n" +
	"\x04sign\x18\n" +
	" \x01(\bR\x04signJ\x04\b\x03\x10\x04J\x04\b\x04\x10\x05R\tsquash_id\"]\n" +
	"\x12UserSquashResponse\x12\x1d\n" +
	"\n" +
	"squash_sha\x18\x01 \x01(\tR\tsquashShaJ\x04\b\x02\x10\x03J\x04\b\x03\x10\x04R\x11pre_receive_errorR\tgit_error\"\xab\x01\n" +
	"\x1aUserRebaseConfirmableError\x12E\n" +
	"\x0frebase_conflict\x18\x01 \x01(\v2\x1a.gitaly.MergeConflictErrorH\x00R\x0erebaseConflict\x12=\n" +
	"\faccess_check\x18\x02 \x01(\v2\x18.gitaly.AccessCheckErrorH\x00R\vaccessCheckB\a\n" +
	"\x05error\"\xac\x01\n" +
	"\x0fUserSquashError\x12I\n" +
	"\x10resolve_revision\x18\x01 \x01(\v2\x1c.gitaly.ResolveRevisionErrorH\x00R\x0fresolveRevision\x12E\n" +
	"\x0frebase_conflict\x18\x02 \x01(\v2\x1a.gitaly.MergeConflictErrorH\x00R\x0erebaseConflictB\a\n" +
	"\x05error\"\x87\x03\n" +
	"\x15UserApplyPatchRequest\x12>\n" +
	"\x06header\x18\x01 \x01(\v2$.gitaly.UserApplyPatchRequest.HeaderH\x00R\x06header\x12\x1a\n" +
	"\apatches\x18\x02 \x01(\fH\x00R\apatches\x1a\xed\x01\n" +
	"\x06Header\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12#\n" +
	"\rtarget_branch\x18\x03 \x01(\fR\ftargetBranch\x128\n" +
	"\ttimestamp\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12(\n" +
	"\x10expected_old_oid\x18\x05 \x01(\tR\x0eexpectedOldOidB\"\n" +
	" user_apply_patch_request_payload\"Z\n" +
	"\x13UserApplyPatchError\x12:\n" +
	"\vcustom_hook\x18\x01 \x01(\v2\x17.gitaly.CustomHookErrorH\x00R\n" +
	"customHookB\a\n" +
	"\x05error\"\\\n" +
	"\x16UserApplyPatchResponse\x12B\n" +
	"\rbranch_update\x18\x01 \x01(\v2\x1d.gitaly.OperationBranchUpdateR\fbranchUpdate\"\xd8\x02\n" +
	"\x1aUserUpdateSubmoduleRequest\x128\n" +
	"\n" +
	"repository\x18\x01 \x01(\v2\x12.gitaly.RepositoryB\x04\x98\xc6,\x01R\n" +
	"repository\x12 \n" +
	"\x04user\x18\x02 \x01(\v2\f.gitaly.UserR\x04user\x12\x1d\n" +
	"\n" +
	"commit_sha\x18\x03 \x01(\tR\tcommitSha\x12\x16\n" +
	"\x06branch\x18\x04 \x01(\fR\x06branch\x12\x1c\n" +
	"\tsubmodule\x18\x05 \x01(\fR\tsubmodule\x12%\n" +
	"\x0ecommit_message\x18\x06 \x01(\fR\rcommitMessage\x128\n" +
	"\ttimestamp\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12(\n" +
	"\x10expected_old_oid\x18\b \x01(\tR\x0eexpectedOldOid\"\xc9\x01\n" +
	"\x1bUserUpdateSubmoduleResponse\x12B\n" +
	"\rbranch_update\x18\x01 \x01(\v2\x1d.gitaly.OperationBranchUpdateR\fbranchUpdate\x12*\n" +
	"\x11pre_receive_error\x18\x02 \x01(\tR\x0fpreReceiveError\x12!\n" +
	"\fcommit_error\x18\x04 \x01(\tR\vcommitErrorJ\x04\b\x03\x10\x04R\x11create_tree_error\"\xde\x01\n" +
	"\x18UserUpdateSubmoduleError\x12:\n" +
	"\vcustom_hook\x18\x01 \x01(\v2\x17.gitaly.CustomHookErrorH\x00R\n" +
	"customHook\x12I\n" +
	"\x10reference_update\x18\x02 \x01(\v2\x1c.gitaly.ReferenceUpdateErrorH\x00R\x0freferenceUpdate\x122\n" +
	"\n" +
	"path_error\x18\x03 \x01(\v2\x11.gitaly.PathErrorH\x00R\tpathErrorB\a\n" +
	"\x05error2\xc9\v\n" +
	"\x10OperationService\x12]\n" +
	"\x10UserCreateBranch\x12\x1f.gitaly.UserCreateBranchRequest\x1a .gitaly.UserCreateBranchResponse\"\x06\xfa\x97(\x02\b\x01\x12]\n" +
	"\x10UserUpdateBranch\x12\x1f.gitaly.UserUpdateBranchRequest\x1a .gitaly.UserUpdateBranchResponse\"\x06\xfa\x97(\x02\b\x01\x12]\n" +
	"\x10UserDeleteBranch\x12\x1f.gitaly.UserDeleteBranchRequest\x1a .gitaly.UserDeleteBranchResponse\"\x06\xfa\x97(\x02\b\x01\x12T\n" +
	"\rUserCreateTag\x12\x1c.gitaly.UserCreateTagRequest\x1a\x1d.gitaly.UserCreateTagResponse\"\x06\xfa\x97(\x02\b\x01\x12T\n" +
	"\rUserDeleteTag\x12\x1c.gitaly.UserDeleteTagRequest\x1a\x1d.gitaly.UserDeleteTagResponse\"\x06\xfa\x97(\x02\b\x01\x12W\n" +
	"\x0eUserMergeToRef\x12\x1d.gitaly.UserMergeToRefRequest\x1a\x1e.gitaly.UserMergeToRefResponse\"\x06\xfa\x97(\x02\b\x01\x12Z\n" +
	"\x0fUserRebaseToRef\x12\x1e.gitaly.UserRebaseToRefRequest\x1a\x1f.gitaly.UserRebaseToRefResponse\"\x06\xfa\x97(\x02\b\x01\x12^\n" +
	"\x0fUserMergeBranch\x12\x1e.gitaly.UserMergeBranchRequest\x1a\x1f.gitaly.UserMergeBranchResponse\"\x06\xfa\x97(\x02\b\x01(\x010\x01\x12Q\n" +
	"\fUserFFBranch\x12\x1b.gitaly.UserFFBranchRequest\x1a\x1c.gitaly.UserFFBranchResponse\"\x06\xfa\x97(\x02\b\x01\x12W\n" +
	"\x0eUserCherryPick\x12\x1d.gitaly.UserCherryPickRequest\x1a\x1e.gitaly.UserCherryPickResponse\"\x06\xfa\x97(\x02\b\x01\x12\\\n" +
	"\x0fUserCommitFiles\x12\x1e.gitaly.UserCommitFilesRequest\x1a\x1f.gitaly.UserCommitFilesResponse\"\x06\xfa\x97(\x02\b\x01(\x01\x12p\n" +
	"\x15UserRebaseConfirmable\x12$.gitaly.UserRebaseConfirmableRequest\x1a%.gitaly.UserRebaseConfirmableResponse\"\x06\xfa\x97(\x02\b\x01(\x010\x01\x12K\n" +
	"\n" +
	"UserRevert\x12\x19.gitaly.UserRevertRequest\x1a\x1a.gitaly.UserRevertResponse\"\x06\xfa\x97(\x02\b\x01\x12K\n" +
	"\n" +
	"UserSquash\x12\x19.gitaly.UserSquashRequest\x1a\x1a.gitaly.UserSquashResponse\"\x06\xfa\x97(\x02\b\x01\x12Y\n" +
	"\x0eUserApplyPatch\x12\x1d.gitaly.UserApplyPatchRequest\x1a\x1e.gitaly.UserApplyPatchResponse\"\x06\xfa\x97(\x02\b\x01(\x01\x12f\n" +
	"\x13UserUpdateSubmodule\x12\".gitaly.UserUpdateSubmoduleRequest\x1a#.gitaly.UserUpdateSubmoduleResponse\"\x06\xfa\x97(\x02\b\x01B4Z2gitlab.com/gitlab-org/gitaly/v18/proto/go/gitalypbb\x06proto3"

var (
	file_operations_proto_rawDescOnce sync.Once
	file_operations_proto_rawDescData []byte
)

func file_operations_proto_rawDescGZIP() []byte {
	file_operations_proto_rawDescOnce.Do(func() {
		file_operations_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_operations_proto_rawDesc), len(file_operations_proto_rawDesc)))
	})
	return file_operations_proto_rawDescData
}

var file_operations_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_operations_proto_msgTypes = make([]protoimpl.MessageInfo, 50)
var file_operations_proto_goTypes = []any{
	(UserRevertResponse_CreateTreeError)(0),     // 0: gitaly.UserRevertResponse.CreateTreeError
	(UserCommitFilesActionHeader_ActionType)(0), // 1: gitaly.UserCommitFilesActionHeader.ActionType
	(*UserCreateBranchRequest)(nil),             // 2: gitaly.UserCreateBranchRequest
	(*UserCreateBranchResponse)(nil),            // 3: gitaly.UserCreateBranchResponse
	(*UserCreateBranchError)(nil),               // 4: gitaly.UserCreateBranchError
	(*UserUpdateBranchRequest)(nil),             // 5: gitaly.UserUpdateBranchRequest
	(*UserUpdateBranchResponse)(nil),            // 6: gitaly.UserUpdateBranchResponse
	(*UserDeleteBranchRequest)(nil),             // 7: gitaly.UserDeleteBranchRequest
	(*UserDeleteBranchResponse)(nil),            // 8: gitaly.UserDeleteBranchResponse
	(*UserDeleteBranchError)(nil),               // 9: gitaly.UserDeleteBranchError
	(*UserDeleteTagRequest)(nil),                // 10: gitaly.UserDeleteTagRequest
	(*UserDeleteTagResponse)(nil),               // 11: gitaly.UserDeleteTagResponse
	(*UserCreateTagRequest)(nil),                // 12: gitaly.UserCreateTagRequest
	(*UserCreateTagResponse)(nil),               // 13: gitaly.UserCreateTagResponse
	(*UserCreateTagError)(nil),                  // 14: gitaly.UserCreateTagError
	(*UserMergeBranchRequest)(nil),              // 15: gitaly.UserMergeBranchRequest
	(*UserMergeBranchResponse)(nil),             // 16: gitaly.UserMergeBranchResponse
	(*UserMergeBranchError)(nil),                // 17: gitaly.UserMergeBranchError
	(*UserMergeToRefRequest)(nil),               // 18: gitaly.UserMergeToRefRequest
	(*UserMergeToRefResponse)(nil),              // 19: gitaly.UserMergeToRefResponse
	(*UserRebaseToRefRequest)(nil),              // 20: gitaly.UserRebaseToRefRequest
	(*UserRebaseToRefResponse)(nil),             // 21: gitaly.UserRebaseToRefResponse
	(*OperationBranchUpdate)(nil),               // 22: gitaly.OperationBranchUpdate
	(*UserFFBranchError)(nil),                   // 23: gitaly.UserFFBranchError
	(*UserFFBranchRequest)(nil),                 // 24: gitaly.UserFFBranchRequest
	(*UserFFBranchResponse)(nil),                // 25: gitaly.UserFFBranchResponse
	(*UserCherryPickRequest)(nil),               // 26: gitaly.UserCherryPickRequest
	(*UserCherryPickResponse)(nil),              // 27: gitaly.UserCherryPickResponse
	(*UserCherryPickError)(nil),                 // 28: gitaly.UserCherryPickError
	(*UserRevertRequest)(nil),                   // 29: gitaly.UserRevertRequest
	(*UserRevertResponse)(nil),                  // 30: gitaly.UserRevertResponse
	(*UserRevertError)(nil),                     // 31: gitaly.UserRevertError
	(*UserCommitFilesActionHeader)(nil),         // 32: gitaly.UserCommitFilesActionHeader
	(*UserCommitFilesAction)(nil),               // 33: gitaly.UserCommitFilesAction
	(*UserCommitFilesRequestHeader)(nil),        // 34: gitaly.UserCommitFilesRequestHeader
	(*UserCommitFilesRequest)(nil),              // 35: gitaly.UserCommitFilesRequest
	(*UserCommitFilesResponse)(nil),             // 36: gitaly.UserCommitFilesResponse
	(*UserCommitFilesError)(nil),                // 37: gitaly.UserCommitFilesError
	(*UserRebaseConfirmableRequest)(nil),        // 38: gitaly.UserRebaseConfirmableRequest
	(*UserRebaseConfirmableResponse)(nil),       // 39: gitaly.UserRebaseConfirmableResponse
	(*UserSquashRequest)(nil),                   // 40: gitaly.UserSquashRequest
	(*UserSquashResponse)(nil),                  // 41: gitaly.UserSquashResponse
	(*UserRebaseConfirmableError)(nil),          // 42: gitaly.UserRebaseConfirmableError
	(*UserSquashError)(nil),                     // 43: gitaly.UserSquashError
	(*UserApplyPatchRequest)(nil),               // 44: gitaly.UserApplyPatchRequest
	(*UserApplyPatchError)(nil),                 // 45: gitaly.UserApplyPatchError
	(*UserApplyPatchResponse)(nil),              // 46: gitaly.UserApplyPatchResponse
	(*UserUpdateSubmoduleRequest)(nil),          // 47: gitaly.UserUpdateSubmoduleRequest
	(*UserUpdateSubmoduleResponse)(nil),         // 48: gitaly.UserUpdateSubmoduleResponse
	(*UserUpdateSubmoduleError)(nil),            // 49: gitaly.UserUpdateSubmoduleError
	(*UserRebaseConfirmableRequest_Header)(nil), // 50: gitaly.UserRebaseConfirmableRequest.Header
	(*UserApplyPatchRequest_Header)(nil),        // 51: gitaly.UserApplyPatchRequest.Header
	(*Repository)(nil),                          // 52: gitaly.Repository
	(*User)(nil),                                // 53: gitaly.User
	(*Branch)(nil),                              // 54: gitaly.Branch
	(*CustomHookError)(nil),                     // 55: gitaly.CustomHookError
	(*AccessCheckError)(nil),                    // 56: gitaly.AccessCheckError
	(*ReferenceUpdateError)(nil),                // 57: gitaly.ReferenceUpdateError
	(*timestamppb.Timestamp)(nil),               // 58: google.protobuf.Timestamp
	(*Tag)(nil),                                 // 59: gitaly.Tag
	(*ReferenceExistsError)(nil),                // 60: gitaly.ReferenceExistsError
	(*MergeConflictError)(nil),                  // 61: gitaly.MergeConflictError
	(*GitCommit)(nil),                           // 62: gitaly.GitCommit
	(*NotAncestorError)(nil),                    // 63: gitaly.NotAncestorError
	(*ChangesAlreadyAppliedError)(nil),          // 64: gitaly.ChangesAlreadyAppliedError
	(*IndexError)(nil),                          // 65: gitaly.IndexError
	(*ResolveRevisionError)(nil),                // 66: gitaly.ResolveRevisionError
	(*PathError)(nil),                           // 67: gitaly.PathError
}
var file_operations_proto_depIdxs = []int32{
	52,  // 0: gitaly.UserCreateBranchRequest.repository:type_name -> gitaly.Repository
	53,  // 1: gitaly.UserCreateBranchRequest.user:type_name -> gitaly.User
	54,  // 2: gitaly.UserCreateBranchResponse.branch:type_name -> gitaly.Branch
	55,  // 3: gitaly.UserCreateBranchError.custom_hook:type_name -> gitaly.CustomHookError
	52,  // 4: gitaly.UserUpdateBranchRequest.repository:type_name -> gitaly.Repository
	53,  // 5: gitaly.UserUpdateBranchRequest.user:type_name -> gitaly.User
	52,  // 6: gitaly.UserDeleteBranchRequest.repository:type_name -> gitaly.Repository
	53,  // 7: gitaly.UserDeleteBranchRequest.user:type_name -> gitaly.User
	56,  // 8: gitaly.UserDeleteBranchError.access_check:type_name -> gitaly.AccessCheckError
	57,  // 9: gitaly.UserDeleteBranchError.reference_update:type_name -> gitaly.ReferenceUpdateError
	55,  // 10: gitaly.UserDeleteBranchError.custom_hook:type_name -> gitaly.CustomHookError
	52,  // 11: gitaly.UserDeleteTagRequest.repository:type_name -> gitaly.Repository
	53,  // 12: gitaly.UserDeleteTagRequest.user:type_name -> gitaly.User
	52,  // 13: gitaly.UserCreateTagRequest.repository:type_name -> gitaly.Repository
	53,  // 14: gitaly.UserCreateTagRequest.user:type_name -> gitaly.User
	58,  // 15: gitaly.UserCreateTagRequest.timestamp:type_name -> google.protobuf.Timestamp
	59,  // 16: gitaly.UserCreateTagResponse.tag:type_name -> gitaly.Tag
	56,  // 17: gitaly.UserCreateTagError.access_check:type_name -> gitaly.AccessCheckError
	57,  // 18: gitaly.UserCreateTagError.reference_update:type_name -> gitaly.ReferenceUpdateError
	55,  // 19: gitaly.UserCreateTagError.custom_hook:type_name -> gitaly.CustomHookError
	60,  // 20: gitaly.UserCreateTagError.reference_exists:type_name -> gitaly.ReferenceExistsError
	52,  // 21: gitaly.UserMergeBranchRequest.repository:type_name -> gitaly.Repository
	53,  // 22: gitaly.UserMergeBranchRequest.user:type_name -> gitaly.User
	58,  // 23: gitaly.UserMergeBranchRequest.timestamp:type_name -> google.protobuf.Timestamp
	22,  // 24: gitaly.UserMergeBranchResponse.branch_update:type_name -> gitaly.OperationBranchUpdate
	56,  // 25: gitaly.UserMergeBranchError.access_check:type_name -> gitaly.AccessCheckError
	57,  // 26: gitaly.UserMergeBranchError.reference_update:type_name -> gitaly.ReferenceUpdateError
	55,  // 27: gitaly.UserMergeBranchError.custom_hook:type_name -> gitaly.CustomHookError
	61,  // 28: gitaly.UserMergeBranchError.merge_conflict:type_name -> gitaly.MergeConflictError
	52,  // 29: gitaly.UserMergeToRefRequest.repository:type_name -> gitaly.Repository
	53,  // 30: gitaly.UserMergeToRefRequest.user:type_name -> gitaly.User
	58,  // 31: gitaly.UserMergeToRefRequest.timestamp:type_name -> google.protobuf.Timestamp
	52,  // 32: gitaly.UserRebaseToRefRequest.repository:type_name -> gitaly.Repository
	53,  // 33: gitaly.UserRebaseToRefRequest.user:type_name -> gitaly.User
	58,  // 34: gitaly.UserRebaseToRefRequest.timestamp:type_name -> google.protobuf.Timestamp
	55,  // 35: gitaly.UserFFBranchError.custom_hook:type_name -> gitaly.CustomHookError
	57,  // 36: gitaly.UserFFBranchError.reference_update:type_name -> gitaly.ReferenceUpdateError
	52,  // 37: gitaly.UserFFBranchRequest.repository:type_name -> gitaly.Repository
	53,  // 38: gitaly.UserFFBranchRequest.user:type_name -> gitaly.User
	22,  // 39: gitaly.UserFFBranchResponse.branch_update:type_name -> gitaly.OperationBranchUpdate
	52,  // 40: gitaly.UserCherryPickRequest.repository:type_name -> gitaly.Repository
	53,  // 41: gitaly.UserCherryPickRequest.user:type_name -> gitaly.User
	62,  // 42: gitaly.UserCherryPickRequest.commit:type_name -> gitaly.GitCommit
	52,  // 43: gitaly.UserCherryPickRequest.start_repository:type_name -> gitaly.Repository
	58,  // 44: gitaly.UserCherryPickRequest.timestamp:type_name -> google.protobuf.Timestamp
	22,  // 45: gitaly.UserCherryPickResponse.branch_update:type_name -> gitaly.OperationBranchUpdate
	61,  // 46: gitaly.UserCherryPickError.cherry_pick_conflict:type_name -> gitaly.MergeConflictError
	63,  // 47: gitaly.UserCherryPickError.target_branch_diverged:type_name -> gitaly.NotAncestorError
	64,  // 48: gitaly.UserCherryPickError.changes_already_applied:type_name -> gitaly.ChangesAlreadyAppliedError
	56,  // 49: gitaly.UserCherryPickError.access_check:type_name -> gitaly.AccessCheckError
	52,  // 50: gitaly.UserRevertRequest.repository:type_name -> gitaly.Repository
	53,  // 51: gitaly.UserRevertRequest.user:type_name -> gitaly.User
	62,  // 52: gitaly.UserRevertRequest.commit:type_name -> gitaly.GitCommit
	52,  // 53: gitaly.UserRevertRequest.start_repository:type_name -> gitaly.Repository
	58,  // 54: gitaly.UserRevertRequest.timestamp:type_name -> google.protobuf.Timestamp
	22,  // 55: gitaly.UserRevertResponse.branch_update:type_name -> gitaly.OperationBranchUpdate
	0,   // 56: gitaly.UserRevertResponse.create_tree_error_code:type_name -> gitaly.UserRevertResponse.CreateTreeError
	61,  // 57: gitaly.UserRevertError.merge_conflict:type_name -> gitaly.MergeConflictError
	64,  // 58: gitaly.UserRevertError.changes_already_applied:type_name -> gitaly.ChangesAlreadyAppliedError
	55,  // 59: gitaly.UserRevertError.custom_hook:type_name -> gitaly.CustomHookError
	63,  // 60: gitaly.UserRevertError.not_ancestor:type_name -> gitaly.NotAncestorError
	1,   // 61: gitaly.UserCommitFilesActionHeader.action:type_name -> gitaly.UserCommitFilesActionHeader.ActionType
	32,  // 62: gitaly.UserCommitFilesAction.header:type_name -> gitaly.UserCommitFilesActionHeader
	52,  // 63: gitaly.UserCommitFilesRequestHeader.repository:type_name -> gitaly.Repository
	53,  // 64: gitaly.UserCommitFilesRequestHeader.user:type_name -> gitaly.User
	52,  // 65: gitaly.UserCommitFilesRequestHeader.start_repository:type_name -> gitaly.Repository
	58,  // 66: gitaly.UserCommitFilesRequestHeader.timestamp:type_name -> google.protobuf.Timestamp
	34,  // 67: gitaly.UserCommitFilesRequest.header:type_name -> gitaly.UserCommitFilesRequestHeader
	33,  // 68: gitaly.UserCommitFilesRequest.action:type_name -> gitaly.UserCommitFilesAction
	22,  // 69: gitaly.UserCommitFilesResponse.branch_update:type_name -> gitaly.OperationBranchUpdate
	56,  // 70: gitaly.UserCommitFilesError.access_check:type_name -> gitaly.AccessCheckError
	65,  // 71: gitaly.UserCommitFilesError.index_update:type_name -> gitaly.IndexError
	55,  // 72: gitaly.UserCommitFilesError.custom_hook:type_name -> gitaly.CustomHookError
	50,  // 73: gitaly.UserRebaseConfirmableRequest.header:type_name -> gitaly.UserRebaseConfirmableRequest.Header
	52,  // 74: gitaly.UserSquashRequest.repository:type_name -> gitaly.Repository
	53,  // 75: gitaly.UserSquashRequest.user:type_name -> gitaly.User
	53,  // 76: gitaly.UserSquashRequest.author:type_name -> gitaly.User
	58,  // 77: gitaly.UserSquashRequest.timestamp:type_name -> google.protobuf.Timestamp
	61,  // 78: gitaly.UserRebaseConfirmableError.rebase_conflict:type_name -> gitaly.MergeConflictError
	56,  // 79: gitaly.UserRebaseConfirmableError.access_check:type_name -> gitaly.AccessCheckError
	66,  // 80: gitaly.UserSquashError.resolve_revision:type_name -> gitaly.ResolveRevisionError
	61,  // 81: gitaly.UserSquashError.rebase_conflict:type_name -> gitaly.MergeConflictError
	51,  // 82: gitaly.UserApplyPatchRequest.header:type_name -> gitaly.UserApplyPatchRequest.Header
	55,  // 83: gitaly.UserApplyPatchError.custom_hook:type_name -> gitaly.CustomHookError
	22,  // 84: gitaly.UserApplyPatchResponse.branch_update:type_name -> gitaly.OperationBranchUpdate
	52,  // 85: gitaly.UserUpdateSubmoduleRequest.repository:type_name -> gitaly.Repository
	53,  // 86: gitaly.UserUpdateSubmoduleRequest.user:type_name -> gitaly.User
	58,  // 87: gitaly.UserUpdateSubmoduleRequest.timestamp:type_name -> google.protobuf.Timestamp
	22,  // 88: gitaly.UserUpdateSubmoduleResponse.branch_update:type_name -> gitaly.OperationBranchUpdate
	55,  // 89: gitaly.UserUpdateSubmoduleError.custom_hook:type_name -> gitaly.CustomHookError
	57,  // 90: gitaly.UserUpdateSubmoduleError.reference_update:type_name -> gitaly.ReferenceUpdateError
	67,  // 91: gitaly.UserUpdateSubmoduleError.path_error:type_name -> gitaly.PathError
	52,  // 92: gitaly.UserRebaseConfirmableRequest.Header.repository:type_name -> gitaly.Repository
	53,  // 93: gitaly.UserRebaseConfirmableRequest.Header.user:type_name -> gitaly.User
	52,  // 94: gitaly.UserRebaseConfirmableRequest.Header.remote_repository:type_name -> gitaly.Repository
	58,  // 95: gitaly.UserRebaseConfirmableRequest.Header.timestamp:type_name -> google.protobuf.Timestamp
	52,  // 96: gitaly.UserApplyPatchRequest.Header.repository:type_name -> gitaly.Repository
	53,  // 97: gitaly.UserApplyPatchRequest.Header.user:type_name -> gitaly.User
	58,  // 98: gitaly.UserApplyPatchRequest.Header.timestamp:type_name -> google.protobuf.Timestamp
	2,   // 99: gitaly.OperationService.UserCreateBranch:input_type -> gitaly.UserCreateBranchRequest
	5,   // 100: gitaly.OperationService.UserUpdateBranch:input_type -> gitaly.UserUpdateBranchRequest
	7,   // 101: gitaly.OperationService.UserDeleteBranch:input_type -> gitaly.UserDeleteBranchRequest
	12,  // 102: gitaly.OperationService.UserCreateTag:input_type -> gitaly.UserCreateTagRequest
	10,  // 103: gitaly.OperationService.UserDeleteTag:input_type -> gitaly.UserDeleteTagRequest
	18,  // 104: gitaly.OperationService.UserMergeToRef:input_type -> gitaly.UserMergeToRefRequest
	20,  // 105: gitaly.OperationService.UserRebaseToRef:input_type -> gitaly.UserRebaseToRefRequest
	15,  // 106: gitaly.OperationService.UserMergeBranch:input_type -> gitaly.UserMergeBranchRequest
	24,  // 107: gitaly.OperationService.UserFFBranch:input_type -> gitaly.UserFFBranchRequest
	26,  // 108: gitaly.OperationService.UserCherryPick:input_type -> gitaly.UserCherryPickRequest
	35,  // 109: gitaly.OperationService.UserCommitFiles:input_type -> gitaly.UserCommitFilesRequest
	38,  // 110: gitaly.OperationService.UserRebaseConfirmable:input_type -> gitaly.UserRebaseConfirmableRequest
	29,  // 111: gitaly.OperationService.UserRevert:input_type -> gitaly.UserRevertRequest
	40,  // 112: gitaly.OperationService.UserSquash:input_type -> gitaly.UserSquashRequest
	44,  // 113: gitaly.OperationService.UserApplyPatch:input_type -> gitaly.UserApplyPatchRequest
	47,  // 114: gitaly.OperationService.UserUpdateSubmodule:input_type -> gitaly.UserUpdateSubmoduleRequest
	3,   // 115: gitaly.OperationService.UserCreateBranch:output_type -> gitaly.UserCreateBranchResponse
	6,   // 116: gitaly.OperationService.UserUpdateBranch:output_type -> gitaly.UserUpdateBranchResponse
	8,   // 117: gitaly.OperationService.UserDeleteBranch:output_type -> gitaly.UserDeleteBranchResponse
	13,  // 118: gitaly.OperationService.UserCreateTag:output_type -> gitaly.UserCreateTagResponse
	11,  // 119: gitaly.OperationService.UserDeleteTag:output_type -> gitaly.UserDeleteTagResponse
	19,  // 120: gitaly.OperationService.UserMergeToRef:output_type -> gitaly.UserMergeToRefResponse
	21,  // 121: gitaly.OperationService.UserRebaseToRef:output_type -> gitaly.UserRebaseToRefResponse
	16,  // 122: gitaly.OperationService.UserMergeBranch:output_type -> gitaly.UserMergeBranchResponse
	25,  // 123: gitaly.OperationService.UserFFBranch:output_type -> gitaly.UserFFBranchResponse
	27,  // 124: gitaly.OperationService.UserCherryPick:output_type -> gitaly.UserCherryPickResponse
	36,  // 125: gitaly.OperationService.UserCommitFiles:output_type -> gitaly.UserCommitFilesResponse
	39,  // 126: gitaly.OperationService.UserRebaseConfirmable:output_type -> gitaly.UserRebaseConfirmableResponse
	30,  // 127: gitaly.OperationService.UserRevert:output_type -> gitaly.UserRevertResponse
	41,  // 128: gitaly.OperationService.UserSquash:output_type -> gitaly.UserSquashResponse
	46,  // 129: gitaly.OperationService.UserApplyPatch:output_type -> gitaly.UserApplyPatchResponse
	48,  // 130: gitaly.OperationService.UserUpdateSubmodule:output_type -> gitaly.UserUpdateSubmoduleResponse
	115, // [115:131] is the sub-list for method output_type
	99,  // [99:115] is the sub-list for method input_type
	99,  // [99:99] is the sub-list for extension type_name
	99,  // [99:99] is the sub-list for extension extendee
	0,   // [0:99] is the sub-list for field type_name
}

func init() { file_operations_proto_init() }
func file_operations_proto_init() {
	if File_operations_proto != nil {
		return
	}
	file_errors_proto_init()
	file_lint_proto_init()
	file_shared_proto_init()
	file_operations_proto_msgTypes[2].OneofWrappers = []any{
		(*UserCreateBranchError_CustomHook)(nil),
	}
	file_operations_proto_msgTypes[7].OneofWrappers = []any{
		(*UserDeleteBranchError_AccessCheck)(nil),
		(*UserDeleteBranchError_ReferenceUpdate)(nil),
		(*UserDeleteBranchError_CustomHook)(nil),
	}
	file_operations_proto_msgTypes[12].OneofWrappers = []any{
		(*UserCreateTagError_AccessCheck)(nil),
		(*UserCreateTagError_ReferenceUpdate)(nil),
		(*UserCreateTagError_CustomHook)(nil),
		(*UserCreateTagError_ReferenceExists)(nil),
	}
	file_operations_proto_msgTypes[15].OneofWrappers = []any{
		(*UserMergeBranchError_AccessCheck)(nil),
		(*UserMergeBranchError_ReferenceUpdate)(nil),
		(*UserMergeBranchError_CustomHook)(nil),
		(*UserMergeBranchError_MergeConflict)(nil),
	}
	file_operations_proto_msgTypes[21].OneofWrappers = []any{
		(*UserFFBranchError_CustomHook)(nil),
		(*UserFFBranchError_ReferenceUpdate)(nil),
	}
	file_operations_proto_msgTypes[26].OneofWrappers = []any{
		(*UserCherryPickError_CherryPickConflict)(nil),
		(*UserCherryPickError_TargetBranchDiverged)(nil),
		(*UserCherryPickError_ChangesAlreadyApplied)(nil),
		(*UserCherryPickError_AccessCheck)(nil),
	}
	file_operations_proto_msgTypes[29].OneofWrappers = []any{
		(*UserRevertError_MergeConflict)(nil),
		(*UserRevertError_ChangesAlreadyApplied)(nil),
		(*UserRevertError_CustomHook)(nil),
		(*UserRevertError_NotAncestor)(nil),
	}
	file_operations_proto_msgTypes[31].OneofWrappers = []any{
		(*UserCommitFilesAction_Header)(nil),
		(*UserCommitFilesAction_Content)(nil),
	}
	file_operations_proto_msgTypes[33].OneofWrappers = []any{
		(*UserCommitFilesRequest_Header)(nil),
		(*UserCommitFilesRequest_Action)(nil),
	}
	file_operations_proto_msgTypes[35].OneofWrappers = []any{
		(*UserCommitFilesError_AccessCheck)(nil),
		(*UserCommitFilesError_IndexUpdate)(nil),
		(*UserCommitFilesError_CustomHook)(nil),
	}
	file_operations_proto_msgTypes[36].OneofWrappers = []any{
		(*UserRebaseConfirmableRequest_Header_)(nil),
		(*UserRebaseConfirmableRequest_Apply)(nil),
	}
	file_operations_proto_msgTypes[37].OneofWrappers = []any{
		(*UserRebaseConfirmableResponse_RebaseSha)(nil),
		(*UserRebaseConfirmableResponse_RebaseApplied)(nil),
	}
	file_operations_proto_msgTypes[40].OneofWrappers = []any{
		(*UserRebaseConfirmableError_RebaseConflict)(nil),
		(*UserRebaseConfirmableError_AccessCheck)(nil),
	}
	file_operations_proto_msgTypes[41].OneofWrappers = []any{
		(*UserSquashError_ResolveRevision)(nil),
		(*UserSquashError_RebaseConflict)(nil),
	}
	file_operations_proto_msgTypes[42].OneofWrappers = []any{
		(*UserApplyPatchRequest_Header_)(nil),
		(*UserApplyPatchRequest_Patches)(nil),
	}
	file_operations_proto_msgTypes[43].OneofWrappers = []any{
		(*UserApplyPatchError_CustomHook)(nil),
	}
	file_operations_proto_msgTypes[47].OneofWrappers = []any{
		(*UserUpdateSubmoduleError_CustomHook)(nil),
		(*UserUpdateSubmoduleError_ReferenceUpdate)(nil),
		(*UserUpdateSubmoduleError_PathError)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_operations_proto_rawDesc), len(file_operations_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   50,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_operations_proto_goTypes,
		DependencyIndexes: file_operations_proto_depIdxs,
		EnumInfos:         file_operations_proto_enumTypes,
		MessageInfos:      file_operations_proto_msgTypes,
	}.Build()
	File_operations_proto = out.File
	file_operations_proto_goTypes = nil
	file_operations_proto_depIdxs = nil
}
