Merge branch 'zj-remove-user-rebase' into 'master'

Remove UserRebase RPC

Closes #1628

See merge request gitlab-org/gitaly!1851

9 files changed, 148 insertions, 723 deletions

diff --git a/changelogs/unreleased/zj-remove-user-rebase.yml b/changelogs/unreleased/zj-remove-user-rebase.yml
new file mode 100644
index 000000000..a5d7a46d3
--- /dev/null
+++ b/changelogs/unreleased/zj-remove-user-rebase.yml
@@ -0,0 +1,5 @@
+---
+title: Remove deprecated UserRebase RPC
+merge_request: 1851
+author:
+type: changed
diff --git a/internal/praefect/protoregistry/protoregistry_test.go b/internal/praefect/protoregistry/protoregistry_test.go
index e99af93ba..4afc206b8 100644
--- a/internal/praefect/protoregistry/protoregistry_test.go
+++ b/internal/praefect/protoregistry/protoregistry_test.go
@@ -81,7 +81,6 @@ func TestPopulatesProtoRegistry(t *testing.T) {
 			"UserFFBranch":        protoregistry.OpMutator,
 			"UserCherryPick":      protoregistry.OpMutator,
 			"UserCommitFiles":     protoregistry.OpMutator,
-			"UserRebase":          protoregistry.OpMutator,
 			"UserRevert":          protoregistry.OpMutator,
 			"UserSquash":          protoregistry.OpMutator,
 			"UserApplyPatch":      protoregistry.OpMutator,
diff --git a/internal/service/operations/rebase.go b/internal/service/operations/rebase.go
index 4346217ac..bc45a5334 100644
--- a/internal/service/operations/rebase.go
+++ b/internal/service/operations/rebase.go
@@ -3,15 +3,12 @@ package operations
 //lint:file-ignore SA1019 due to planned removal in issue https://gitlab.com/gitlab-org/gitaly/issues/1628
 
 import (
-	"context"
 	"errors"
 
 	"gitlab.com/gitlab-org/gitaly/internal/git"
 	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
 )
 
 func (s *server) UserRebaseConfirmable(stream gitalypb.OperationService_UserRebaseConfirmableServer) error {
@@ -116,59 +113,3 @@ func validateUserRebaseConfirmableHeader(header *gitalypb.UserRebaseConfirmableR
 
 	return nil
 }
-
-// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-func (s *server) UserRebase(ctx context.Context, req *gitalypb.UserRebaseRequest) (*gitalypb.UserRebaseResponse, error) {
-	if err := validateUserRebaseRequest(req); err != nil {
-		return nil, status.Errorf(codes.InvalidArgument, "UserRebase: %v", err)
-	}
-
-	client, err := s.ruby.OperationServiceClient(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	clientCtx, err := rubyserver.SetHeaders(ctx, req.GetRepository())
-	if err != nil {
-		return nil, err
-	}
-
-	return client.UserRebase(clientCtx, req)
-}
-
-// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-func validateUserRebaseRequest(req *gitalypb.UserRebaseRequest) error {
-	if req.GetRepository() == nil {
-		return errors.New("empty Repository")
-	}
-
-	if req.GetUser() == nil {
-		return errors.New("empty User")
-	}
-
-	if req.GetRebaseId() == "" {
-		return errors.New("empty RebaseId")
-	}
-
-	if req.GetBranch() == nil {
-		return errors.New("empty Branch")
-	}
-
-	if req.GetBranchSha() == "" {
-		return errors.New("empty BranchSha")
-	}
-
-	if req.GetRemoteRepository() == nil {
-		return errors.New("empty RemoteRepository")
-	}
-
-	if req.GetRemoteBranch() == nil {
-		return errors.New("empty RemoteBranch")
-	}
-
-	if err := git.ValidateRevision(req.GetRemoteBranch()); err != nil {
-		return ErrInvalidBranch
-	}
-
-	return nil
-}
diff --git a/internal/service/operations/rebase_test.go b/internal/service/operations/rebase_test.go
index af6e25270..d819d1d8b 100644
--- a/internal/service/operations/rebase_test.go
+++ b/internal/service/operations/rebase_test.go
@@ -385,270 +385,6 @@ func TestFailedUserRebaseConfirmableDueToGitError(t *testing.T) {
 	require.Equal(t, branchSha, newBranchSha, "branch should not change when the rebase fails due to GitError")
 }
 
-// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-func TestSuccessfulUserRebaseRequest(t *testing.T) {
-	ctxOuter, cancel := testhelper.Context()
-	defer cancel()
-
-	server, serverSocketPath := runFullServer(t)
-	defer server.Stop()
-
-	client, conn := operations.NewOperationClient(t, serverSocketPath)
-	defer conn.Close()
-
-	testRepo, testRepoPath, cleanup := testhelper.NewTestRepo(t)
-	defer cleanup()
-
-	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
-	defer cleanup()
-
-	branchSha := getBranchSha(t, testRepoPath, branchName)
-
-	request := &gitalypb.UserRebaseRequest{
-		Repository:       testRepo,
-		User:             rebaseUser,
-		RebaseId:         "1",
-		Branch:           []byte(branchName),
-		BranchSha:        branchSha,
-		RemoteRepository: testRepoCopy,
-		RemoteBranch:     []byte("master"),
-	}
-
-	md := testhelper.GitalyServersMetadata(t, serverSocketPath)
-	ctx := metadata.NewOutgoingContext(ctxOuter, md)
-
-	response, err := client.UserRebase(ctx, request)
-	require.NoError(t, err)
-
-	newBranchSha := getBranchSha(t, testRepoPath, branchName)
-
-	require.NotEqual(t, newBranchSha, branchSha)
-	require.Equal(t, newBranchSha, response.RebaseSha)
-}
-
-// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-func TestFailedUserRebaseRequestDueToPreReceiveError(t *testing.T) {
-	ctxOuter, cancel := testhelper.Context()
-	defer cancel()
-
-	server, serverSocketPath := runFullServer(t)
-	defer server.Stop()
-
-	client, conn := operations.NewOperationClient(t, serverSocketPath)
-	defer conn.Close()
-
-	testRepo, testRepoPath, cleanup := testhelper.NewTestRepo(t)
-	defer cleanup()
-
-	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
-	defer cleanup()
-
-	branchSha := getBranchSha(t, testRepoPath, branchName)
-
-	request := &gitalypb.UserRebaseRequest{
-		Repository:       testRepo,
-		User:             rebaseUser,
-		Branch:           []byte(branchName),
-		BranchSha:        branchSha,
-		RemoteRepository: testRepoCopy,
-		RemoteBranch:     []byte("master"),
-	}
-
-	hookContent := []byte("#!/bin/sh\necho GL_ID=$GL_ID\nexit 1\n")
-	for i, hookName := range operations.GitlabPreHooks {
-		t.Run(hookName, func(t *testing.T) {
-			remove, err := operations.OverrideHooks(hookName, hookContent)
-			require.NoError(t, err, "set up hooks override")
-			defer remove()
-
-			md := testhelper.GitalyServersMetadata(t, serverSocketPath)
-			ctx := metadata.NewOutgoingContext(ctxOuter, md)
-
-			request.RebaseId = fmt.Sprintf("%d", i+1)
-			response, err := client.UserRebase(ctx, request)
-			require.NoError(t, err)
-			require.Contains(t, response.PreReceiveError, "GL_ID="+rebaseUser.GlId)
-		})
-	}
-}
-
-// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-func TestFailedUserRebaseRequestDueToGitError(t *testing.T) {
-	ctxOuter, cancel := testhelper.Context()
-	defer cancel()
-
-	server, serverSocketPath := runFullServer(t)
-	defer server.Stop()
-
-	client, conn := operations.NewOperationClient(t, serverSocketPath)
-	defer conn.Close()
-
-	testRepo, testRepoPath, cleanup := testhelper.NewTestRepo(t)
-	defer cleanup()
-
-	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
-	defer cleanup()
-
-	failedBranchName := "rebase-encoding-failure-trigger"
-	branchSha := getBranchSha(t, testRepoPath, failedBranchName)
-
-	request := &gitalypb.UserRebaseRequest{
-		Repository:       testRepo,
-		User:             rebaseUser,
-		RebaseId:         "1",
-		Branch:           []byte(failedBranchName),
-		BranchSha:        branchSha,
-		RemoteRepository: testRepoCopy,
-		RemoteBranch:     []byte("master"),
-	}
-
-	md := testhelper.GitalyServersMetadata(t, serverSocketPath)
-	ctx := metadata.NewOutgoingContext(ctxOuter, md)
-
-	response, err := client.UserRebase(ctx, request)
-	require.NoError(t, err)
-	require.Contains(t, response.GitError, "error: Failed to merge in the changes.")
-}
-
-// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-func TestFailedUserRebaseRequestDueToValidations(t *testing.T) {
-	ctxOuter, cancel := testhelper.Context()
-	defer cancel()
-
-	server, serverSocketPath := runFullServer(t)
-	defer server.Stop()
-
-	client, conn := operations.NewOperationClient(t, serverSocketPath)
-	defer conn.Close()
-
-	testRepo, _, cleanup := testhelper.NewTestRepo(t)
-	defer cleanup()
-
-	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
-	defer cleanup()
-
-	testCases := []struct {
-		desc    string
-		request *gitalypb.UserRebaseRequest
-		code    codes.Code
-	}{
-		{
-			desc: "empty repository",
-			request: &gitalypb.UserRebaseRequest{
-				Repository:       nil,
-				User:             rebaseUser,
-				RebaseId:         "1",
-				Branch:           []byte("some-branch"),
-				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
-				RemoteRepository: testRepoCopy,
-				RemoteBranch:     []byte("master"),
-			},
-			code: codes.InvalidArgument,
-		},
-		{
-			desc: "empty user",
-			request: &gitalypb.UserRebaseRequest{
-				Repository:       testRepo,
-				User:             nil,
-				RebaseId:         "1",
-				Branch:           []byte("some-branch"),
-				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
-				RemoteRepository: testRepoCopy,
-				RemoteBranch:     []byte("master"),
-			},
-			code: codes.InvalidArgument,
-		},
-		{
-			desc: "empty rebase id",
-			request: &gitalypb.UserRebaseRequest{
-				Repository:       testRepo,
-				User:             rebaseUser,
-				RebaseId:         "",
-				Branch:           []byte("some-branch"),
-				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
-				RemoteRepository: testRepoCopy,
-				RemoteBranch:     []byte("master"),
-			},
-			code: codes.InvalidArgument,
-		},
-		{
-			desc: "empty branch",
-			request: &gitalypb.UserRebaseRequest{
-				Repository:       testRepo,
-				User:             rebaseUser,
-				RebaseId:         "1",
-				Branch:           nil,
-				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
-				RemoteRepository: testRepoCopy,
-				RemoteBranch:     []byte("master"),
-			},
-			code: codes.InvalidArgument,
-		},
-		{
-			desc: "empty branch sha",
-			request: &gitalypb.UserRebaseRequest{
-				Repository:       testRepo,
-				User:             rebaseUser,
-				RebaseId:         "1",
-				Branch:           []byte("some-branch"),
-				BranchSha:        "",
-				RemoteRepository: testRepoCopy,
-				RemoteBranch:     []byte("master"),
-			},
-			code: codes.InvalidArgument,
-		},
-		{
-			desc: "empty remote repository",
-			request: &gitalypb.UserRebaseRequest{
-				Repository:       testRepo,
-				User:             rebaseUser,
-				RebaseId:         "1",
-				Branch:           []byte("some-branch"),
-				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
-				RemoteRepository: nil,
-				RemoteBranch:     []byte("master"),
-			},
-			code: codes.InvalidArgument,
-		},
-		{
-			desc: "empty remote branch",
-			request: &gitalypb.UserRebaseRequest{
-				Repository:       testRepo,
-				User:             rebaseUser,
-				RebaseId:         "1",
-				Branch:           []byte("some-branch"),
-				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
-				RemoteRepository: testRepoCopy,
-				RemoteBranch:     nil,
-			},
-			code: codes.InvalidArgument,
-		},
-		{
-			desc: "invalid remote branch",
-			request: &gitalypb.UserRebaseRequest{
-				Repository:       testRepo,
-				User:             rebaseUser,
-				RebaseId:         "1",
-				Branch:           []byte("some-branch"),
-				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
-				RemoteRepository: testRepoCopy,
-				RemoteBranch:     []byte("+dev:master"),
-			},
-			code: codes.InvalidArgument,
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.desc, func(t *testing.T) {
-			md := testhelper.GitalyServersMetadata(t, serverSocketPath)
-			ctx := metadata.NewOutgoingContext(ctxOuter, md)
-
-			_, err := client.UserRebase(ctx, testCase.request)
-			testhelper.RequireGrpcError(t, err, testCase.code)
-		})
-	}
-}
-
 func getBranchSha(t *testing.T, repoPath string, branchName string) string {
 	branchSha := string(testhelper.MustRunCommand(t, nil, "git", "-C", repoPath, "rev-parse", branchName))
 	return strings.TrimSpace(branchSha)
diff --git a/proto/go/gitalypb/operations.pb.go b/proto/go/gitalypb/operations.pb.go
index daed95f1a..c8e89fb52 100644
--- a/proto/go/gitalypb/operations.pb.go
+++ b/proto/go/gitalypb/operations.pb.go
@@ -1825,154 +1825,6 @@ func (m *UserCommitFilesResponse) GetPreReceiveError() string {
 	return ""
 }
 
-// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-//
-// Deprecated: Do not use.
-type UserRebaseRequest struct {
-	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
-	User                 *User       `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
-	RebaseId             string      `protobuf:"bytes,3,opt,name=rebase_id,json=rebaseId,proto3" json:"rebase_id,omitempty"`
-	Branch               []byte      `protobuf:"bytes,4,opt,name=branch,proto3" json:"branch,omitempty"`
-	BranchSha            string      `protobuf:"bytes,5,opt,name=branch_sha,json=branchSha,proto3" json:"branch_sha,omitempty"`
-	RemoteRepository     *Repository `protobuf:"bytes,6,opt,name=remote_repository,json=remoteRepository,proto3" json:"remote_repository,omitempty"`
-	RemoteBranch         []byte      `protobuf:"bytes,7,opt,name=remote_branch,json=remoteBranch,proto3" json:"remote_branch,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
-	XXX_unrecognized     []byte      `json:"-"`
-	XXX_sizecache        int32       `json:"-"`
-}
-
-func (m *UserRebaseRequest) Reset()         { *m = UserRebaseRequest{} }
-func (m *UserRebaseRequest) String() string { return proto.CompactTextString(m) }
-func (*UserRebaseRequest) ProtoMessage()    {}
-func (*UserRebaseRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{26}
-}
-
-func (m *UserRebaseRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_UserRebaseRequest.Unmarshal(m, b)
-}
-func (m *UserRebaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_UserRebaseRequest.Marshal(b, m, deterministic)
-}
-func (m *UserRebaseRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UserRebaseRequest.Merge(m, src)
-}
-func (m *UserRebaseRequest) XXX_Size() int {
-	return xxx_messageInfo_UserRebaseRequest.Size(m)
-}
-func (m *UserRebaseRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_UserRebaseRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UserRebaseRequest proto.InternalMessageInfo
-
-func (m *UserRebaseRequest) GetRepository() *Repository {
-	if m != nil {
-		return m.Repository
-	}
-	return nil
-}
-
-func (m *UserRebaseRequest) GetUser() *User {
-	if m != nil {
-		return m.User
-	}
-	return nil
-}
-
-func (m *UserRebaseRequest) GetRebaseId() string {
-	if m != nil {
-		return m.RebaseId
-	}
-	return ""
-}
-
-func (m *UserRebaseRequest) GetBranch() []byte {
-	if m != nil {
-		return m.Branch
-	}
-	return nil
-}
-
-func (m *UserRebaseRequest) GetBranchSha() string {
-	if m != nil {
-		return m.BranchSha
-	}
-	return ""
-}
-
-func (m *UserRebaseRequest) GetRemoteRepository() *Repository {
-	if m != nil {
-		return m.RemoteRepository
-	}
-	return nil
-}
-
-func (m *UserRebaseRequest) GetRemoteBranch() []byte {
-	if m != nil {
-		return m.RemoteBranch
-	}
-	return nil
-}
-
-// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-//
-// Deprecated: Do not use.
-type UserRebaseResponse struct {
-	RebaseSha            string   `protobuf:"bytes,1,opt,name=rebase_sha,json=rebaseSha,proto3" json:"rebase_sha,omitempty"`
-	PreReceiveError      string   `protobuf:"bytes,2,opt,name=pre_receive_error,json=preReceiveError,proto3" json:"pre_receive_error,omitempty"`
-	GitError             string   `protobuf:"bytes,3,opt,name=git_error,json=gitError,proto3" json:"git_error,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *UserRebaseResponse) Reset()         { *m = UserRebaseResponse{} }
-func (m *UserRebaseResponse) String() string { return proto.CompactTextString(m) }
-func (*UserRebaseResponse) ProtoMessage()    {}
-func (*UserRebaseResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{27}
-}
-
-func (m *UserRebaseResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_UserRebaseResponse.Unmarshal(m, b)
-}
-func (m *UserRebaseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_UserRebaseResponse.Marshal(b, m, deterministic)
-}
-func (m *UserRebaseResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UserRebaseResponse.Merge(m, src)
-}
-func (m *UserRebaseResponse) XXX_Size() int {
-	return xxx_messageInfo_UserRebaseResponse.Size(m)
-}
-func (m *UserRebaseResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_UserRebaseResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UserRebaseResponse proto.InternalMessageInfo
-
-func (m *UserRebaseResponse) GetRebaseSha() string {
-	if m != nil {
-		return m.RebaseSha
-	}
-	return ""
-}
-
-func (m *UserRebaseResponse) GetPreReceiveError() string {
-	if m != nil {
-		return m.PreReceiveError
-	}
-	return ""
-}
-
-func (m *UserRebaseResponse) GetGitError() string {
-	if m != nil {
-		return m.GitError
-	}
-	return ""
-}
-
 type UserRebaseConfirmableRequest struct {
 	// Types that are valid to be assigned to UserRebaseConfirmableRequestPayload:
 	//	*UserRebaseConfirmableRequest_Header_
@@ -1987,7 +1839,7 @@ func (m *UserRebaseConfirmableRequest) Reset()         { *m = UserRebaseConfirma
 func (m *UserRebaseConfirmableRequest) String() string { return proto.CompactTextString(m) }
 func (*UserRebaseConfirmableRequest) ProtoMessage()    {}
 func (*UserRebaseConfirmableRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{28}
+	return fileDescriptor_1b4a5877375e491e, []int{26}
 }
 
 func (m *UserRebaseConfirmableRequest) XXX_Unmarshal(b []byte) error {
@@ -2073,7 +1925,7 @@ func (m *UserRebaseConfirmableRequest_Header) Reset()         { *m = UserRebaseC
 func (m *UserRebaseConfirmableRequest_Header) String() string { return proto.CompactTextString(m) }
 func (*UserRebaseConfirmableRequest_Header) ProtoMessage()    {}
 func (*UserRebaseConfirmableRequest_Header) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{28, 0}
+	return fileDescriptor_1b4a5877375e491e, []int{26, 0}
 }
 
 func (m *UserRebaseConfirmableRequest_Header) XXX_Unmarshal(b []byte) error {
@@ -2166,7 +2018,7 @@ func (m *UserRebaseConfirmableResponse) Reset()         { *m = UserRebaseConfirm
 func (m *UserRebaseConfirmableResponse) String() string { return proto.CompactTextString(m) }
 func (*UserRebaseConfirmableResponse) ProtoMessage()    {}
 func (*UserRebaseConfirmableResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{29}
+	return fileDescriptor_1b4a5877375e491e, []int{27}
 }
 
 func (m *UserRebaseConfirmableResponse) XXX_Unmarshal(b []byte) error {
@@ -2265,7 +2117,7 @@ func (m *UserSquashRequest) Reset()         { *m = UserSquashRequest{} }
 func (m *UserSquashRequest) String() string { return proto.CompactTextString(m) }
 func (*UserSquashRequest) ProtoMessage()    {}
 func (*UserSquashRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{30}
+	return fileDescriptor_1b4a5877375e491e, []int{28}
 }
 
 func (m *UserSquashRequest) XXX_Unmarshal(b []byte) error {
@@ -2347,7 +2199,7 @@ func (m *UserSquashResponse) Reset()         { *m = UserSquashResponse{} }
 func (m *UserSquashResponse) String() string { return proto.CompactTextString(m) }
 func (*UserSquashResponse) ProtoMessage()    {}
 func (*UserSquashResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{31}
+	return fileDescriptor_1b4a5877375e491e, []int{29}
 }
 
 func (m *UserSquashResponse) XXX_Unmarshal(b []byte) error {
@@ -2396,7 +2248,7 @@ func (m *UserApplyPatchRequest) Reset()         { *m = UserApplyPatchRequest{} }
 func (m *UserApplyPatchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserApplyPatchRequest) ProtoMessage()    {}
 func (*UserApplyPatchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{32}
+	return fileDescriptor_1b4a5877375e491e, []int{30}
 }
 
 func (m *UserApplyPatchRequest) XXX_Unmarshal(b []byte) error {
@@ -2475,7 +2327,7 @@ func (m *UserApplyPatchRequest_Header) Reset()         { *m = UserApplyPatchRequ
 func (m *UserApplyPatchRequest_Header) String() string { return proto.CompactTextString(m) }
 func (*UserApplyPatchRequest_Header) ProtoMessage()    {}
 func (*UserApplyPatchRequest_Header) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{32, 0}
+	return fileDescriptor_1b4a5877375e491e, []int{30, 0}
 }
 
 func (m *UserApplyPatchRequest_Header) XXX_Unmarshal(b []byte) error {
@@ -2528,7 +2380,7 @@ func (m *UserApplyPatchResponse) Reset()         { *m = UserApplyPatchResponse{}
 func (m *UserApplyPatchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserApplyPatchResponse) ProtoMessage()    {}
 func (*UserApplyPatchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{33}
+	return fileDescriptor_1b4a5877375e491e, []int{31}
 }
 
 func (m *UserApplyPatchResponse) XXX_Unmarshal(b []byte) error {
@@ -2572,7 +2424,7 @@ func (m *UserUpdateSubmoduleRequest) Reset()         { *m = UserUpdateSubmoduleR
 func (m *UserUpdateSubmoduleRequest) String() string { return proto.CompactTextString(m) }
 func (*UserUpdateSubmoduleRequest) ProtoMessage()    {}
 func (*UserUpdateSubmoduleRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{34}
+	return fileDescriptor_1b4a5877375e491e, []int{32}
 }
 
 func (m *UserUpdateSubmoduleRequest) XXX_Unmarshal(b []byte) error {
@@ -2648,7 +2500,7 @@ func (m *UserUpdateSubmoduleResponse) Reset()         { *m = UserUpdateSubmodule
 func (m *UserUpdateSubmoduleResponse) String() string { return proto.CompactTextString(m) }
 func (*UserUpdateSubmoduleResponse) ProtoMessage()    {}
 func (*UserUpdateSubmoduleResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1b4a5877375e491e, []int{35}
+	return fileDescriptor_1b4a5877375e491e, []int{33}
 }
 
 func (m *UserUpdateSubmoduleResponse) XXX_Unmarshal(b []byte) error {
@@ -2720,8 +2572,6 @@ func init() {
 	proto.RegisterType((*UserCommitFilesRequestHeader)(nil), "gitaly.UserCommitFilesRequestHeader")
 	proto.RegisterType((*UserCommitFilesRequest)(nil), "gitaly.UserCommitFilesRequest")
 	proto.RegisterType((*UserCommitFilesResponse)(nil), "gitaly.UserCommitFilesResponse")
-	proto.RegisterType((*UserRebaseRequest)(nil), "gitaly.UserRebaseRequest")
-	proto.RegisterType((*UserRebaseResponse)(nil), "gitaly.UserRebaseResponse")
 	proto.RegisterType((*UserRebaseConfirmableRequest)(nil), "gitaly.UserRebaseConfirmableRequest")
 	proto.RegisterType((*UserRebaseConfirmableRequest_Header)(nil), "gitaly.UserRebaseConfirmableRequest.Header")
 	proto.RegisterType((*UserRebaseConfirmableResponse)(nil), "gitaly.UserRebaseConfirmableResponse")
@@ -2737,143 +2587,139 @@ func init() {
 func init() { proto.RegisterFile("operations.proto", fileDescriptor_1b4a5877375e491e) }
 
 var fileDescriptor_1b4a5877375e491e = []byte{
-	// 2162 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcd, 0x6f, 0x23, 0x49,
-	0x15, 0x4f, 0xdb, 0x8e, 0xe3, 0xbc, 0x38, 0x89, 0x53, 0xbb, 0x33, 0xeb, 0xf5, 0x4c, 0x98, 0x6c,
-	0x67, 0x86, 0xc9, 0x0c, 0x8b, 0x67, 0x35, 0xac, 0x00, 0x21, 0x2d, 0x68, 0xe2, 0x38, 0x64, 0x86,
-	0xcd, 0x07, 0x9d, 0x0c, 0x68, 0xd1, 0x42, 0xab, 0x63, 0x97, 0xed, 0x16, 0xb6, 0xbb, 0xb7, 0xba,
-	0x1d, 0x26, 0x1c, 0x10, 0x27, 0x04, 0x87, 0x3d, 0xf2, 0x71, 0x47, 0xe2, 0x80, 0xe0, 0x0a, 0x27,
-	0x10, 0x07, 0xb4, 0x82, 0x1b, 0x57, 0x2e, 0xfc, 0x01, 0x1c, 0xf9, 0xb8, 0x70, 0x42, 0x55, 0xef,
-	0xb5, 0xdd, 0xd5, 0xdd, 0xce, 0x26, 0x4b, 0x36, 0x3b, 0x20, 0x6e, 0xe9, 0x57, 0xcf, 0xaf, 0xde,
-	0xfb, 0xbd, 0xaf, 0xaa, 0x57, 0x81, 0x8a, 0xe7, 0x73, 0xe1, 0x84, 0xae, 0x37, 0x0c, 0xea, 0xbe,
-	0xf0, 0x42, 0x8f, 0x15, 0xbb, 0x6e, 0xe8, 0xf4, 0x4f, 0x6b, 0xe5, 0xa0, 0xe7, 0x08, 0xde, 0x46,
-	0xaa, 0xf9, 0x6b, 0x03, 0x5e, 0x7a, 0x1a, 0x70, 0xd1, 0x10, 0xdc, 0x09, 0xf9, 0xa6, 0x70, 0x86,
-	0xad, 0x9e, 0xc5, 0xdf, 0x19, 0xf1, 0x20, 0x64, 0x9f, 0x05, 0x10, 0xdc, 0xf7, 0x02, 0x37, 0xf4,
-	0xc4, 0x69, 0xd5, 0x58, 0x33, 0x36, 0x16, 0x1e, 0xb2, 0x3a, 0x8a, 0xa9, 0x5b, 0xe3, 0x95, 0xcd,
-	0xc2, 0x4f, 0xde, 0x7b, 0xd5, 0xb0, 0x62, 0xbc, 0xec, 0x16, 0x2c, 0x1c, 0x2b, 0x51, 0xf6, 0xd0,
-	0x19, 0xf0, 0x6a, 0x6e, 0xcd, 0xd8, 0x28, 0x5b, 0x80, 0xa4, 0x3d, 0x67, 0xc0, 0xd9, 0x1a, 0x14,
-	0x46, 0x01, 0x17, 0xd5, 0xbc, 0x12, 0x5a, 0x8e, 0x84, 0x4a, 0x4d, 0x2c, 0xb5, 0x22, 0x45, 0x04,
-	0xa1, 0x23, 0x42, 0xdb, 0xf7, 0xdc, 0x61, 0x58, 0x2d, 0xa0, 0x08, 0x45, 0x3a, 0x90, 0x14, 0x73,
-	0x08, 0xd5, 0xb4, 0xe2, 0x81, 0xef, 0x0d, 0x03, 0xce, 0x3e, 0x0e, 0x45, 0xdc, 0x8c, 0xb4, 0x5e,
-	0x8a, 0x36, 0x20, 0x3e, 0x5a, 0x65, 0xf7, 0x61, 0xc5, 0x17, 0xdc, 0x16, 0xbc, 0xc5, 0xdd, 0x13,
-	0x6e, 0x73, 0x21, 0x3c, 0xa1, 0xb4, 0x9d, 0xb7, 0x96, 0x7d, 0xc1, 0x2d, 0xa4, 0x37, 0x25, 0xd9,
-	0x7c, 0x8f, 0x90, 0x7a, 0xea, 0xb7, 0x9f, 0x2f, 0xa4, 0xae, 0x43, 0x71, 0xc8, 0xbf, 0x25, 0xf8,
-	0x09, 0x81, 0x44, 0x5f, 0x92, 0xee, 0xf5, 0xdb, 0x92, 0x3e, 0x8b, 0x74, 0xfc, 0x32, 0xb7, 0x11,
-	0x38, 0xdd, 0x0e, 0x02, 0x2e, 0x13, 0x10, 0x23, 0x1b, 0x90, 0x1f, 0x11, 0x20, 0x5b, 0xbc, 0xcf,
-	0x9f, 0x27, 0x40, 0x22, 0x03, 0x75, 0xbd, 0x3e, 0x80, 0x81, 0xef, 0x1a, 0xf0, 0xe2, 0x44, 0xd0,
-	0x91, 0xd3, 0xfd, 0xcf, 0xad, 0x7b, 0x19, 0x4a, 0xa1, 0xd3, 0x8d, 0x9b, 0x36, 0x17, 0x3a, 0xdd,
-	0x73, 0xda, 0xd5, 0x80, 0x6b, 0x09, 0x75, 0x3e, 0x80, 0x51, 0x7f, 0x22, 0xa3, 0x30, 0x6f, 0x3e,
-	0x72, 0xa3, 0xd8, 0x5d, 0x58, 0x0e, 0x1d, 0xd1, 0xe5, 0xa1, 0x2d, 0xf8, 0x89, 0x1b, 0xb8, 0xde,
-	0x90, 0xc2, 0x78, 0x09, 0xc9, 0x16, 0x51, 0x59, 0x15, 0xe6, 0x06, 0x3c, 0x08, 0x9c, 0x2e, 0xa7,
-	0x78, 0x8e, 0x3e, 0xcd, 0x6f, 0x23, 0x2e, 0x31, 0x8b, 0x08, 0x97, 0x55, 0xc8, 0x87, 0x4e, 0x97,
-	0x6c, 0x59, 0x88, 0x36, 0x97, 0x1c, 0x92, 0x2e, 0x13, 0x84, 0x3f, 0x73, 0x83, 0x30, 0x50, 0x5a,
-	0x97, 0x2c, 0xfa, 0xca, 0x86, 0x33, 0x9f, 0x0d, 0xe7, 0x9f, 0x0d, 0xb8, 0x2e, 0x37, 0xdf, 0xe5,
-	0xa2, 0x7b, 0x69, 0x39, 0x10, 0xa1, 0x96, 0x9b, 0x8a, 0xda, 0x0d, 0x98, 0x6f, 0x79, 0x83, 0x81,
-	0x1b, 0xda, 0x6e, 0x9b, 0x54, 0x2b, 0x21, 0xe1, 0x71, 0x5b, 0xda, 0x45, 0xd5, 0x8f, 0x0a, 0x02,
-	0x55, 0xbb, 0xa9, 0x08, 0xb2, 0x17, 0x61, 0xd6, 0xf1, 0xfd, 0xfe, 0x69, 0xb5, 0xa8, 0x80, 0xc0,
-	0x0f, 0xf3, 0x17, 0x94, 0xe0, 0x9a, 0x6d, 0x04, 0xad, 0xa6, 0x80, 0x91, 0x50, 0x60, 0x13, 0x16,
-	0x29, 0x87, 0x47, 0xaa, 0xc8, 0x90, 0xfb, 0x57, 0x23, 0x43, 0xf6, 0xa3, 0xde, 0x84, 0x42, 0xb1,
-	0x12, 0x59, 0xe5, 0xe3, 0xd8, 0x57, 0xb6, 0x13, 0x0a, 0x99, 0x4e, 0x78, 0x52, 0x28, 0xe5, 0x2a,
-	0x79, 0xf3, 0xdd, 0x1c, 0xc6, 0x81, 0x52, 0xf7, 0xc8, 0xb3, 0x78, 0xe7, 0x2a, 0x3c, 0xb1, 0x0a,
-	0x10, 0x78, 0x23, 0xd1, 0xe2, 0x76, 0xd0, 0x73, 0xc8, 0x15, 0xf3, 0x48, 0x39, 0xec, 0x39, 0x53,
-	0x7d, 0xb1, 0x0a, 0x30, 0x0e, 0xfb, 0x0e, 0xb9, 0x63, 0x3e, 0x8a, 0xf8, 0x4e, 0xdc, 0x55, 0x45,
-	0xdd, 0x55, 0x1b, 0x50, 0xe9, 0xb8, 0x22, 0x08, 0x6d, 0xdf, 0x11, 0x7c, 0x88, 0x3f, 0x9f, 0xc3,
-	0x84, 0x51, 0xf4, 0x03, 0x45, 0xb6, 0x78, 0xc7, 0x74, 0x62, 0x91, 0x49, 0x70, 0x9c, 0xc7, 0x79,
-	0x17, 0xe9, 0x89, 0xdf, 0x81, 0x6b, 0x99, 0xbe, 0x3c, 0x7b, 0x87, 0x57, 0xa0, 0x2c, 0x21, 0xb6,
-	0x5b, 0x2a, 0x61, 0xdb, 0x94, 0x7d, 0x0b, 0x92, 0x86, 0x39, 0xdc, 0x66, 0x77, 0x60, 0x89, 0x22,
-	0x28, 0x62, 0xca, 0x2b, 0x26, 0x8a, 0x2b, 0x62, 0x33, 0x7f, 0x66, 0xc0, 0x0b, 0xd2, 0xc6, 0xed,
-	0xed, 0xe7, 0x3b, 0xf5, 0xcc, 0xef, 0x51, 0xd5, 0x9d, 0x28, 0x4a, 0xae, 0x48, 0xa5, 0x8a, 0x71,
-	0x49, 0xa9, 0x32, 0xc5, 0x63, 0xbf, 0xa7, 0x24, 0x69, 0xf4, 0xb8, 0x10, 0xa7, 0x07, 0x6e, 0xeb,
-	0x9b, 0x57, 0x81, 0xd9, 0x3d, 0x28, 0x22, 0x44, 0x54, 0x09, 0x56, 0x22, 0x9e, 0x2f, 0xba, 0x61,
-	0x43, 0x2d, 0x58, 0xc4, 0x90, 0xec, 0xff, 0x85, 0x54, 0xff, 0x9f, 0x5e, 0xc5, 0xee, 0xc3, 0x0a,
-	0x1e, 0x19, 0xe3, 0x02, 0x30, 0x7d, 0x96, 0xd5, 0xc2, 0xe6, 0x44, 0xca, 0x1b, 0x50, 0x41, 0xde,
-	0x98, 0xcd, 0x73, 0xd3, 0x6c, 0xa6, 0x9f, 0x4f, 0x08, 0xe6, 0xdf, 0x72, 0x98, 0x5c, 0x71, 0x18,
-	0x2f, 0xd7, 0xa3, 0x18, 0xf7, 0x76, 0x28, 0x78, 0xc2, 0xa3, 0xb8, 0x70, 0x24, 0x38, 0x7a, 0x54,
-	0x66, 0x13, 0xc5, 0x63, 0xbc, 0x51, 0x2d, 0x20, 0x0d, 0x59, 0x2e, 0x50, 0x4b, 0x59, 0x0b, 0xae,
-	0xa7, 0xb6, 0xb6, 0x5b, 0x5e, 0x1b, 0xd1, 0x5e, 0x7a, 0x58, 0x8f, 0xbb, 0x37, 0x6d, 0x7e, 0xbd,
-	0xa1, 0xab, 0x67, 0xbd, 0x90, 0xd0, 0xb7, 0xe1, 0xb5, 0xb9, 0xf9, 0x3a, 0x2c, 0x27, 0xf8, 0x58,
-	0x09, 0x0a, 0x7b, 0xfb, 0x7b, 0xcd, 0xca, 0x0c, 0x9b, 0x87, 0xd9, 0xe6, 0xee, 0xc1, 0xd1, 0x5b,
-	0x15, 0x83, 0x95, 0xa1, 0xd4, 0xd8, 0xdf, 0xdb, 0x7e, 0xf3, 0x71, 0xe3, 0xa8, 0x92, 0x33, 0x7f,
-	0x97, 0x83, 0x15, 0x15, 0x54, 0xfc, 0x84, 0x4b, 0x6f, 0xfc, 0x3f, 0x6e, 0x2f, 0x1c, 0xb7, 0x7f,
-	0xcd, 0x01, 0x8b, 0x43, 0xf8, 0xbf, 0x11, 0xb3, 0xf6, 0xfb, 0xc4, 0xec, 0x7d, 0xcd, 0xb5, 0x9a,
-	0xe9, 0x1f, 0x66, 0xbc, 0xfe, 0x33, 0x07, 0x37, 0x54, 0x96, 0x28, 0xb3, 0xb6, 0xdd, 0x3e, 0x0f,
-	0x1e, 0xb5, 0x24, 0x8a, 0x3b, 0xdc, 0x69, 0x73, 0xc1, 0xb6, 0xa1, 0xe8, 0xa8, 0x6f, 0x05, 0x77,
-	0x32, 0xb5, 0xb2, 0x7f, 0x54, 0xc7, 0x8f, 0xa3, 0x53, 0x9f, 0x5b, 0xf4, 0x6b, 0xd9, 0x91, 0x3a,
-	0x6e, 0x9f, 0xdb, 0xbe, 0x13, 0xf6, 0xe8, 0x00, 0x5e, 0x92, 0x84, 0x03, 0x27, 0xec, 0xb1, 0x75,
-	0x58, 0xf4, 0xe5, 0xc9, 0xda, 0x1b, 0x05, 0xc8, 0x90, 0x57, 0x0c, 0xe5, 0x88, 0xa8, 0x98, 0x64,
-	0xbb, 0x75, 0x02, 0xfe, 0xe9, 0xd7, 0xed, 0x96, 0x37, 0x0c, 0x39, 0xdd, 0xb7, 0x65, 0xbb, 0x55,
-	0xd4, 0x06, 0x12, 0xd9, 0x3d, 0xa8, 0xf0, 0x67, 0xbc, 0x35, 0x0a, 0xb9, 0x2d, 0xe5, 0x0f, 0x22,
-	0x84, 0x4b, 0xd6, 0x32, 0xd1, 0xb7, 0x89, 0x2c, 0xb7, 0x75, 0x87, 0x1d, 0x2e, 0xc6, 0x02, 0xf1,
-	0x64, 0x59, 0x56, 0x44, 0x92, 0x67, 0x3e, 0x05, 0x98, 0x98, 0xc3, 0x00, 0x8a, 0x0d, 0xab, 0xf9,
-	0xe8, 0x48, 0x62, 0xba, 0x04, 0x80, 0x7f, 0xdb, 0x5b, 0x8f, 0xad, 0x8a, 0x21, 0xd7, 0x9e, 0x1e,
-	0x6c, 0xc9, 0xb5, 0x9c, 0x44, 0x7e, 0x77, 0xff, 0x2b, 0xcd, 0x4a, 0x5e, 0x52, 0xb7, 0x9a, 0x6f,
-	0x36, 0x8f, 0x9a, 0x95, 0x82, 0xf4, 0x42, 0x63, 0x67, 0x77, 0x7f, 0xab, 0x32, 0x2b, 0x2f, 0xa6,
-	0xd7, 0x32, 0x21, 0x64, 0x6f, 0x40, 0xb1, 0xa7, 0x60, 0xa4, 0x00, 0x5f, 0x3f, 0x07, 0xe2, 0x3b,
-	0x33, 0x16, 0xfd, 0x88, 0xd5, 0x60, 0x2e, 0x32, 0x47, 0xc1, 0xbc, 0x33, 0x63, 0x45, 0x84, 0x4d,
-	0x13, 0xd6, 0x64, 0xc9, 0xb0, 0x29, 0xae, 0x25, 0x3e, 0x81, 0x8d, 0x0e, 0xb2, 0x7d, 0xe7, 0xb4,
-	0xef, 0x39, 0x6d, 0xf3, 0xb7, 0x79, 0xb8, 0x99, 0xd8, 0x89, 0xaa, 0x18, 0x45, 0xc4, 0x87, 0x59,
-	0xcb, 0x12, 0x05, 0x2a, 0x9f, 0x2a, 0x50, 0x77, 0x60, 0x89, 0x94, 0x8f, 0xea, 0x14, 0x16, 0xb1,
-	0x45, 0xa4, 0xee, 0x52, 0xb5, 0x7a, 0x15, 0x18, 0xb1, 0x39, 0xa3, 0xb0, 0xe7, 0x09, 0x14, 0x87,
-	0x25, 0xad, 0x82, 0x2b, 0x8f, 0xd4, 0x82, 0x12, 0x5a, 0x87, 0x17, 0x74, 0x6e, 0x3e, 0x70, 0xdc,
-	0x3e, 0x55, 0xb7, 0x95, 0x38, 0x7b, 0x53, 0x2e, 0x64, 0xd7, 0xc2, 0xb9, 0xf3, 0xd7, 0xc2, 0xd2,
-	0xb9, 0x6b, 0xa1, 0xbc, 0xf4, 0x74, 0x3c, 0xd1, 0xe2, 0xd5, 0x79, 0xbc, 0xf4, 0xa8, 0x0f, 0x99,
-	0x4c, 0x28, 0x54, 0x1e, 0xe7, 0x01, 0x8f, 0x77, 0x8a, 0x70, 0xd8, 0x73, 0xcc, 0x5f, 0xd1, 0x6d,
-	0x2f, 0xed, 0x40, 0xf6, 0xf9, 0x44, 0x68, 0xdd, 0x9e, 0x12, 0x5a, 0x9a, 0xc3, 0x63, 0xb1, 0xf5,
-	0x99, 0x71, 0x31, 0xc8, 0xe9, 0xb5, 0x37, 0x3b, 0x34, 0x67, 0xa2, 0xec, 0xdf, 0x5c, 0x87, 0x57,
-	0xd2, 0x81, 0x27, 0x70, 0x97, 0x71, 0xe4, 0xfd, 0x3c, 0x1a, 0xf3, 0xc5, 0x15, 0xb9, 0xc4, 0xe2,
-	0x7f, 0x0b, 0x16, 0xdc, 0x61, 0x9b, 0x3f, 0xd3, 0xca, 0x3e, 0x28, 0xd2, 0x19, 0xe5, 0x7c, 0xca,
-	0x9d, 0xfa, 0x97, 0xe3, 0x3e, 0x2f, 0xcb, 0xcf, 0x15, 0x9d, 0xe9, 0x85, 0xda, 0x2c, 0x76, 0xa6,
-	0x47, 0xc2, 0x19, 0xd7, 0xe9, 0x55, 0xa0, 0xec, 0x51, 0xa1, 0x32, 0x8b, 0x37, 0x3f, 0xa4, 0xc8,
-	0x9b, 0xdf, 0x17, 0x60, 0x45, 0xf0, 0x81, 0x17, 0xf2, 0x78, 0x78, 0x16, 0xa7, 0x86, 0x67, 0x05,
-	0x99, 0x63, 0xf1, 0xb9, 0x0e, 0x8b, 0x24, 0x80, 0xb6, 0xc7, 0x34, 0x28, 0x23, 0x11, 0x9d, 0xf1,
-	0xb9, 0x5c, 0xd5, 0x30, 0xbf, 0x6b, 0x44, 0x4d, 0x1d, 0xf1, 0x1a, 0x4f, 0x3f, 0x80, 0x8c, 0x92,
-	0xfa, 0xe1, 0x25, 0x8c, 0xcc, 0x94, 0xfa, 0x5d, 0xe0, 0xd6, 0x20, 0xf1, 0xe9, 0x26, 0x9a, 0x75,
-	0xa9, 0x4b, 0x9d, 0x5a, 0xa9, 0xf0, 0x77, 0xaa, 0x6c, 0xa8, 0x42, 0xc3, 0x1b, 0x76, 0x5c, 0x31,
-	0x70, 0x8e, 0xfb, 0x63, 0xef, 0x35, 0x13, 0xe9, 0xf1, 0x09, 0xbd, 0x25, 0x67, 0xff, 0xaa, 0x9e,
-	0xca, 0x92, 0xeb, 0xd1, 0xa0, 0x42, 0xdd, 0x19, 0x77, 0x66, 0x68, 0x54, 0x51, 0xfb, 0x43, 0x0e,
-	0x8a, 0x57, 0x50, 0x43, 0xff, 0x6b, 0xe3, 0x84, 0x6d, 0x40, 0x45, 0x7a, 0xd0, 0x1f, 0x05, 0x3d,
-	0xdb, 0xf3, 0xd5, 0xbb, 0x40, 0xb5, 0xb4, 0x96, 0xdf, 0x98, 0xb7, 0x96, 0xba, 0x6e, 0x78, 0x30,
-	0x0a, 0x7a, 0xfb, 0x48, 0xdd, 0xbc, 0x07, 0x77, 0x55, 0x3d, 0x21, 0x43, 0x5b, 0x13, 0xaf, 0xa4,
-	0xaa, 0xca, 0x5f, 0x0c, 0x58, 0x9d, 0xe2, 0x3f, 0x8a, 0xc1, 0x5b, 0xe9, 0x18, 0xdc, 0x99, 0x89,
-	0x47, 0xe1, 0x5d, 0x58, 0x22, 0x06, 0xe9, 0x48, 0x37, 0x9a, 0x06, 0xec, 0xcc, 0x58, 0x8b, 0x48,
-	0x7f, 0x84, 0xe4, 0x8b, 0x14, 0x10, 0x3d, 0x5c, 0x0b, 0x7a, 0xb8, 0x6e, 0xde, 0x87, 0x8d, 0xe9,
-	0xf6, 0xa1, 0xda, 0x63, 0x03, 0x7f, 0x48, 0x95, 0xe8, 0xf0, 0x9d, 0x91, 0x13, 0x5c, 0xd5, 0x74,
-	0x21, 0x50, 0x9b, 0xc5, 0x22, 0x0c, 0x09, 0x8f, 0xdb, 0x7a, 0x6f, 0x9a, 0xd5, 0x7b, 0x13, 0x7b,
-	0x09, 0xe6, 0xf8, 0xb0, 0xad, 0x96, 0x8a, 0x6a, 0xa9, 0xc8, 0x87, 0x6d, 0xb9, 0x70, 0x1b, 0x8a,
-	0xd8, 0x7b, 0xe9, 0xa2, 0xa0, 0x6f, 0x4b, 0x6b, 0x19, 0xdd, 0xbf, 0x94, 0xd1, 0xfd, 0x9f, 0x14,
-	0x4a, 0x85, 0xca, 0xac, 0xe9, 0x62, 0xc1, 0x89, 0x60, 0x99, 0x14, 0x1c, 0xd2, 0x3d, 0x56, 0x70,
-	0x90, 0x22, 0xf5, 0x38, 0xab, 0x88, 0xe0, 0x08, 0xcf, 0x4a, 0xbb, 0xd8, 0xfc, 0x29, 0x0d, 0x2c,
-	0x64, 0x1c, 0x9c, 0x1e, 0x38, 0xe1, 0x64, 0xc8, 0x73, 0x66, 0xc7, 0x4d, 0xb1, 0xd7, 0xb3, 0x4e,
-	0x73, 0xbe, 0x64, 0xe0, 0xc1, 0xe4, 0x34, 0x47, 0x84, 0xda, 0x0f, 0x8c, 0x2b, 0xa9, 0x27, 0xeb,
-	0xb0, 0x48, 0x53, 0x40, 0x4a, 0x5d, 0x3a, 0x9c, 0x23, 0x11, 0x53, 0x77, 0x7c, 0xb2, 0x54, 0x95,
-	0xce, 0x56, 0x1a, 0xa6, 0x32, 0xf1, 0x6d, 0x3c, 0x97, 0xc4, 0xad, 0xbe, 0xbc, 0xee, 0x6e, 0xfe,
-	0xc3, 0x80, 0xda, 0xe4, 0xc9, 0xe8, 0x70, 0x74, 0x3c, 0xf0, 0xda, 0xa3, 0x3e, 0xbf, 0xa2, 0xf1,
-	0x2a, 0x85, 0x65, 0x6c, 0xbc, 0x8a, 0x94, 0xb3, 0xc6, 0xab, 0x37, 0x61, 0x3e, 0x88, 0xd4, 0x8c,
-	0xa6, 0xab, 0x63, 0x42, 0x46, 0xac, 0x17, 0x33, 0x62, 0xdd, 0xfc, 0xa3, 0x81, 0xf7, 0xb7, 0x94,
-	0xd9, 0x1f, 0xcd, 0xec, 0x2e, 0x75, 0x6b, 0x2e, 0xa4, 0x6e, 0xcd, 0x4f, 0x0a, 0xa5, 0x7c, 0xa5,
-	0x60, 0xa5, 0x2f, 0xe2, 0x0f, 0x7f, 0xb3, 0x00, 0x95, 0xb1, 0x3e, 0x87, 0x5c, 0x9c, 0xb8, 0x2d,
-	0xce, 0xbe, 0x0e, 0x95, 0xe4, 0x13, 0x2a, 0xbb, 0xa5, 0x9d, 0x3b, 0xd3, 0xaf, 0xc2, 0xb5, 0xb5,
-	0xe9, 0x0c, 0x88, 0x8b, 0x59, 0xfc, 0xd7, 0x8f, 0x37, 0x72, 0x25, 0x23, 0x12, 0x1f, 0x7f, 0x68,
-	0xd4, 0xc5, 0x67, 0x3c, 0xa5, 0xea, 0xe2, 0xb3, 0xde, 0x28, 0x93, 0xe2, 0xe3, 0xcf, 0x7c, 0xba,
-	0xf8, 0x8c, 0x87, 0x49, 0x5d, 0x7c, 0xd6, 0x0b, 0xe1, 0x58, 0xfc, 0x11, 0x2c, 0x6a, 0xaf, 0x4a,
-	0xec, 0x66, 0xda, 0xf0, 0xc9, 0xf3, 0x59, 0x6d, 0x75, 0xca, 0x6a, 0xb6, 0xd4, 0xf1, 0x1b, 0x9e,
-	0x2e, 0x35, 0xf9, 0xd2, 0xa8, 0x4b, 0x4d, 0x3d, 0xfc, 0x8d, 0xa5, 0x7e, 0x15, 0x96, 0xf4, 0x51,
-	0x3f, 0xd3, 0x7e, 0x98, 0x7a, 0x11, 0xa9, 0x7d, 0x6c, 0xda, 0x72, 0x42, 0xf0, 0x37, 0x60, 0x39,
-	0xf1, 0x02, 0xc4, 0xd2, 0x3f, 0xd5, 0x11, 0xbe, 0x35, 0x75, 0x5d, 0x97, 0xbd, 0x61, 0xbc, 0x66,
-	0xb0, 0x2f, 0x43, 0x39, 0x3e, 0x16, 0x67, 0x37, 0xe2, 0x3f, 0x4e, 0x4c, 0xf5, 0x6b, 0x37, 0xb3,
-	0x17, 0xb3, 0xb1, 0x98, 0x8c, 0x26, 0x75, 0x2c, 0x52, 0x83, 0x6f, 0x1d, 0x8b, 0xf4, 0x44, 0x73,
-	0x2c, 0xf8, 0x6d, 0xc4, 0x22, 0x76, 0x85, 0xd2, 0xb1, 0x48, 0x5f, 0xf2, 0x74, 0x2c, 0x32, 0xee,
-	0x5e, 0x13, 0x2c, 0xd8, 0x1e, 0xc0, 0xe4, 0x28, 0xc5, 0x5e, 0x4e, 0x1f, 0x8f, 0x23, 0x99, 0xb5,
-	0xac, 0x25, 0x12, 0x37, 0x8f, 0xe2, 0xbe, 0x9f, 0x33, 0x98, 0x8f, 0x6d, 0x33, 0x75, 0x34, 0x63,
-	0xb7, 0xcf, 0x73, 0xf2, 0xae, 0xdd, 0x79, 0x1f, 0xae, 0x0c, 0x5f, 0x7e, 0x29, 0xb2, 0xe0, 0x84,
-	0x8b, 0x30, 0x69, 0x41, 0x6c, 0x62, 0x9b, 0xb4, 0x20, 0x3e, 0x8e, 0x1b, 0x83, 0x4d, 0xc2, 0xf0,
-	0x84, 0xa1, 0x0b, 0xd3, 0x0e, 0x63, 0xba, 0x30, 0xfd, 0x40, 0x32, 0x16, 0xf6, 0x16, 0x86, 0xc4,
-	0xa4, 0x3b, 0xea, 0x21, 0x91, 0x3a, 0x2b, 0xe8, 0x21, 0x91, 0x6e, 0xaa, 0x31, 0xb7, 0x75, 0xf0,
-	0x01, 0x2a, 0xd1, 0x22, 0x98, 0x99, 0xae, 0x62, 0xc9, 0xb6, 0x59, 0x5b, 0x3f, 0x93, 0x47, 0xdf,
-	0x69, 0xf3, 0xb5, 0xaf, 0x49, 0xee, 0xbe, 0x73, 0x5c, 0x6f, 0x79, 0x83, 0x07, 0xf8, 0xe7, 0x27,
-	0x3d, 0xd1, 0x7d, 0x80, 0x32, 0x1e, 0xa8, 0xff, 0xe6, 0x79, 0xd0, 0xf5, 0xe8, 0xdb, 0x3f, 0x3e,
-	0x2e, 0x2a, 0xd2, 0xa7, 0xfe, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x60, 0xb0, 0x86, 0xfc, 0x0a, 0x24,
-	0x00, 0x00,
+	// 2110 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcd, 0x73, 0x1b, 0x49,
+	0x15, 0xf7, 0x48, 0xb2, 0x2c, 0x3f, 0xcb, 0xb6, 0xdc, 0xd9, 0x64, 0xbd, 0x4a, 0x4c, 0xbc, 0xe3,
+	0x84, 0x38, 0x61, 0x51, 0xb6, 0xc2, 0x16, 0x70, 0x59, 0xa8, 0x58, 0x96, 0x71, 0xc2, 0x3a, 0x36,
+	0x63, 0x07, 0x6a, 0xa9, 0x85, 0xa9, 0xb1, 0xd4, 0x92, 0xa6, 0x90, 0x34, 0xb3, 0x3d, 0x23, 0x13,
+	0x73, 0xe0, 0x48, 0x15, 0x87, 0x3d, 0xf2, 0x71, 0xa7, 0x8a, 0x03, 0xc5, 0x19, 0x6e, 0x14, 0x07,
+	0x6a, 0x0b, 0x6e, 0x5c, 0xb9, 0xf0, 0x07, 0x50, 0xc5, 0x85, 0x8f, 0x0b, 0x27, 0xaa, 0xfb, 0xbd,
+	0x19, 0x4d, 0xcf, 0x8c, 0xbc, 0xce, 0xe2, 0x78, 0x53, 0xd4, 0xde, 0x3c, 0xaf, 0x9f, 0x5e, 0xbf,
+	0xf7, 0x7b, 0x1f, 0xfd, 0x5e, 0xb7, 0xa1, 0xe6, 0xf9, 0x5c, 0x38, 0xa1, 0xeb, 0x8d, 0x82, 0x86,
+	0x2f, 0xbc, 0xd0, 0x63, 0xe5, 0x9e, 0x1b, 0x3a, 0x83, 0xd3, 0x7a, 0x35, 0xe8, 0x3b, 0x82, 0x77,
+	0x90, 0x6a, 0xfe, 0xd6, 0x80, 0x57, 0x9f, 0x06, 0x5c, 0x34, 0x05, 0x77, 0x42, 0xbe, 0x25, 0x9c,
+	0x51, 0xbb, 0x6f, 0xf1, 0xf7, 0xc7, 0x3c, 0x08, 0xd9, 0x97, 0x01, 0x04, 0xf7, 0xbd, 0xc0, 0x0d,
+	0x3d, 0x71, 0xba, 0x6a, 0xac, 0x1b, 0x9b, 0x0b, 0x0f, 0x58, 0x03, 0xc5, 0x34, 0xac, 0x78, 0x65,
+	0xab, 0xf4, 0xf3, 0x0f, 0xdf, 0x30, 0xac, 0x04, 0x2f, 0xbb, 0x09, 0x0b, 0xc7, 0x4a, 0x94, 0x3d,
+	0x72, 0x86, 0x7c, 0xb5, 0xb0, 0x6e, 0x6c, 0x56, 0x2d, 0x40, 0xd2, 0x13, 0x67, 0xc8, 0xd9, 0x3a,
+	0x94, 0xc6, 0x01, 0x17, 0xab, 0x45, 0x25, 0xb4, 0x1a, 0x09, 0x95, 0x9a, 0x58, 0x6a, 0x45, 0x8a,
+	0x08, 0x42, 0x47, 0x84, 0xb6, 0xef, 0xb9, 0xa3, 0x70, 0xb5, 0x84, 0x22, 0x14, 0xe9, 0x40, 0x52,
+	0xcc, 0x11, 0xac, 0x66, 0x15, 0x0f, 0x7c, 0x6f, 0x14, 0x70, 0xf6, 0x59, 0x28, 0xe3, 0x66, 0xa4,
+	0xf5, 0x52, 0xb4, 0x01, 0xf1, 0xd1, 0x2a, 0xbb, 0x07, 0x2b, 0xbe, 0xe0, 0xb6, 0xe0, 0x6d, 0xee,
+	0x9e, 0x70, 0x9b, 0x0b, 0xe1, 0x09, 0xa5, 0xed, 0xbc, 0xb5, 0xec, 0x0b, 0x6e, 0x21, 0xbd, 0x25,
+	0xc9, 0xe6, 0x87, 0x84, 0xd4, 0x53, 0xbf, 0xf3, 0x72, 0x21, 0x75, 0x0d, 0xca, 0x23, 0xfe, 0x7d,
+	0xc1, 0x4f, 0x08, 0x24, 0xfa, 0x92, 0x74, 0x6f, 0xd0, 0x91, 0xf4, 0x59, 0xa4, 0xe3, 0x97, 0xb9,
+	0x83, 0xc0, 0xe9, 0x76, 0x10, 0x70, 0xb9, 0x80, 0x18, 0xf9, 0x80, 0xfc, 0x94, 0x00, 0xd9, 0xe6,
+	0x03, 0xfe, 0x32, 0x01, 0x12, 0x19, 0xa8, 0xeb, 0xf5, 0x31, 0x0c, 0xfc, 0xc0, 0x80, 0x57, 0x26,
+	0x82, 0x8e, 0x9c, 0xde, 0xff, 0x6e, 0xdd, 0x6b, 0x50, 0x09, 0x9d, 0x5e, 0xd2, 0xb4, 0xb9, 0xd0,
+	0xe9, 0x9d, 0xd3, 0xae, 0x26, 0x5c, 0x4d, 0xa9, 0xf3, 0x31, 0x8c, 0xfa, 0x33, 0x19, 0x85, 0x79,
+	0xf3, 0x89, 0x1b, 0xc5, 0xee, 0xc0, 0x72, 0xe8, 0x88, 0x1e, 0x0f, 0x6d, 0xc1, 0x4f, 0xdc, 0xc0,
+	0xf5, 0x46, 0x14, 0xc6, 0x4b, 0x48, 0xb6, 0x88, 0xca, 0x56, 0x61, 0x6e, 0xc8, 0x83, 0xc0, 0xe9,
+	0x71, 0x8a, 0xe7, 0xe8, 0xd3, 0xfc, 0x01, 0xe2, 0x92, 0xb0, 0x88, 0x70, 0x59, 0x83, 0x62, 0xe8,
+	0xf4, 0xc8, 0x96, 0x85, 0x68, 0x73, 0xc9, 0x21, 0xe9, 0x32, 0x41, 0xf8, 0x33, 0x37, 0x08, 0x03,
+	0xa5, 0x75, 0xc5, 0xa2, 0xaf, 0x7c, 0x38, 0x8b, 0xf9, 0x70, 0xfe, 0xc5, 0x80, 0x6b, 0x72, 0xf3,
+	0x3d, 0x2e, 0x7a, 0x17, 0x96, 0x03, 0x11, 0x6a, 0x85, 0xa9, 0xa8, 0x5d, 0x87, 0xf9, 0xb6, 0x37,
+	0x1c, 0xba, 0xa1, 0xed, 0x76, 0x48, 0xb5, 0x0a, 0x12, 0x1e, 0x75, 0xa4, 0x5d, 0x54, 0xfd, 0xa8,
+	0x20, 0x50, 0xb5, 0x9b, 0x8a, 0x20, 0x7b, 0x05, 0x66, 0x1d, 0xdf, 0x1f, 0x9c, 0xae, 0x96, 0x15,
+	0x10, 0xf8, 0x61, 0xfe, 0x9a, 0x12, 0x5c, 0xb3, 0x8d, 0xa0, 0xd5, 0x14, 0x30, 0x52, 0x0a, 0x6c,
+	0xc1, 0x22, 0xe5, 0xf0, 0x58, 0x15, 0x19, 0x72, 0xff, 0x5a, 0x64, 0xc8, 0x7e, 0x74, 0x36, 0xa1,
+	0x50, 0xac, 0x44, 0x56, 0xf5, 0x38, 0xf1, 0x95, 0xef, 0x84, 0x52, 0xae, 0x13, 0x1e, 0x97, 0x2a,
+	0x85, 0x5a, 0xd1, 0xfc, 0xa0, 0x80, 0x71, 0xa0, 0xd4, 0x3d, 0xf2, 0x2c, 0xde, 0xbd, 0x0c, 0x4f,
+	0xac, 0x01, 0x04, 0xde, 0x58, 0xb4, 0xb9, 0x1d, 0xf4, 0x1d, 0x72, 0xc5, 0x3c, 0x52, 0x0e, 0xfb,
+	0xce, 0x54, 0x5f, 0xac, 0x01, 0xc4, 0x61, 0xdf, 0x25, 0x77, 0xcc, 0x47, 0x11, 0xdf, 0x4d, 0xba,
+	0xaa, 0xac, 0xbb, 0x6a, 0x13, 0x6a, 0x5d, 0x57, 0x04, 0xa1, 0xed, 0x3b, 0x82, 0x8f, 0xf0, 0xe7,
+	0x73, 0x98, 0x30, 0x8a, 0x7e, 0xa0, 0xc8, 0x16, 0xef, 0x9a, 0x4e, 0x22, 0x32, 0x09, 0x8e, 0xf3,
+	0x38, 0xef, 0x79, 0xce, 0xc4, 0x1f, 0xc2, 0xd5, 0x5c, 0x5f, 0x9e, 0xbd, 0xc3, 0xeb, 0x50, 0x95,
+	0x10, 0xdb, 0x6d, 0x95, 0xb0, 0x1d, 0xca, 0xbe, 0x05, 0x49, 0xc3, 0x1c, 0xee, 0xb0, 0xdb, 0xb0,
+	0x44, 0x11, 0x14, 0x31, 0x15, 0x15, 0x13, 0xc5, 0x15, 0xb1, 0x99, 0xbf, 0x34, 0xe0, 0x8a, 0xb4,
+	0x71, 0x67, 0xe7, 0xe5, 0x4e, 0x3d, 0xf3, 0x47, 0x54, 0x75, 0x27, 0x8a, 0x92, 0x2b, 0x32, 0xa9,
+	0x62, 0x5c, 0x50, 0xaa, 0x4c, 0xf1, 0xd8, 0x1f, 0x28, 0x49, 0x9a, 0x7d, 0x2e, 0xc4, 0xe9, 0x81,
+	0xdb, 0xfe, 0xde, 0x65, 0x60, 0x76, 0x17, 0xca, 0x08, 0x11, 0x55, 0x82, 0x95, 0x88, 0xe7, 0x6b,
+	0x6e, 0xd8, 0x54, 0x0b, 0x16, 0x31, 0xa4, 0xcf, 0xff, 0x52, 0xe6, 0xfc, 0x9f, 0x5e, 0xc5, 0xee,
+	0xc1, 0x0a, 0xb6, 0x8c, 0x49, 0x01, 0x98, 0x3e, 0xcb, 0x6a, 0x61, 0x6b, 0x22, 0xe5, 0x6d, 0xa8,
+	0x21, 0x6f, 0xc2, 0xe6, 0xb9, 0x69, 0x36, 0xd3, 0xcf, 0x27, 0x04, 0xf3, 0x1f, 0x05, 0x4c, 0xae,
+	0x24, 0x8c, 0x17, 0xeb, 0x51, 0x8c, 0x7b, 0x3b, 0x14, 0x3c, 0xe5, 0x51, 0x5c, 0x38, 0x12, 0x1c,
+	0x3d, 0x2a, 0xb3, 0x89, 0xe2, 0x31, 0x79, 0x50, 0x2d, 0x20, 0x0d, 0x59, 0x9e, 0xa3, 0x96, 0xb2,
+	0x36, 0x5c, 0xcb, 0x6c, 0x6d, 0xb7, 0xbd, 0x0e, 0xa2, 0xbd, 0xf4, 0xa0, 0x91, 0x74, 0x6f, 0xd6,
+	0xfc, 0x46, 0x53, 0x57, 0xcf, 0xba, 0x92, 0xd2, 0xb7, 0xe9, 0x75, 0xb8, 0xf9, 0x16, 0x2c, 0xa7,
+	0xf8, 0x58, 0x05, 0x4a, 0x4f, 0xf6, 0x9f, 0xb4, 0x6a, 0x33, 0x6c, 0x1e, 0x66, 0x5b, 0x7b, 0x07,
+	0x47, 0xef, 0xd6, 0x0c, 0x56, 0x85, 0x4a, 0x73, 0xff, 0xc9, 0xce, 0x3b, 0x8f, 0x9a, 0x47, 0xb5,
+	0x82, 0xf9, 0xfb, 0x02, 0xac, 0xa8, 0xa0, 0xe2, 0x27, 0x5c, 0x7a, 0xe3, 0xd3, 0xb8, 0x7d, 0xee,
+	0xb8, 0xfd, 0x5b, 0x01, 0x58, 0x12, 0xc2, 0xff, 0x8f, 0x98, 0xb5, 0x3f, 0x22, 0x66, 0xef, 0x69,
+	0xae, 0xd5, 0x4c, 0x7f, 0x91, 0xf1, 0xfa, 0xef, 0x02, 0x5c, 0x57, 0x59, 0xa2, 0xcc, 0xda, 0x71,
+	0x07, 0x3c, 0x78, 0xd8, 0x96, 0x28, 0xee, 0x72, 0xa7, 0xc3, 0x05, 0xdb, 0x81, 0xb2, 0xa3, 0xbe,
+	0x15, 0xdc, 0xe9, 0xd4, 0xca, 0xff, 0x51, 0x03, 0x3f, 0x8e, 0x4e, 0x7d, 0x6e, 0xd1, 0xaf, 0xe5,
+	0x89, 0xd4, 0x75, 0x07, 0xdc, 0xf6, 0x9d, 0xb0, 0x4f, 0x0d, 0x78, 0x45, 0x12, 0x0e, 0x9c, 0xb0,
+	0xcf, 0x36, 0x60, 0xd1, 0x97, 0x9d, 0xb5, 0x37, 0x0e, 0x90, 0xa1, 0xa8, 0x18, 0xaa, 0x11, 0x51,
+	0x31, 0xc9, 0xe3, 0xd6, 0x09, 0xf8, 0x17, 0xdf, 0xb2, 0xdb, 0xde, 0x28, 0xe4, 0x34, 0x6f, 0xcb,
+	0xe3, 0x56, 0x51, 0x9b, 0x48, 0x64, 0x77, 0xa1, 0xc6, 0x9f, 0xf1, 0xf6, 0x38, 0xe4, 0xb6, 0x94,
+	0x3f, 0x8c, 0x10, 0xae, 0x58, 0xcb, 0x44, 0xdf, 0x21, 0xb2, 0xdc, 0xd6, 0x1d, 0x75, 0xb9, 0x88,
+	0x05, 0x62, 0x67, 0x59, 0x55, 0x44, 0x92, 0x67, 0x3e, 0x05, 0x98, 0x98, 0xc3, 0x00, 0xca, 0x4d,
+	0xab, 0xf5, 0xf0, 0x48, 0x62, 0xba, 0x04, 0x80, 0x7f, 0xdb, 0xdb, 0x8f, 0xac, 0x9a, 0x21, 0xd7,
+	0x9e, 0x1e, 0x6c, 0xcb, 0xb5, 0x82, 0x44, 0x7e, 0x6f, 0xff, 0x9b, 0xad, 0x5a, 0x51, 0x52, 0xb7,
+	0x5b, 0xef, 0xb4, 0x8e, 0x5a, 0xb5, 0x92, 0xf4, 0x42, 0x73, 0x77, 0x6f, 0x7f, 0xbb, 0x36, 0x2b,
+	0x07, 0xd3, 0xab, 0xb9, 0x10, 0xb2, 0xb7, 0xa1, 0xdc, 0x57, 0x30, 0x52, 0x80, 0x6f, 0x9c, 0x03,
+	0xf1, 0xdd, 0x19, 0x8b, 0x7e, 0xc4, 0xea, 0x30, 0x17, 0x99, 0xa3, 0x60, 0xde, 0x9d, 0xb1, 0x22,
+	0xc2, 0x96, 0x09, 0xeb, 0xb2, 0x64, 0xd8, 0x14, 0xd7, 0x12, 0x9f, 0xc0, 0x46, 0x07, 0xd9, 0xbe,
+	0x73, 0x3a, 0xf0, 0x9c, 0x8e, 0xf9, 0xbb, 0x22, 0xdc, 0x48, 0xed, 0x44, 0x55, 0x8c, 0x22, 0xe2,
+	0x45, 0xd6, 0xb2, 0x54, 0x81, 0x2a, 0x66, 0x0a, 0xd4, 0x6d, 0x58, 0x22, 0xe5, 0xa3, 0x3a, 0x85,
+	0x45, 0x6c, 0x11, 0xa9, 0x7b, 0x54, 0xad, 0xde, 0x00, 0x46, 0x6c, 0xce, 0x38, 0xec, 0x7b, 0x02,
+	0xc5, 0x61, 0x49, 0xab, 0xe1, 0xca, 0x43, 0xb5, 0xa0, 0x84, 0x36, 0xe0, 0x8a, 0xce, 0xcd, 0x87,
+	0x8e, 0x3b, 0xa0, 0xea, 0xb6, 0x92, 0x64, 0x6f, 0xc9, 0x85, 0xfc, 0x5a, 0x38, 0x77, 0xfe, 0x5a,
+	0x58, 0x39, 0x77, 0x2d, 0x94, 0x43, 0x4f, 0xd7, 0x13, 0x6d, 0xbe, 0x3a, 0x8f, 0x43, 0x8f, 0xfa,
+	0x90, 0xc9, 0x84, 0x42, 0x65, 0x3b, 0x0f, 0xd8, 0xde, 0x29, 0xc2, 0x61, 0xdf, 0x31, 0x7f, 0x43,
+	0xd3, 0x5e, 0xd6, 0x81, 0xec, 0x2b, 0xa9, 0xd0, 0xba, 0x35, 0x25, 0xb4, 0x34, 0x87, 0x27, 0x62,
+	0xeb, 0x4b, 0x71, 0x31, 0x28, 0xe8, 0xb5, 0x37, 0x3f, 0x34, 0x67, 0xa2, 0xec, 0xdf, 0xda, 0x80,
+	0xd7, 0xb3, 0x81, 0x27, 0x70, 0x97, 0x38, 0xf2, 0x7e, 0x15, 0x5d, 0xf3, 0x25, 0x15, 0xb9, 0xc0,
+	0xe2, 0x7f, 0x13, 0x16, 0xdc, 0x51, 0x87, 0x3f, 0xd3, 0xca, 0x3e, 0x28, 0xd2, 0x19, 0xe5, 0x7c,
+	0xca, 0x4c, 0xfd, 0x4f, 0x4a, 0x13, 0x8b, 0xcb, 0xf2, 0xd3, 0xf4, 0x46, 0x5d, 0x57, 0x0c, 0x9d,
+	0xe3, 0x01, 0x8f, 0xb0, 0x6e, 0xa5, 0xb0, 0xfe, 0x9c, 0x5e, 0xdf, 0xf3, 0x7f, 0xd5, 0xc8, 0x40,
+	0x7e, 0x2d, 0x9a, 0x7a, 0xd5, 0x00, 0xb2, 0x3b, 0x43, 0x73, 0x6f, 0xfd, 0x8f, 0x05, 0x28, 0x5f,
+	0x42, 0x42, 0x5e, 0x87, 0x79, 0xa1, 0x74, 0x4d, 0x0c, 0x12, 0x48, 0x38, 0x63, 0x86, 0x5f, 0x03,
+	0x4a, 0x59, 0x15, 0x9f, 0xb3, 0x38, 0x6e, 0x22, 0x45, 0x8e, 0x9b, 0x5f, 0x85, 0x15, 0xc1, 0x87,
+	0x5e, 0xc8, 0x93, 0x39, 0x51, 0x9e, 0x9a, 0x13, 0x35, 0x64, 0x4e, 0x24, 0xc5, 0x06, 0x2c, 0x92,
+	0x00, 0xda, 0x1e, 0x73, 0xaf, 0x8a, 0x44, 0x8c, 0x00, 0x39, 0x83, 0xf6, 0xdc, 0xd0, 0xf6, 0xc7,
+	0x41, 0xdf, 0xf6, 0x7c, 0x75, 0xc9, 0xbc, 0x5a, 0x59, 0x2f, 0x6e, 0xce, 0x5b, 0x4b, 0x3d, 0x37,
+	0x3c, 0x18, 0x07, 0xfd, 0x7d, 0xa4, 0x6e, 0xdd, 0x85, 0x3b, 0x2a, 0x38, 0xc9, 0xd0, 0xf6, 0xc4,
+	0x2b, 0x99, 0x10, 0xfd, 0xab, 0x01, 0x6b, 0x53, 0xfc, 0x47, 0x81, 0x7a, 0x53, 0x3a, 0x43, 0xc9,
+	0x91, 0xb6, 0xab, 0xa9, 0x72, 0x77, 0xc6, 0x22, 0x10, 0xa5, 0xf5, 0x77, 0x60, 0x89, 0x18, 0xa4,
+	0x23, 0xdd, 0x68, 0xb4, 0xdc, 0x9d, 0xb1, 0x16, 0x91, 0xfe, 0x10, 0xc9, 0xcf, 0x13, 0x8d, 0xd2,
+	0x4d, 0xbd, 0xb8, 0x51, 0xc1, 0x06, 0xa4, 0xd2, 0xa3, 0x2e, 0x65, 0xeb, 0x1e, 0x6c, 0x4e, 0xb7,
+	0x0f, 0xd5, 0x8e, 0x0d, 0xfc, 0x09, 0xb5, 0xaf, 0x87, 0xef, 0x8f, 0x9d, 0xe0, 0xb2, 0x46, 0xd5,
+	0x40, 0x6d, 0x96, 0x88, 0x30, 0x24, 0x3c, 0xea, 0xe8, 0x85, 0x6e, 0x56, 0x2f, 0x74, 0xec, 0x55,
+	0x98, 0xe3, 0xa3, 0x8e, 0x5a, 0x2a, 0xab, 0xa5, 0x32, 0x1f, 0x75, 0xe4, 0xc2, 0x2d, 0x28, 0x63,
+	0x21, 0xa7, 0xae, 0x53, 0xdf, 0x96, 0xd6, 0x72, 0x8e, 0x92, 0x4a, 0xce, 0x51, 0xf2, 0xb8, 0x54,
+	0x29, 0xd5, 0x66, 0x4d, 0x17, 0x5b, 0xd2, 0x08, 0x96, 0xf8, 0xee, 0x0e, 0x48, 0xf7, 0xd8, 0xd9,
+	0x16, 0x59, 0x23, 0xf5, 0xd0, 0xbc, 0x52, 0xd4, 0xbd, 0x82, 0xf7, 0x41, 0x56, 0xd6, 0xc5, 0xe6,
+	0x2f, 0x68, 0xfa, 0x95, 0x71, 0x70, 0x7a, 0xe0, 0x84, 0x93, 0x1b, 0x83, 0x33, 0xcb, 0x77, 0x86,
+	0xbd, 0x91, 0xd7, 0x1a, 0xf8, 0x92, 0x81, 0x07, 0x93, 0xd6, 0x80, 0x08, 0xf5, 0x1f, 0x1b, 0x97,
+	0x52, 0x4f, 0x36, 0x60, 0x91, 0xae, 0x94, 0x28, 0x75, 0xa9, 0xd3, 0x43, 0x22, 0xa6, 0x6e, 0xdc,
+	0xa6, 0xa8, 0x4a, 0x67, 0x2b, 0x0d, 0x33, 0x99, 0xf8, 0x1e, 0x1e, 0x72, 0x49, 0xab, 0x2f, 0xee,
+	0xa8, 0x30, 0xff, 0x65, 0x40, 0x7d, 0xf2, 0xfe, 0x70, 0x38, 0x3e, 0x1e, 0x7a, 0x9d, 0xf1, 0xa4,
+	0xb6, 0xbf, 0xe0, 0xbb, 0x3a, 0x0a, 0xcb, 0xc4, 0x5d, 0x1d, 0x52, 0xce, 0xba, 0xab, 0xbb, 0x01,
+	0xf3, 0x41, 0xa4, 0x66, 0x74, 0x55, 0x17, 0x13, 0x72, 0x62, 0xbd, 0x9c, 0x13, 0xeb, 0xe6, 0x9f,
+	0x0c, 0x1c, 0x06, 0x32, 0x66, 0x7f, 0x32, 0x17, 0x41, 0x99, 0x11, 0xac, 0x94, 0x19, 0xc1, 0x1e,
+	0x97, 0x2a, 0xc5, 0x5a, 0xc9, 0xca, 0x4e, 0x75, 0x0f, 0xfe, 0x0e, 0x50, 0x8b, 0xf5, 0x39, 0xe4,
+	0xe2, 0xc4, 0x6d, 0x73, 0xf6, 0x1d, 0xa8, 0xa5, 0xdf, 0xe3, 0xd8, 0x4d, 0xad, 0x89, 0xc9, 0x3e,
+	0x31, 0xd6, 0xd7, 0xa7, 0x33, 0x20, 0x2e, 0x66, 0xf9, 0x3f, 0x3f, 0xdb, 0x2c, 0x54, 0x8c, 0x48,
+	0x7c, 0xf2, 0xd5, 0x4a, 0x17, 0x9f, 0xf3, 0x2e, 0xa7, 0x8b, 0xcf, 0x7b, 0xf0, 0x4a, 0x8b, 0x4f,
+	0xbe, 0x19, 0xe9, 0xe2, 0x73, 0x5e, 0xb9, 0x74, 0xf1, 0x79, 0xcf, 0x4d, 0xb1, 0xf8, 0x23, 0x58,
+	0xd4, 0x9e, 0x28, 0xd8, 0x8d, 0xac, 0xe1, 0x93, 0xb7, 0x98, 0xfa, 0xda, 0x94, 0xd5, 0x7c, 0xa9,
+	0xf1, 0x83, 0x90, 0x2e, 0x35, 0xfd, 0x6c, 0xa5, 0x4b, 0xcd, 0xbc, 0x22, 0xc5, 0x52, 0xbf, 0x05,
+	0x4b, 0xfa, 0xbd, 0x31, 0xd3, 0x7e, 0x98, 0xb9, 0x5e, 0xaf, 0x7f, 0x66, 0xda, 0x72, 0x4a, 0xf0,
+	0x77, 0x61, 0x39, 0xf5, 0x9c, 0xc0, 0xb2, 0x3f, 0xd5, 0x11, 0xbe, 0x39, 0x75, 0x5d, 0x97, 0xbd,
+	0x69, 0xbc, 0x69, 0xb0, 0x6f, 0x40, 0x35, 0x79, 0xc7, 0xca, 0xae, 0x27, 0x7f, 0x9c, 0xba, 0x22,
+	0xae, 0xdf, 0xc8, 0x5f, 0xcc, 0xc7, 0x62, 0x72, 0xcf, 0xa5, 0x63, 0x91, 0xb9, 0x45, 0xd5, 0xb1,
+	0xc8, 0x5e, 0x8f, 0xc5, 0x82, 0xdf, 0x43, 0x2c, 0x12, 0xfd, 0xb8, 0x8e, 0x45, 0x76, 0x62, 0xd0,
+	0xb1, 0xc8, 0x69, 0xe4, 0x27, 0x58, 0x30, 0x1f, 0x8f, 0xb9, 0x4c, 0x2b, 0xc5, 0x6e, 0x9d, 0xa7,
+	0x53, 0xae, 0xdf, 0xfe, 0x08, 0xae, 0x1c, 0xec, 0xbf, 0x0e, 0x30, 0xb9, 0x5c, 0x61, 0xaf, 0xe5,
+	0x5d, 0xb8, 0xa0, 0xec, 0xfa, 0xf4, 0xbb, 0x98, 0x18, 0x1c, 0x12, 0x86, 0x1d, 0x81, 0x2e, 0x4c,
+	0x6b, 0x9e, 0x74, 0x61, 0x7a, 0x03, 0x11, 0x0b, 0x7b, 0x17, 0x5d, 0x38, 0x39, 0xcd, 0x74, 0x17,
+	0x66, 0xce, 0x76, 0xdd, 0x85, 0xd9, 0x43, 0x30, 0x01, 0x73, 0x17, 0x5f, 0x1f, 0x52, 0x25, 0x9d,
+	0x99, 0xd9, 0xaa, 0x93, 0x3e, 0xe6, 0xea, 0x1b, 0x67, 0xf2, 0xe8, 0x3b, 0x6d, 0xbd, 0xf9, 0x6d,
+	0xc9, 0x3d, 0x70, 0x8e, 0x1b, 0x6d, 0x6f, 0x78, 0x1f, 0xff, 0xfc, 0xbc, 0x27, 0x7a, 0xf7, 0x51,
+	0xc6, 0x7d, 0xf5, 0xaf, 0x1c, 0xf7, 0x7b, 0x1e, 0x7d, 0xfb, 0xc7, 0xc7, 0x65, 0x45, 0xfa, 0xc2,
+	0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x8d, 0xc0, 0x0b, 0x97, 0x07, 0x22, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2898,7 +2744,6 @@ type OperationServiceClient interface {
 	UserFFBranch(ctx context.Context, in *UserFFBranchRequest, opts ...grpc.CallOption) (*UserFFBranchResponse, error)
 	UserCherryPick(ctx context.Context, in *UserCherryPickRequest, opts ...grpc.CallOption) (*UserCherryPickResponse, error)
 	UserCommitFiles(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserCommitFilesClient, error)
-	UserRebase(ctx context.Context, in *UserRebaseRequest, opts ...grpc.CallOption) (*UserRebaseResponse, error)
 	UserRebaseConfirmable(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserRebaseConfirmableClient, error)
 	UserRevert(ctx context.Context, in *UserRevertRequest, opts ...grpc.CallOption) (*UserRevertResponse, error)
 	UserSquash(ctx context.Context, in *UserSquashRequest, opts ...grpc.CallOption) (*UserSquashResponse, error)
@@ -3051,16 +2896,6 @@ func (x *operationServiceUserCommitFilesClient) CloseAndRecv() (*UserCommitFiles
 	return m, nil
 }
 
-// Deprecated: Do not use.
-func (c *operationServiceClient) UserRebase(ctx context.Context, in *UserRebaseRequest, opts ...grpc.CallOption) (*UserRebaseResponse, error) {
-	out := new(UserRebaseResponse)
-	err := c.cc.Invoke(ctx, "/gitaly.OperationService/UserRebase", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 func (c *operationServiceClient) UserRebaseConfirmable(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserRebaseConfirmableClient, error) {
 	stream, err := c.cc.NewStream(ctx, &_OperationService_serviceDesc.Streams[2], "/gitaly.OperationService/UserRebaseConfirmable", opts...)
 	if err != nil {
@@ -3165,7 +3000,6 @@ type OperationServiceServer interface {
 	UserFFBranch(context.Context, *UserFFBranchRequest) (*UserFFBranchResponse, error)
 	UserCherryPick(context.Context, *UserCherryPickRequest) (*UserCherryPickResponse, error)
 	UserCommitFiles(OperationService_UserCommitFilesServer) error
-	UserRebase(context.Context, *UserRebaseRequest) (*UserRebaseResponse, error)
 	UserRebaseConfirmable(OperationService_UserRebaseConfirmableServer) error
 	UserRevert(context.Context, *UserRevertRequest) (*UserRevertResponse, error)
 	UserSquash(context.Context, *UserSquashRequest) (*UserSquashResponse, error)
@@ -3207,9 +3041,6 @@ func (*UnimplementedOperationServiceServer) UserCherryPick(ctx context.Context,
 func (*UnimplementedOperationServiceServer) UserCommitFiles(srv OperationService_UserCommitFilesServer) error {
 	return status.Errorf(codes.Unimplemented, "method UserCommitFiles not implemented")
 }
-func (*UnimplementedOperationServiceServer) UserRebase(ctx context.Context, req *UserRebaseRequest) (*UserRebaseResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method UserRebase not implemented")
-}
 func (*UnimplementedOperationServiceServer) UserRebaseConfirmable(srv OperationService_UserRebaseConfirmableServer) error {
 	return status.Errorf(codes.Unimplemented, "method UserRebaseConfirmable not implemented")
 }
@@ -3426,24 +3257,6 @@ func (x *operationServiceUserCommitFilesServer) Recv() (*UserCommitFilesRequest,
 	return m, nil
 }
 
-func _OperationService_UserRebase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(UserRebaseRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(OperationServiceServer).UserRebase(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/gitaly.OperationService/UserRebase",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(OperationServiceServer).UserRebase(ctx, req.(*UserRebaseRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 func _OperationService_UserRebaseConfirmable_Handler(srv interface{}, stream grpc.ServerStream) error {
 	return srv.(OperationServiceServer).UserRebaseConfirmable(&operationServiceUserRebaseConfirmableServer{stream})
 }
@@ -3587,10 +3400,6 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 			Handler:    _OperationService_UserCherryPick_Handler,
 		},
 		{
-			MethodName: "UserRebase",
-			Handler:    _OperationService_UserRebase_Handler,
-		},
-		{
 			MethodName: "UserRevert",
 			Handler:    _OperationService_UserRevert_Handler,
 		},
diff --git a/proto/operations.proto b/proto/operations.proto
index 8c537cdb4..ce9aaef4b 100644
--- a/proto/operations.proto
+++ b/proto/operations.proto
@@ -57,12 +57,6 @@ service OperationService {
       op: MUTATOR
     };
   }
-  rpc UserRebase(UserRebaseRequest) returns (UserRebaseResponse) {
-    option deprecated = true;
-    option (op_type) = {
-      op: MUTATOR
-    };
-  }
   rpc UserRebaseConfirmable(stream UserRebaseConfirmableRequest) returns (stream UserRebaseConfirmableResponse) {
     option (op_type) = {
       op: MUTATOR
@@ -319,28 +313,6 @@ message UserCommitFilesResponse {
   string pre_receive_error = 3;
 }
 
-// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-message UserRebaseRequest {
-  option deprecated = true;
-
-  Repository repository = 1 [(target_repository)=true];
-  User user = 2;
-  string rebase_id = 3;
-  bytes branch = 4;
-  string branch_sha = 5;
-  Repository remote_repository = 6;
-  bytes remote_branch = 7;
-}
-
-// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-message UserRebaseResponse {
-  option deprecated = true;
-
-  string rebase_sha = 1;
-  string pre_receive_error = 2;
-  string git_error = 3;
-}
-
 message UserRebaseConfirmableRequest {
   message Header {
     Repository repository = 1 [(target_repository)=true];
diff --git a/ruby/lib/gitaly_server/operations_service.rb b/ruby/lib/gitaly_server/operations_service.rb
index 2d26ef15c..d4aebac0c 100644
--- a/ruby/lib/gitaly_server/operations_service.rb
+++ b/ruby/lib/gitaly_server/operations_service.rb
@@ -241,26 +241,6 @@ module GitalyServer
       end
     end
 
-    # DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
-    def user_rebase(request, call)
-      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-      user = Gitlab::Git::User.from_gitaly(request.user)
-      remote_repository = Gitlab::Git::GitalyRemoteRepository.new(request.remote_repository, call)
-      rebase_sha = repo.rebase(user, request.rebase_id,
-                               branch: request.branch,
-                               branch_sha: request.branch_sha,
-                               remote_repository: remote_repository,
-                               remote_branch: request.remote_branch)
-
-      Gitaly::UserRebaseResponse.new(rebase_sha: rebase_sha)
-    rescue Gitlab::Git::PreReceiveError => e
-      Gitaly::UserRebaseResponse.new(pre_receive_error: set_utf8!(e.message))
-    rescue Gitlab::Git::Repository::GitError => e
-      Gitaly::UserRebaseResponse.new(git_error: set_utf8!(e.message))
-    rescue Gitlab::Git::CommitError => e
-      raise GRPC::FailedPrecondition.new(e.message)
-    end
-
     def user_commit_files(call)
       actions = []
       request_enum = call.each_remote_read
diff --git a/ruby/proto/gitaly/operations_pb.rb b/ruby/proto/gitaly/operations_pb.rb
index b40bbcee9..4f1fd14d6 100644
--- a/ruby/proto/gitaly/operations_pb.rb
+++ b/ruby/proto/gitaly/operations_pb.rb
@@ -181,20 +181,6 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :index_error, :string, 2
     optional :pre_receive_error, :string, 3
   end
-  add_message "gitaly.UserRebaseRequest" do
-    optional :repository, :message, 1, "gitaly.Repository"
-    optional :user, :message, 2, "gitaly.User"
-    optional :rebase_id, :string, 3
-    optional :branch, :bytes, 4
-    optional :branch_sha, :string, 5
-    optional :remote_repository, :message, 6, "gitaly.Repository"
-    optional :remote_branch, :bytes, 7
-  end
-  add_message "gitaly.UserRebaseResponse" do
-    optional :rebase_sha, :string, 1
-    optional :pre_receive_error, :string, 2
-    optional :git_error, :string, 3
-  end
   add_message "gitaly.UserRebaseConfirmableRequest" do
     oneof :user_rebase_confirmable_request_payload do
       optional :header, :message, 1, "gitaly.UserRebaseConfirmableRequest.Header"
@@ -291,8 +277,6 @@ module Gitaly
   UserCommitFilesRequestHeader = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.UserCommitFilesRequestHeader").msgclass
   UserCommitFilesRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.UserCommitFilesRequest").msgclass
   UserCommitFilesResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.UserCommitFilesResponse").msgclass
-  UserRebaseRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.UserRebaseRequest").msgclass
-  UserRebaseResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.UserRebaseResponse").msgclass
   UserRebaseConfirmableRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.UserRebaseConfirmableRequest").msgclass
   UserRebaseConfirmableRequest::Header = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.UserRebaseConfirmableRequest.Header").msgclass
   UserRebaseConfirmableResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.UserRebaseConfirmableResponse").msgclass
diff --git a/ruby/proto/gitaly/operations_services_pb.rb b/ruby/proto/gitaly/operations_services_pb.rb
index 57a586b1f..27901ebc9 100644
--- a/ruby/proto/gitaly/operations_services_pb.rb
+++ b/ruby/proto/gitaly/operations_services_pb.rb
@@ -24,7 +24,6 @@ module Gitaly
       rpc :UserFFBranch, UserFFBranchRequest, UserFFBranchResponse
       rpc :UserCherryPick, UserCherryPickRequest, UserCherryPickResponse
       rpc :UserCommitFiles, stream(UserCommitFilesRequest), UserCommitFilesResponse
-      rpc :UserRebase, UserRebaseRequest, UserRebaseResponse
       rpc :UserRebaseConfirmable, stream(UserRebaseConfirmableRequest), stream(UserRebaseConfirmableResponse)
       rpc :UserRevert, UserRevertRequest, UserRevertResponse
       rpc :UserSquash, UserSquashRequest, UserSquashResponse