diff --git a/changelogs/unreleased/jc-geo-fetch.yml b/changelogs/unreleased/jc-geo-fetch.yml
new file mode 100644
index 0000000000000000000000000000000000000000..7be10ea47cb11f5c900c9b3931008a1448c7cf46
--- /dev/null
+++ b/changelogs/unreleased/jc-geo-fetch.yml
@@ -0,0 +1,5 @@
+---
+title: Adding GeoFetch RPC
+merge_request: 1126
+author:
+type: other
diff --git a/internal/git/objectpool/link.go b/internal/git/objectpool/link.go
index 1b5614c1bc30c7b2134ea84d7c065c6003ae21bd..2750d6f9a4662ccee2b824200a67fa93bdcfac8e 100644
--- a/internal/git/objectpool/link.go
+++ b/internal/git/objectpool/link.go
@@ -20,6 +20,7 @@ import (
 // Link will write the relative path to the object pool from the repository that
 // is to join the pool. This does not trigger deduplication, which is the
 // responsibility of the caller.
+// Link will not overwrite an existing alternates file if one already exists
 func (o *ObjectPool) Link(ctx context.Context, repo *gitalypb.Repository) error {
 	altPath, err := git.AlternatesPath(repo)
 	if err != nil {
diff --git a/internal/service/repository/fetch_http_remote.go b/internal/service/repository/fetch_http_remote.go
new file mode 100644
index 0000000000000000000000000000000000000000..a2c3bf0097b03145003b9e1ae709f7a9e2fd9184
--- /dev/null
+++ b/internal/service/repository/fetch_http_remote.go
@@ -0,0 +1,129 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+
+	grpc_logrus "github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus"
+	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
+	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
+)
+
+func (s *server) FetchHTTPRemote(ctx context.Context, req *gitalypb.FetchHTTPRemoteRequest) (*gitalypb.FetchHTTPRemoteResponse, error) {
+	if err := validateFetchHTTPRemoteRequest(req); err != nil {
+		return nil, helper.ErrInvalidArgument(err)
+	}
+
+	authorizationKey := fmt.Sprintf("http.%s.extraHeader", req.GetRemote().GetUrl())
+	authorizationValue := fmt.Sprintf("Authorization: %s", req.GetRemote().GetHttpAuthorizationHeader())
+
+	if err := s.setAuthorization(ctx, req.GetRepository(), authorizationKey, authorizationValue); err != nil {
+		return nil, helper.ErrInternal(err)
+	}
+
+	defer func() {
+		if err := s.removeAuthorization(ctx, req.GetRepository(), authorizationKey); err != nil {
+			grpc_logrus.Extract(ctx).WithError(err).Error("error removing authorization config")
+		}
+	}()
+
+	repository := req.GetRepository()
+	remoteName := req.GetRemote().GetName()
+	remoteURL := req.GetRemote().GetUrl()
+
+	if err := s.addRemote(ctx, repository, remoteName, remoteURL); err != nil {
+		return nil, helper.ErrInternal(err)
+	}
+
+	if err := s.fetchRemote(ctx, repository, remoteName, req.GetTimeout()); err != nil {
+		return nil, helper.ErrInternal(err)
+	}
+
+	return &gitalypb.FetchHTTPRemoteResponse{}, nil
+}
+
+func validateFetchHTTPRemoteRequest(req *gitalypb.FetchHTTPRemoteRequest) error {
+	if req.GetRepository() == nil {
+		return errors.New("repository is empty")
+	}
+
+	if req.GetRemote().GetUrl() == "" {
+		return errors.New("missing remote url")
+	}
+
+	u, err := url.ParseRequestURI(req.GetRemote().GetUrl())
+	if err != nil {
+		return errors.New("invalid remote url")
+	}
+
+	if u.Scheme != "http" && u.Scheme != "https" {
+		return errors.New("invalid remote url")
+	}
+
+	if req.GetRemote().GetName() == "" {
+		return errors.New("missing remote name")
+	}
+
+	return nil
+}
+
+func (s *server) addRemote(ctx context.Context, repository *gitalypb.Repository, name, url string) error {
+	client, err := s.RemoteServiceClient(ctx)
+	if err != nil {
+		return err
+	}
+
+	clientCtx, err := rubyserver.SetHeaders(ctx, repository)
+	if err != nil {
+		return err
+	}
+
+	if _, err = client.AddRemote(clientCtx, &gitalypb.AddRemoteRequest{
+		Repository:    repository,
+		Name:          name,
+		Url:           url,
+		MirrorRefmaps: []string{"all_refs"},
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *server) fetchRemote(ctx context.Context, repository *gitalypb.Repository, remoteName string, timeout int32) error {
+	fetchRemoteRequest := &gitalypb.FetchRemoteRequest{
+		Repository: repository,
+		Remote:     remoteName,
+		Force:      false,
+		Timeout:    timeout,
+	}
+
+	_, err := s.FetchRemote(ctx, fetchRemoteRequest)
+	return err
+}
+
+func (s *server) setAuthorization(ctx context.Context, repository *gitalypb.Repository, key, value string) error {
+	_, err := s.SetConfig(ctx, &gitalypb.SetConfigRequest{
+		Repository: repository,
+		Entries: []*gitalypb.SetConfigRequest_Entry{
+			&gitalypb.SetConfigRequest_Entry{
+				Key: key,
+				Value: &gitalypb.SetConfigRequest_Entry_ValueStr{
+					ValueStr: value,
+				},
+			},
+		},
+	})
+	return err
+}
+
+func (s *server) removeAuthorization(ctx context.Context, repository *gitalypb.Repository, key string) error {
+	_, err := s.DeleteConfig(ctx, &gitalypb.DeleteConfigRequest{
+		Repository: repository,
+		Keys:       []string{key},
+	})
+	return err
+}
diff --git a/internal/service/repository/fetch_http_remote_test.go b/internal/service/repository/fetch_http_remote_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ee1e4099e5e020f6b2e3706c2424acd05f3e39cc
--- /dev/null
+++ b/internal/service/repository/fetch_http_remote_test.go
@@ -0,0 +1,162 @@
+package repository
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"google.golang.org/grpc/codes"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
+	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
+)
+
+const (
+	httpToken = "ABCefg0999182"
+)
+
+func remoteHTTPServer(t *testing.T, repoName, httpToken string) (*httptest.Server, string) {
+	s := httptest.NewServer(
+		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.String() == fmt.Sprintf("/%s.git/info/refs?service=git-upload-pack", repoName) {
+				if r.Header.Get("Authorization") != httpToken {
+					w.WriteHeader(http.StatusUnauthorized)
+					return
+				}
+				w.Header().Set("Content-Type", "application/x-git-upload-pack-advertisement")
+				w.WriteHeader(http.StatusOK)
+
+				b, err := ioutil.ReadFile("testdata/advertise.txt")
+				require.NoError(t, err)
+				w.Write(b)
+			} else {
+				w.WriteHeader(http.StatusNotFound)
+			}
+		}),
+	)
+
+	return s, fmt.Sprintf("%s/%s.git", s.URL, repoName)
+}
+
+func TestFetchHTTPRemoteOverHTTP(t *testing.T) {
+	server, serverSocketPath := runRepoServer(t)
+	defer server.Stop()
+
+	client, conn := newRepositoryClient(t, serverSocketPath)
+	defer conn.Close()
+
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	forkedRepo, forkedRepoPath, forkedRepoCleanup := testhelper.NewTestRepo(t)
+	defer forkedRepoCleanup()
+
+	repoName := "my-repo"
+
+	_, remoteURL := remoteHTTPServer(t, repoName, httpToken)
+
+	req := &gitalypb.FetchHTTPRemoteRequest{
+		Repository: forkedRepo,
+		Remote: &gitalypb.Remote{
+			Url:                     remoteURL,
+			Name:                    "geo",
+			HttpAuthorizationHeader: httpToken,
+		},
+		Timeout: 1000,
+	}
+
+	refs := getRefnames(t, forkedRepoPath)
+	require.True(t, len(refs) > 1)
+
+	_, err := client.FetchHTTPRemote(ctx, req)
+	require.NoError(t, err)
+
+	refs = getRefnames(t, forkedRepoPath)
+	require.Len(t, refs, 1)
+	assert.Equal(t, "master", refs[0])
+}
+
+func getRefnames(t *testing.T, repoPath string) []string {
+	result := testhelper.MustRunCommand(t, nil, "git", "-C", repoPath, "for-each-ref", "--format", "%(refname:lstrip=2)")
+	return strings.Split(string(bytes.TrimRight(result, "\n")), "\n")
+}
+
+func TestFetchHTTPRemoteValidationError(t *testing.T) {
+	server, serverSocketPath := runRepoServer(t)
+	defer server.Stop()
+
+	client, conn := newRepositoryClient(t, serverSocketPath)
+	defer conn.Close()
+
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	forkedRepo, _, forkRepoCleanup := getForkDestination(t)
+	defer forkRepoCleanup()
+
+	testCases := []struct {
+		description string
+		request     gitalypb.FetchHTTPRemoteRequest
+	}{
+		{
+			description: "missing repository",
+			request: gitalypb.FetchHTTPRemoteRequest{
+				Repository: nil,
+				Remote:     &gitalypb.Remote{},
+			},
+		},
+		{
+			description: "missing remote url",
+			request: gitalypb.FetchHTTPRemoteRequest{
+				Repository: forkedRepo,
+				Remote: &gitalypb.Remote{
+					Name: "geo",
+					Url:  "",
+				},
+			},
+		},
+		{
+			description: "missing remote name",
+			request: gitalypb.FetchHTTPRemoteRequest{
+				Repository: forkedRepo,
+				Remote: &gitalypb.Remote{
+					Name: "",
+					Url:  "https://www.gitlab.com",
+				},
+			},
+		},
+		{
+			description: "bad remote url",
+			request: gitalypb.FetchHTTPRemoteRequest{
+				Repository: forkedRepo,
+				Remote: &gitalypb.Remote{
+					Name: "geo",
+					Url:  "not a real url",
+				},
+			},
+		},
+		{
+			description: "a valid file url",
+			request: gitalypb.FetchHTTPRemoteRequest{
+				Repository: forkedRepo,
+				Remote: &gitalypb.Remote{
+					Name: "geo",
+					Url:  "file://some/path",
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.description, func(t *testing.T) {
+			_, err := client.FetchHTTPRemote(ctx, &tc.request)
+			testhelper.RequireGrpcError(t, err, codes.InvalidArgument)
+		})
+	}
+}
diff --git a/internal/service/repository/geo_fast_initial_fetch.go b/internal/service/repository/geo_fast_initial_fetch.go
new file mode 100644
index 0000000000000000000000000000000000000000..ec48df3faae0129f959356e7c76f931248cb9124
--- /dev/null
+++ b/internal/service/repository/geo_fast_initial_fetch.go
@@ -0,0 +1,166 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
+	"gitlab.com/gitlab-org/gitaly/internal/git"
+	"gitlab.com/gitlab-org/gitaly/internal/git/objectpool"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
+)
+
+func (s *server) GeoFastInitialFetch(ctx context.Context, req *gitalypb.GeoFastInitialFetchRequest) (*gitalypb.GeoFastInitialFetchResponse, error) {
+	if err := validateGeoFastInitialFetchRequest(req); err != nil {
+		return nil, helper.ErrInvalidArgument(err)
+	}
+
+	if err := validateGeoFastInitialFetchPrecondition(req); err != nil {
+		return nil, helper.ErrPreconditionFailed(err)
+	}
+
+	tmpRepo, err := preFetch(ctx, req)
+	if err != nil {
+		return nil, helper.ErrInternal(err)
+	}
+
+	if _, err := s.FetchHTTPRemote(ctx, &gitalypb.FetchHTTPRemoteRequest{
+		Repository: tmpRepo,
+		Remote:     req.GetRemote(),
+		Timeout:    req.GetTimeout(),
+	}); err != nil {
+		return nil, helper.ErrInternal(err)
+	}
+
+	tmpRepoDir, err := helper.GetPath(tmpRepo)
+	if err != nil {
+		return nil, helper.ErrInternal(err)
+	}
+	defer os.RemoveAll(tmpRepoDir)
+
+	// rename
+	repositoryFullPath, err := helper.GetPath(req.GetRepository())
+	if err != nil {
+		return nil, helper.ErrInternal(err)
+	}
+
+	if err := os.Rename(tmpRepoDir, repositoryFullPath); err != nil {
+		return nil, helper.ErrInternal(err)
+	}
+
+	return &gitalypb.GeoFastInitialFetchResponse{}, nil
+}
+
+func validateGeoFastInitialFetchRequest(req *gitalypb.GeoFastInitialFetchRequest) error {
+	if req.GetRepository() == nil {
+		return errors.New("repository is empty")
+	}
+
+	if req.GetObjectPool() == nil {
+		return errors.New("object pool is empty")
+	}
+
+	return nil
+}
+
+func validateGeoFastInitialFetchPrecondition(req *gitalypb.GeoFastInitialFetchRequest) error {
+	repositoryFullPath, err := helper.GetPath(req.GetRepository())
+	if err != nil {
+		return fmt.Errorf("getting target repository path: %v", err)
+	}
+
+	if _, err := os.Stat(repositoryFullPath); !os.IsNotExist(err) {
+		return errors.New("target reopsitory already exists")
+	}
+
+	poolRepo := req.GetObjectPool().GetRepository()
+	objectPool, err := objectpool.NewObjectPool(poolRepo.GetStorageName(), poolRepo.GetRelativePath())
+	if err != nil {
+		return fmt.Errorf("getting object pool from repository: %v", err)
+	}
+
+	if !objectPool.Exists() {
+		return errors.New("object pool does not exist")
+	}
+
+	if !objectPool.IsValid() {
+		return errors.New("object pool is not valid")
+	}
+
+	return nil
+}
+
+func preFetch(ctx context.Context, req *gitalypb.GeoFastInitialFetchRequest) (*gitalypb.Repository, error) {
+	repository := req.GetRepository()
+
+	repositoryPath, err := helper.GetPath(repository)
+	if err != nil {
+		return nil, fmt.Errorf("getting repository path: %v", err)
+	}
+
+	objectPoolPath, err := helper.GetPath(req.GetObjectPool().GetRepository())
+	if err != nil {
+		return nil, fmt.Errorf("getting object pool path: %v", err)
+	}
+
+	dir := filepath.Dir(repositoryPath)
+	if _, err = os.Stat(dir); os.IsNotExist(err) {
+		if err = os.MkdirAll(dir, 0770); err != nil {
+			return nil, err
+		}
+	}
+
+	tmpRepoDir, err := ioutil.TempDir(dir, "repo")
+	if err != nil {
+		return nil, fmt.Errorf("creating temp directory for repo: %v", err)
+	}
+
+	storagePath, err := helper.GetStorageByName(repository.GetStorageName())
+	if err != nil {
+		return nil, fmt.Errorf("getting storage path for target repo: %v", err)
+	}
+
+	relativePath, err := filepath.Rel(storagePath, tmpRepoDir)
+	if err != nil {
+		return nil, fmt.Errorf("getting relative path for temp repo: %v", err)
+	}
+
+	tmpRepo := &gitalypb.Repository{
+		RelativePath: relativePath,
+		StorageName:  repository.GetStorageName(),
+	}
+
+	args := []string{
+		"clone",
+		"--bare",
+		"--shared",
+		"--",
+		objectPoolPath,
+		tmpRepoDir,
+	}
+
+	cmd, err := git.BareCommand(ctx, nil, nil, nil, nil, args...)
+	if err != nil {
+		return nil, fmt.Errorf("clone command: %v", err)
+	}
+
+	if err := cmd.Wait(); err != nil {
+		return nil, fmt.Errorf("clone command: %v", err)
+	}
+
+	poolRepo := req.GetObjectPool().GetRepository()
+	objectPool, err := objectpool.NewObjectPool(poolRepo.GetStorageName(), poolRepo.GetRelativePath())
+	if err != nil {
+		return nil, fmt.Errorf("getting object pool from repository: %v", err)
+	}
+
+	if err := objectPool.Link(ctx, tmpRepo); err != nil {
+		return nil, fmt.Errorf("linking object pool to temp repo: %v", err)
+	}
+
+	return tmpRepo, nil
+}
diff --git a/internal/service/repository/pre_fetch_test.go b/internal/service/repository/geo_fast_initial_fetch_test.go
similarity index 71%
rename from internal/service/repository/pre_fetch_test.go
rename to internal/service/repository/geo_fast_initial_fetch_test.go
index d461b7b2aedc04434088fe255fd3a03121509a15..3744167a93cd1b8e7a63173c882549feb84f036c 100644
--- a/internal/service/repository/pre_fetch_test.go
+++ b/internal/service/repository/geo_fast_initial_fetch_test.go
@@ -42,9 +42,7 @@ func getGitObjectDirSize(t *testing.T, repoPath string) int64 {
 	return blocks
 }
 
-func TestPreFetch(t *testing.T) {
-	t.Skip("PreFetch is unsafe https://gitlab.com/gitlab-org/gitaly/issues/1552")
-
+func TestGeoFastInitialFetch(t *testing.T) {
 	server, serverSocketPath := runRepoServer(t)
 	defer server.Stop()
 
@@ -54,29 +52,37 @@ func TestPreFetch(t *testing.T) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	testRepo, testRepoPath, cleanupFn := testhelper.NewTestRepo(t)
+	_, remoteRepoPath, cleanupRemoteRepo := testhelper.NewTestRepo(t)
+	defer cleanupRemoteRepo()
+
+	// add a branch
+	branch := "my-cool-branch"
+	testhelper.MustRunCommand(t, nil, "git", "-C", remoteRepoPath, "update-ref", "refs/heads/"+branch, "master")
+
+	testRepo, _, cleanupFn := testhelper.NewTestRepo(t)
 	defer cleanupFn()
 
 	pool, poolRepo := objectpool.NewTestObjectPool(t)
 	defer pool.Remove(ctx)
 
 	require.NoError(t, pool.Create(ctx, testRepo))
-	require.NoError(t, pool.Link(ctx, testRepo))
-
-	testhelper.MustRunCommand(t, nil, "git", "-C", testRepoPath, "gc")
 
 	forkedRepo, forkRepoPath, forkRepoCleanup := getForkDestination(t)
 	defer forkRepoCleanup()
 
-	req := &gitalypb.PreFetchRequest{
-		TargetRepository: forkedRepo,
-		SourceRepository: testRepo,
+	req := &gitalypb.GeoFastInitialFetchRequest{
+		Repository: forkedRepo,
 		ObjectPool: &gitalypb.ObjectPool{
 			Repository: poolRepo,
 		},
+		Remote: &gitalypb.Remote{
+			Url:                     remoteRepoPath,
+			Name:                    "geo",
+			HttpAuthorizationHeader: "token",
+		},
 	}
 
-	_, err := client.PreFetch(ctx, req)
+	_, err := client.GeoFastInitialFetch(ctx, req)
 	require.NoError(t, err)
 
 	assert.True(t, getGitObjectDirSize(t, forkRepoPath) < 40)
@@ -84,11 +90,10 @@ func TestPreFetch(t *testing.T) {
 	// feature is a branch known to exist in the source repository. By looking it up in the target
 	// we establish that the target has branches, even though (as we saw above) it has no objects.
 	testhelper.MustRunCommand(t, nil, "git", "-C", forkRepoPath, "show-ref", "feature")
+	testhelper.MustRunCommand(t, nil, "git", "-C", forkRepoPath, "show-ref", branch)
 }
 
-func TestPreFetchValidationError(t *testing.T) {
-	t.Skip("PreFetch is unsafe https://gitlab.com/gitlab-org/gitaly/issues/1552")
-
+func TestGeoFastInitialFetchValidationError(t *testing.T) {
 	server, serverSocketPath := runRepoServer(t)
 	defer server.Stop()
 
@@ -105,7 +110,7 @@ func TestPreFetchValidationError(t *testing.T) {
 	defer pool.Remove(ctx)
 
 	require.NoError(t, pool.Create(ctx, testRepo))
-	require.NoError(t, pool.Link(ctx, testRepo))
+	require.NoError(t, pool.Link(ctx, testRepo, false))
 
 	forkedRepo, _, forkRepoCleanup := getForkDestination(t)
 	defer forkRepoCleanup()
@@ -117,77 +122,72 @@ func TestPreFetchValidationError(t *testing.T) {
 
 	testCases := []struct {
 		description string
-		sourceRepo  *gitalypb.Repository
-		targetRepo  *gitalypb.Repository
+		repo        *gitalypb.Repository
 		objectPool  *gitalypb.Repository
+		remoteURL   string
 		code        codes.Code
 	}{
 		{
 			description: "source repository nil",
-			sourceRepo:  nil,
-			targetRepo:  forkedRepo,
+			repo:        forkedRepo,
 			objectPool:  poolRepo,
+			remoteURL:   "something",
 			code:        codes.InvalidArgument,
 		},
 		{
 			description: "target repository nil",
-			sourceRepo:  testRepo,
-			targetRepo:  nil,
+			repo:        nil,
 			objectPool:  poolRepo,
+			remoteURL:   "something",
 			code:        codes.InvalidArgument,
 		},
-		{
-			description: "source/target repository have different storage",
-			sourceRepo:  testRepo,
-			targetRepo: &gitalypb.Repository{
-				StorageName:  "specialstorage",
-				RelativePath: forkedRepo.RelativePath,
-				GlRepository: forkedRepo.GlRepository,
-			},
-			objectPool: poolRepo,
-			code:       codes.InvalidArgument,
-		},
 		{
 			description: "bad pool repository",
-			sourceRepo:  testRepo,
-			targetRepo:  forkedRepo,
+			repo:        forkedRepo,
 			objectPool:  badPool,
+			remoteURL:   "something",
 			code:        codes.FailedPrecondition,
 		},
+		{
+			description: "remote url is empty",
+			repo:        forkedRepo,
+			objectPool:  poolRepo,
+			remoteURL:   "",
+			code:        codes.InvalidArgument,
+		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.description, func(t *testing.T) {
-			_, err := client.PreFetch(ctx, &gitalypb.PreFetchRequest{
-				TargetRepository: tc.targetRepo,
-				SourceRepository: tc.sourceRepo,
+			_, err := client.GeoFastInitialFetch(ctx, &gitalypb.GeoFastInitialFetchRequest{
+				Repository: tc.repo,
 				ObjectPool: &gitalypb.ObjectPool{
 					Repository: tc.objectPool,
 				},
+				Remote: &gitalypb.Remote{
+					Name:                    "geo",
+					Url:                     tc.remoteURL,
+					HttpAuthorizationHeader: "header",
+				},
 			})
 			testhelper.RequireGrpcError(t, err, tc.code)
 		})
 	}
 }
 
-func TestPreFetchDirectoryExists(t *testing.T) {
-	t.Skip("PreFetch is unsafe https://gitlab.com/gitlab-org/gitaly/issues/1552")
-
+func TestGeoFastInitialFetchDirectoryExists(t *testing.T) {
 	server, serverSocketPath := runRepoServer(t)
 	defer server.Stop()
 
 	client, conn := newRepositoryClient(t, serverSocketPath)
 	defer conn.Close()
 
-	testRepo, _, cleanupFn := testhelper.NewTestRepo(t)
-	defer cleanupFn()
-
 	forkedRepo, _, forkRepoCleanup := testhelper.InitBareRepo(t)
 	defer forkRepoCleanup()
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	_, err := client.PreFetch(ctx, &gitalypb.PreFetchRequest{TargetRepository: forkedRepo, SourceRepository: testRepo})
+	_, err := client.GeoFastInitialFetch(ctx, &gitalypb.GeoFastInitialFetchRequest{Repository: forkedRepo, ObjectPool: &gitalypb.ObjectPool{}})
 	testhelper.RequireGrpcError(t, err, codes.FailedPrecondition)
 }
diff --git a/internal/service/repository/pre_fetch.go b/internal/service/repository/pre_fetch.go
deleted file mode 100644
index a0377f1f8629199e24e483faad1d9685bd607165..0000000000000000000000000000000000000000
--- a/internal/service/repository/pre_fetch.go
+++ /dev/null
@@ -1,155 +0,0 @@
-package repository
-
-import (
-	"context"
-
-	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
-	"gitlab.com/gitlab-org/gitaly/internal/helper"
-)
-
-// PreFetch is unsafe https://gitlab.com/gitlab-org/gitaly/issues/1552
-func (s *server) PreFetch(ctx context.Context, req *gitalypb.PreFetchRequest) (*gitalypb.PreFetchResponse, error) {
-	return nil, helper.Unimplemented
-
-	/*
-		if err := validatePreFetchRequest(req); err != nil {
-			return nil, helper.ErrInvalidArgument(err)
-		}
-
-		if err := validatePreFetchPrecondition(req); err != nil {
-			return nil, helper.ErrPreconditionFailed(err)
-		}
-
-		if err := preFetch(ctx, req); err != nil {
-			return nil, helper.ErrInternal(err)
-		}
-
-		return &gitalypb.PreFetchResponse{}, nil
-	*/
-}
-
-/*
-func validatePreFetchRequest(req *gitalypb.PreFetchRequest) error {
-	if req.GetTargetRepository() == nil {
-		return errors.New("repository is empty")
-	}
-
-	if req.GetSourceRepository() == nil {
-		return errors.New("source repository is empty")
-	}
-
-	if req.GetSourceRepository().GetStorageName() != req.GetTargetRepository().GetStorageName() {
-		return errors.New("source repository and target repository are not on the same storage")
-	}
-
-	return nil
-}
-
-func validatePreFetchPrecondition(req *gitalypb.PreFetchRequest) error {
-	targetRepositoryFullPath, err := helper.GetPath(req.GetTargetRepository())
-	if err != nil {
-		return fmt.Errorf("getting target repository path: %v", err)
-	}
-
-	if _, err := os.Stat(targetRepositoryFullPath); !os.IsNotExist(err) {
-		return errors.New("target reopsitory already exists")
-	}
-
-	objectPool, err := objectpool.FromProto(req.GetObjectPool())
-	if err != nil {
-		return fmt.Errorf("getting object pool from repository: %v", err)
-	}
-
-	if !objectPool.Exists() {
-		return errors.New("object pool does not exist")
-	}
-
-	if !objectPool.IsValid() {
-		return errors.New("object pool is not valid")
-	}
-
-	linked, err := objectPool.LinkedToRepository(req.GetSourceRepository())
-	if err != nil {
-		return fmt.Errorf("error when testing if source repository is linked to pool repository: %v", err)
-	}
-
-	if !linked {
-		return errors.New("source repository is not linked to pool repository")
-	}
-
-	return nil
-}
-
-func preFetch(ctx context.Context, req *gitalypb.PreFetchRequest) error {
-	targetRepository, sourceRepository := req.GetTargetRepository(), req.GetSourceRepository()
-
-	sourceRepositoryFullPath, err := helper.GetPath(sourceRepository)
-	if err != nil {
-		return fmt.Errorf("getting source repository path: %v", err)
-	}
-
-	targetRepositoryFullPath, err := helper.GetPath(targetRepository)
-	if err != nil {
-		return fmt.Errorf("getting target repository path: %v", err)
-	}
-
-	targetPath, err := helper.GetPath(targetRepository)
-	if err != nil {
-		return fmt.Errorf("getting target repository path: %v", err)
-	}
-
-	dir := filepath.Dir(targetPath)
-
-	tmpRepoDir, err := ioutil.TempDir(dir, "repo")
-	if err != nil {
-		return fmt.Errorf("creating temp directory for repo: %v", err)
-	}
-	defer os.RemoveAll(tmpRepoDir)
-
-	storagePath, err := helper.GetStorageByName(targetRepository.GetStorageName())
-	if err != nil {
-		return fmt.Errorf("getting storage path for target repo: %v", err)
-	}
-
-	relativePath, err := filepath.Rel(storagePath, tmpRepoDir)
-	if err != nil {
-		return fmt.Errorf("getting relative path for temp repo: %v", err)
-	}
-
-	tmpRepo := &gitalypb.Repository{
-		RelativePath: relativePath,
-		StorageName:  targetRepository.GetStorageName(),
-	}
-
-	args := []string{
-		"clone",
-		"--bare",
-		"--shared",
-		"--",
-		sourceRepositoryFullPath,
-		tmpRepoDir,
-	}
-
-	cmd, err := git.BareCommand(ctx, nil, nil, nil, nil, args...)
-	if err != nil {
-		return fmt.Errorf("clone command: %v", err)
-	}
-
-	if err := cmd.Wait(); err != nil {
-		return fmt.Errorf("clone command: %v", err)
-	}
-
-	objectPool, err := objectpool.FromProto(req.GetObjectPool())
-	if err != nil {
-		return fmt.Errorf("getting object pool: %v", err)
-	}
-
-	// As of 11.9, Link will still create remotes in the object pool. In this case the remotes will point to the tempoarary
-	// directory. This is OK because we don't plan on using these remotes, and will remove them in the future.
-	if err := objectPool.Link(ctx, tmpRepo); err != nil {
-		return fmt.Errorf("linking: %v", err)
-	}
-
-	return os.Rename(tmpRepoDir, targetRepositoryFullPath)
-}
-*/
diff --git a/internal/service/repository/testdata/advertise.txt b/internal/service/repository/testdata/advertise.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a07f3623ca80f383c32fd904dee13fde18253bc0
--- /dev/null
+++ b/internal/service/repository/testdata/advertise.txt
@@ -0,0 +1,4 @@
+001e# service=git-upload-pack
+000000f91e292f8fedd741b75372e19097c76d327140c312 HEADmulti_ack thin-pack side-band side-band-64k ofs-delta shallow deepen-since deepen-not deepen-relative no-progress include-tag multi_ack_detailed no-done symref=HEAD:refs/heads/master agent=git/2.21.0
+003f1e292f8fedd741b75372e19097c76d327140c312 refs/heads/master
+0000
\ No newline at end of file
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go
index 0cce2e89843d5068f8c28ac5342305c7757d5ba0..f776e50df749fa495f4d731e423878676dbe75e6 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: blob.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -38,7 +38,7 @@ func (m *GetBlobRequest) Reset()         { *m = GetBlobRequest{} }
 func (m *GetBlobRequest) String() string { return proto.CompactTextString(m) }
 func (*GetBlobRequest) ProtoMessage()    {}
 func (*GetBlobRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{0}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{0}
 }
 func (m *GetBlobRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetBlobRequest.Unmarshal(m, b)
@@ -95,7 +95,7 @@ func (m *GetBlobResponse) Reset()         { *m = GetBlobResponse{} }
 func (m *GetBlobResponse) String() string { return proto.CompactTextString(m) }
 func (*GetBlobResponse) ProtoMessage()    {}
 func (*GetBlobResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{1}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{1}
 }
 func (m *GetBlobResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetBlobResponse.Unmarshal(m, b)
@@ -151,7 +151,7 @@ func (m *GetBlobsRequest) Reset()         { *m = GetBlobsRequest{} }
 func (m *GetBlobsRequest) String() string { return proto.CompactTextString(m) }
 func (*GetBlobsRequest) ProtoMessage()    {}
 func (*GetBlobsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{2}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{2}
 }
 func (m *GetBlobsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetBlobsRequest.Unmarshal(m, b)
@@ -204,7 +204,7 @@ func (m *GetBlobsRequest_RevisionPath) Reset()         { *m = GetBlobsRequest_Re
 func (m *GetBlobsRequest_RevisionPath) String() string { return proto.CompactTextString(m) }
 func (*GetBlobsRequest_RevisionPath) ProtoMessage()    {}
 func (*GetBlobsRequest_RevisionPath) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{2, 0}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{2, 0}
 }
 func (m *GetBlobsRequest_RevisionPath) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetBlobsRequest_RevisionPath.Unmarshal(m, b)
@@ -258,7 +258,7 @@ func (m *GetBlobsResponse) Reset()         { *m = GetBlobsResponse{} }
 func (m *GetBlobsResponse) String() string { return proto.CompactTextString(m) }
 func (*GetBlobsResponse) ProtoMessage()    {}
 func (*GetBlobsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{3}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{3}
 }
 func (m *GetBlobsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetBlobsResponse.Unmarshal(m, b)
@@ -340,7 +340,7 @@ func (m *LFSPointer) Reset()         { *m = LFSPointer{} }
 func (m *LFSPointer) String() string { return proto.CompactTextString(m) }
 func (*LFSPointer) ProtoMessage()    {}
 func (*LFSPointer) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{4}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{4}
 }
 func (m *LFSPointer) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_LFSPointer.Unmarshal(m, b)
@@ -394,7 +394,7 @@ func (m *NewBlobObject) Reset()         { *m = NewBlobObject{} }
 func (m *NewBlobObject) String() string { return proto.CompactTextString(m) }
 func (*NewBlobObject) ProtoMessage()    {}
 func (*NewBlobObject) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{5}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{5}
 }
 func (m *NewBlobObject) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_NewBlobObject.Unmarshal(m, b)
@@ -447,7 +447,7 @@ func (m *GetLFSPointersRequest) Reset()         { *m = GetLFSPointersRequest{} }
 func (m *GetLFSPointersRequest) String() string { return proto.CompactTextString(m) }
 func (*GetLFSPointersRequest) ProtoMessage()    {}
 func (*GetLFSPointersRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{6}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{6}
 }
 func (m *GetLFSPointersRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetLFSPointersRequest.Unmarshal(m, b)
@@ -492,7 +492,7 @@ func (m *GetLFSPointersResponse) Reset()         { *m = GetLFSPointersResponse{}
 func (m *GetLFSPointersResponse) String() string { return proto.CompactTextString(m) }
 func (*GetLFSPointersResponse) ProtoMessage()    {}
 func (*GetLFSPointersResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{7}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{7}
 }
 func (m *GetLFSPointersResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetLFSPointersResponse.Unmarshal(m, b)
@@ -535,7 +535,7 @@ func (m *GetNewLFSPointersRequest) Reset()         { *m = GetNewLFSPointersReque
 func (m *GetNewLFSPointersRequest) String() string { return proto.CompactTextString(m) }
 func (*GetNewLFSPointersRequest) ProtoMessage()    {}
 func (*GetNewLFSPointersRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{8}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{8}
 }
 func (m *GetNewLFSPointersRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetNewLFSPointersRequest.Unmarshal(m, b)
@@ -601,7 +601,7 @@ func (m *GetNewLFSPointersResponse) Reset()         { *m = GetNewLFSPointersResp
 func (m *GetNewLFSPointersResponse) String() string { return proto.CompactTextString(m) }
 func (*GetNewLFSPointersResponse) ProtoMessage()    {}
 func (*GetNewLFSPointersResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{9}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{9}
 }
 func (m *GetNewLFSPointersResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetNewLFSPointersResponse.Unmarshal(m, b)
@@ -640,7 +640,7 @@ func (m *GetAllLFSPointersRequest) Reset()         { *m = GetAllLFSPointersReque
 func (m *GetAllLFSPointersRequest) String() string { return proto.CompactTextString(m) }
 func (*GetAllLFSPointersRequest) ProtoMessage()    {}
 func (*GetAllLFSPointersRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{10}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{10}
 }
 func (m *GetAllLFSPointersRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetAllLFSPointersRequest.Unmarshal(m, b)
@@ -685,7 +685,7 @@ func (m *GetAllLFSPointersResponse) Reset()         { *m = GetAllLFSPointersResp
 func (m *GetAllLFSPointersResponse) String() string { return proto.CompactTextString(m) }
 func (*GetAllLFSPointersResponse) ProtoMessage()    {}
 func (*GetAllLFSPointersResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_blob_c77e365e4ee3386b, []int{11}
+	return fileDescriptor_blob_4ab5662dde31e5b6, []int{11}
 }
 func (m *GetAllLFSPointersResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetAllLFSPointersResponse.Unmarshal(m, b)
@@ -1073,46 +1073,49 @@ var _BlobService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "blob.proto",
 }
 
-func init() { proto.RegisterFile("blob.proto", fileDescriptor_blob_c77e365e4ee3386b) }
-
-var fileDescriptor_blob_c77e365e4ee3386b = []byte{
-	// 596 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcf, 0x6e, 0xd3, 0x4e,
-	0x10, 0xfe, 0xb9, 0x6e, 0x9a, 0x64, 0xec, 0xf6, 0x57, 0x56, 0xd0, 0xba, 0x16, 0x54, 0xae, 0xc5,
-	0xc1, 0xa7, 0x08, 0x05, 0x71, 0xad, 0x14, 0x0e, 0x8d, 0xa2, 0xa2, 0xb6, 0xda, 0x5c, 0x91, 0x2c,
-	0xbb, 0xde, 0x90, 0xad, 0x36, 0xde, 0xe0, 0xdd, 0xb4, 0x2a, 0x6f, 0xc3, 0x33, 0x70, 0xe7, 0x79,
-	0x78, 0x0c, 0xe4, 0xbf, 0xd9, 0xc4, 0x0e, 0x17, 0xc3, 0x6d, 0x76, 0x66, 0xe7, 0x9b, 0x6f, 0x66,
-	0x3e, 0xaf, 0x01, 0x42, 0xc6, 0xc3, 0xc1, 0x32, 0xe1, 0x92, 0xa3, 0x83, 0x2f, 0x54, 0x06, 0xec,
-	0xd9, 0x36, 0xc5, 0x3c, 0x48, 0x48, 0x94, 0x7b, 0x5d, 0x06, 0x47, 0x63, 0x22, 0x3f, 0x32, 0x1e,
-	0x62, 0xf2, 0x75, 0x45, 0x84, 0x44, 0x43, 0x80, 0x84, 0x2c, 0xb9, 0xa0, 0x92, 0x27, 0xcf, 0x96,
-	0xe6, 0x68, 0x9e, 0x31, 0x44, 0x83, 0x3c, 0x79, 0x80, 0xab, 0x08, 0x56, 0x6e, 0xa1, 0x63, 0xd0,
-	0x39, 0x8d, 0xac, 0x3d, 0x47, 0xf3, 0xfa, 0x38, 0x35, 0xd1, 0x4b, 0xe8, 0x30, 0xba, 0xa0, 0xd2,
-	0xd2, 0x1d, 0xcd, 0xd3, 0x71, 0x7e, 0x70, 0xaf, 0xe1, 0xff, 0xaa, 0x9a, 0x58, 0xf2, 0x58, 0x10,
-	0x84, 0x60, 0x5f, 0xd0, 0x6f, 0x24, 0x2b, 0xa4, 0xe3, 0xcc, 0x4e, 0x7d, 0x51, 0x20, 0x83, 0x0c,
-	0xcf, 0xc4, 0x99, 0x5d, 0x96, 0xd0, 0xab, 0x12, 0xee, 0x2f, 0xad, 0x42, 0x13, 0x6d, 0xc8, 0x5f,
-	0xc3, 0x51, 0x42, 0x1e, 0xa9, 0xa0, 0x3c, 0xf6, 0x97, 0x81, 0x9c, 0x0b, 0x6b, 0xcf, 0xd1, 0x3d,
-	0x63, 0xf8, 0xb6, 0xcc, 0xdb, 0x2a, 0x32, 0xc0, 0xc5, 0xed, 0xbb, 0x40, 0xce, 0xf1, 0x61, 0xa2,
-	0x9c, 0x44, 0x73, 0xdf, 0xf6, 0x25, 0x98, 0x6a, 0x12, 0xb2, 0xa1, 0x57, 0xa6, 0x65, 0x24, 0xfb,
-	0xb8, 0x3a, 0xa7, 0xcd, 0xa7, 0x2c, 0xca, 0xe6, 0x53, 0xdb, 0xfd, 0xa1, 0xc1, 0xf1, 0x9a, 0x45,
-	0xdb, 0xc9, 0xa1, 0x0b, 0x30, 0xa9, 0xf0, 0xc5, 0x2a, 0x5c, 0xf0, 0x68, 0xc5, 0x88, 0xb5, 0xef,
-	0x68, 0x5e, 0x0f, 0x1b, 0x54, 0x4c, 0x4b, 0x57, 0x0a, 0xb4, 0xe0, 0x11, 0xb1, 0x3a, 0x8e, 0xe6,
-	0x75, 0x70, 0x66, 0x6f, 0xb0, 0x3e, 0xd8, 0xc1, 0xba, 0xab, 0xb0, 0xbe, 0x02, 0xf8, 0x74, 0x35,
-	0xbd, 0xe3, 0x34, 0x96, 0x24, 0x69, 0xb1, 0xe8, 0x09, 0x1c, 0xde, 0x90, 0xa7, 0xb4, 0xf9, 0xdb,
-	0xf0, 0x81, 0xdc, 0xcb, 0x46, 0xa8, 0xba, 0x04, 0x4b, 0x4a, 0xba, 0x42, 0x69, 0x06, 0xaf, 0xc6,
-	0x44, 0xae, 0x59, 0xb5, 0x12, 0xce, 0x19, 0xf4, 0xd2, 0xef, 0xcb, 0xa7, 0x51, 0x2e, 0x99, 0x3e,
-	0xee, 0xa6, 0xe7, 0x49, 0x24, 0xdc, 0x5b, 0x38, 0xd9, 0xae, 0x53, 0x6c, 0xed, 0x03, 0x98, 0x6c,
-	0x26, 0xfc, 0x65, 0xe1, 0xb7, 0xb4, 0x4c, 0x6b, 0x55, 0xa9, 0x75, 0x0a, 0x36, 0xd8, 0x4c, 0x94,
-	0xe9, 0xee, 0x4f, 0x0d, 0xac, 0x31, 0x91, 0x37, 0xe4, 0xe9, 0x2f, 0x91, 0x57, 0x97, 0x99, 0x8f,
-	0x7f, 0xbd, 0xcc, 0x0d, 0x11, 0x77, 0x0a, 0x11, 0xa3, 0xd7, 0x00, 0x31, 0x97, 0x3e, 0x8d, 0xfd,
-	0x80, 0xb1, 0x42, 0x33, 0xbd, 0x98, 0xcb, 0x49, 0x3c, 0x62, 0x0c, 0x9d, 0x83, 0x51, 0x44, 0x13,
-	0x32, 0x13, 0x56, 0xc7, 0xd1, 0x3d, 0x13, 0xf7, 0xb3, 0x30, 0x26, 0x33, 0xe1, 0x62, 0x38, 0x6b,
-	0xe0, 0xdf, 0x6e, 0x28, 0x0f, 0xd9, 0x4c, 0x46, 0x8c, 0xfd, 0xfb, 0x99, 0x14, 0xfc, 0xb7, 0x6b,
-	0xb5, 0xe2, 0x3f, 0xfc, 0xae, 0x83, 0x91, 0xca, 0x7a, 0x4a, 0x92, 0x47, 0x7a, 0x4f, 0xd0, 0x25,
-	0x74, 0x8b, 0xaf, 0x1c, 0x9d, 0x6c, 0x3d, 0x3e, 0x45, 0x5b, 0xf6, 0x69, 0xcd, 0x9f, 0x53, 0x70,
-	0xff, 0x7b, 0xa7, 0xa1, 0x11, 0xf4, 0xca, 0x57, 0x02, 0x9d, 0xee, 0x78, 0xbd, 0x6c, 0xab, 0x1e,
-	0x50, 0x20, 0xa6, 0xd9, 0xff, 0x40, 0xe9, 0x11, 0xbd, 0x51, 0xee, 0xd7, 0xe7, 0x6c, 0x9f, 0xef,
-	0x0a, 0x2b, 0xa0, 0x9f, 0xe1, 0x45, 0x6d, 0xf7, 0xc8, 0x51, 0x12, 0x1b, 0x65, 0x6d, 0x5f, 0xfc,
-	0xe1, 0x46, 0x0d, 0x7d, 0x73, 0x33, 0x1b, 0xe8, 0x8d, 0x02, 0xd9, 0x40, 0x6f, 0x5e, 0x6b, 0x8a,
-	0x1e, 0x1e, 0x64, 0xff, 0xc9, 0xf7, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x0d, 0x42, 0xa0, 0x80,
-	0x4b, 0x07, 0x00, 0x00,
+func init() { proto.RegisterFile("blob.proto", fileDescriptor_blob_4ab5662dde31e5b6) }
+
+var fileDescriptor_blob_4ab5662dde31e5b6 = []byte{
+	// 641 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcd, 0x4e, 0xdb, 0x4c,
+	0x14, 0xfd, 0x1c, 0x93, 0x90, 0xdc, 0x04, 0x3e, 0x3a, 0x6a, 0xc1, 0x58, 0x2d, 0x32, 0x51, 0x17,
+	0xde, 0x10, 0x50, 0xaa, 0x6e, 0xba, 0x40, 0x82, 0x05, 0x08, 0x51, 0x01, 0x9a, 0xec, 0xaa, 0x4a,
+	0x91, 0x8d, 0x27, 0x30, 0xd5, 0xc4, 0xe3, 0x7a, 0x06, 0x10, 0x7d, 0x91, 0xae, 0xfb, 0x0c, 0x7d,
+	0x87, 0x3e, 0x4f, 0xd5, 0x27, 0xa8, 0x66, 0xfc, 0x9b, 0xd8, 0x74, 0xe3, 0x76, 0x77, 0xe7, 0xce,
+	0xfd, 0x39, 0xe7, 0xde, 0xe3, 0x31, 0x80, 0xcf, 0xb8, 0x3f, 0x8a, 0x62, 0x2e, 0x39, 0xea, 0xdc,
+	0x50, 0xe9, 0xb1, 0x47, 0x7b, 0x20, 0x6e, 0xbd, 0x98, 0x04, 0x89, 0x77, 0x28, 0x61, 0xfd, 0x94,
+	0xc8, 0x63, 0xc6, 0x7d, 0x4c, 0x3e, 0xdf, 0x11, 0x21, 0xd1, 0x18, 0x20, 0x26, 0x11, 0x17, 0x54,
+	0xf2, 0xf8, 0xd1, 0x32, 0x1c, 0xc3, 0xed, 0x8f, 0xd1, 0x28, 0x49, 0x1e, 0xe1, 0xfc, 0x06, 0x97,
+	0xa2, 0xd0, 0x06, 0x98, 0x9c, 0x06, 0x56, 0xcb, 0x31, 0xdc, 0x1e, 0x56, 0x26, 0x7a, 0x0e, 0x6d,
+	0x46, 0xe7, 0x54, 0x5a, 0xa6, 0x63, 0xb8, 0x26, 0x4e, 0x0e, 0xef, 0x3a, 0xbf, 0xbe, 0xba, 0xad,
+	0x6e, 0x6b, 0x78, 0x0e, 0xff, 0xe7, 0x5d, 0x45, 0xc4, 0x43, 0x41, 0x10, 0x82, 0x15, 0x41, 0xbf,
+	0x10, 0xdd, 0xd0, 0xc4, 0xda, 0x56, 0xbe, 0xc0, 0x93, 0x9e, 0xae, 0x3b, 0xc0, 0xda, 0xce, 0x5a,
+	0x99, 0x79, 0xab, 0xe1, 0x4f, 0x23, 0xaf, 0x26, 0x9a, 0x90, 0x38, 0x87, 0xf5, 0x98, 0xdc, 0x53,
+	0x41, 0x79, 0x38, 0x8d, 0x3c, 0x79, 0x2b, 0xac, 0x96, 0x63, 0xba, 0xfd, 0xf1, 0xeb, 0x2c, 0x6f,
+	0xa9, 0xc9, 0x08, 0xa7, 0xd1, 0x57, 0x9e, 0xbc, 0xc5, 0x6b, 0x71, 0xe9, 0x24, 0xea, 0xf9, 0xdb,
+	0x87, 0x30, 0x28, 0x27, 0x21, 0x1b, 0xba, 0x59, 0x9a, 0x06, 0xd9, 0xc3, 0xf9, 0x59, 0x91, 0x57,
+	0x28, 0x32, 0xf2, 0xca, 0xce, 0xe7, 0xf7, 0xdd, 0x80, 0x8d, 0x02, 0x4d, 0xd3, 0x09, 0xa2, 0x5d,
+	0x18, 0x50, 0x31, 0x15, 0x77, 0xfe, 0x9c, 0x07, 0x77, 0x8c, 0x58, 0x2b, 0x8e, 0xe1, 0x76, 0x71,
+	0x9f, 0x8a, 0x49, 0xe6, 0x52, 0x85, 0xe6, 0x3c, 0x20, 0x56, 0xdb, 0x31, 0xdc, 0x36, 0xd6, 0xf6,
+	0x02, 0xfa, 0xce, 0x13, 0xe8, 0x57, 0x0b, 0xf4, 0xc3, 0x13, 0x80, 0xf7, 0x27, 0x93, 0x2b, 0x4e,
+	0x43, 0x49, 0xe2, 0x06, 0x0b, 0x3f, 0x83, 0xb5, 0x0b, 0xf2, 0xa0, 0xc8, 0x5f, 0xfa, 0x9f, 0xc8,
+	0xb5, 0xac, 0x2d, 0x55, 0x95, 0x64, 0x06, 0xc9, 0x2c, 0x41, 0x0a, 0xe1, 0xc5, 0x29, 0x91, 0x05,
+	0xaa, 0x46, 0x02, 0xda, 0x86, 0xae, 0xfa, 0xde, 0xa6, 0x34, 0x48, 0xa4, 0xd3, 0xc3, 0xab, 0xea,
+	0x7c, 0x16, 0x88, 0x7c, 0x71, 0x97, 0xb0, 0xb9, 0xdc, 0x2f, 0xdd, 0xde, 0x5b, 0x18, 0xb0, 0x99,
+	0x98, 0x46, 0xa9, 0xdf, 0x32, 0xb4, 0xf6, 0xf2, 0x96, 0x45, 0x0a, 0xee, 0xb3, 0x99, 0xc8, 0xd2,
+	0x87, 0x3f, 0x0c, 0xb0, 0x4e, 0x89, 0xbc, 0x20, 0x0f, 0x7f, 0x89, 0x44, 0x79, 0xa9, 0xc9, 0x1a,
+	0x8a, 0xa5, 0x2e, 0x88, 0xba, 0x9d, 0x8a, 0x1a, 0xbd, 0x04, 0x08, 0xb9, 0x9c, 0xd2, 0x70, 0xea,
+	0x31, 0x96, 0x6a, 0xa7, 0x1b, 0x72, 0x79, 0x16, 0x1e, 0x31, 0x86, 0x76, 0xa0, 0x9f, 0xde, 0xc6,
+	0x64, 0x26, 0xac, 0xb6, 0x63, 0xba, 0x03, 0xdc, 0xd3, 0xd7, 0x98, 0xcc, 0x8a, 0xc9, 0x60, 0xd8,
+	0xae, 0xe1, 0xd1, 0x6c, 0x38, 0xb1, 0x9e, 0xcd, 0x11, 0x63, 0xff, 0x7e, 0x36, 0x4b, 0x3c, 0x96,
+	0x7b, 0x36, 0xe2, 0x31, 0xfe, 0x66, 0x42, 0x5f, 0xc9, 0x7d, 0x42, 0xe2, 0x7b, 0x7a, 0x4d, 0xd0,
+	0x21, 0xac, 0xa6, 0x5f, 0x3f, 0xda, 0x5c, 0x7a, 0x9c, 0x52, 0x7a, 0xf6, 0x56, 0xc5, 0x9f, 0x40,
+	0x18, 0xfe, 0x77, 0x60, 0xa0, 0x23, 0xe8, 0x66, 0xaf, 0x07, 0xda, 0x7a, 0xe2, 0x75, 0xb3, 0xad,
+	0xea, 0x45, 0xa9, 0xc4, 0x44, 0xff, 0x37, 0x4a, 0x1c, 0xd1, 0xab, 0x52, 0x7c, 0x75, 0xde, 0xf6,
+	0xce, 0x53, 0xd7, 0xa5, 0xa2, 0x1f, 0xe1, 0x59, 0x45, 0x03, 0xc8, 0x29, 0x25, 0xd6, 0xca, 0xdc,
+	0xde, 0xfd, 0x43, 0x44, 0xa5, 0xfa, 0xe2, 0x66, 0x16, 0xaa, 0xd7, 0x0a, 0x65, 0xa1, 0x7a, 0xfd,
+	0x5a, 0x55, 0xf5, 0xe3, 0x83, 0x0f, 0x2a, 0x8e, 0x79, 0xfe, 0xe8, 0x9a, 0xcf, 0xf7, 0x13, 0x73,
+	0x8f, 0xc7, 0x37, 0xfb, 0x49, 0xf6, 0x9e, 0xfe, 0xdd, 0xee, 0xdf, 0xf0, 0xf4, 0x1c, 0xf9, 0x7e,
+	0x47, 0xbb, 0xde, 0xfc, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x20, 0xce, 0xf0, 0xda, 0xa5, 0x07, 0x00,
+	0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/cleanup.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/cleanup.pb.go
index 65d28f581c8fc212d9ce0d910e5d3bbe2566e4d1..ae513b80e378fa256e992837ff1920ac86c831a3 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/cleanup.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/cleanup.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: cleanup.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -38,7 +38,7 @@ func (m *ApplyBfgObjectMapRequest) Reset()         { *m = ApplyBfgObjectMapReque
 func (m *ApplyBfgObjectMapRequest) String() string { return proto.CompactTextString(m) }
 func (*ApplyBfgObjectMapRequest) ProtoMessage()    {}
 func (*ApplyBfgObjectMapRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cleanup_ef82541c5171c9f7, []int{0}
+	return fileDescriptor_cleanup_048c113e3f69de1a, []int{0}
 }
 func (m *ApplyBfgObjectMapRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ApplyBfgObjectMapRequest.Unmarshal(m, b)
@@ -82,7 +82,7 @@ func (m *ApplyBfgObjectMapResponse) Reset()         { *m = ApplyBfgObjectMapResp
 func (m *ApplyBfgObjectMapResponse) String() string { return proto.CompactTextString(m) }
 func (*ApplyBfgObjectMapResponse) ProtoMessage()    {}
 func (*ApplyBfgObjectMapResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cleanup_ef82541c5171c9f7, []int{1}
+	return fileDescriptor_cleanup_048c113e3f69de1a, []int{1}
 }
 func (m *ApplyBfgObjectMapResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ApplyBfgObjectMapResponse.Unmarshal(m, b)
@@ -213,21 +213,23 @@ var _CleanupService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "cleanup.proto",
 }
 
-func init() { proto.RegisterFile("cleanup.proto", fileDescriptor_cleanup_ef82541c5171c9f7) }
+func init() { proto.RegisterFile("cleanup.proto", fileDescriptor_cleanup_048c113e3f69de1a) }
 
-var fileDescriptor_cleanup_ef82541c5171c9f7 = []byte{
-	// 195 bytes of a gzipped FileDescriptorProto
+var fileDescriptor_cleanup_048c113e3f69de1a = []byte{
+	// 234 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4d, 0xce, 0x49, 0x4d,
 	0xcc, 0x2b, 0x2d, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc,
-	0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81, 0x88, 0x2a, 0xe5, 0x72, 0x49, 0x38,
+	0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81, 0x88, 0x2a, 0x95, 0x72, 0x49, 0x38,
 	0x16, 0x14, 0xe4, 0x54, 0x3a, 0xa5, 0xa5, 0xfb, 0x27, 0x65, 0xa5, 0x26, 0x97, 0xf8, 0x26, 0x16,
 	0x04, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x15, 0xa5, 0x16, 0xe4, 0x17,
 	0x67, 0x96, 0xe4, 0x17, 0x55, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xe9, 0x41, 0x8c,
 	0xd1, 0x0b, 0x82, 0xcb, 0x04, 0x21, 0xa9, 0x12, 0x92, 0xe5, 0xe2, 0xca, 0x07, 0x9b, 0x13, 0x9f,
-	0x9b, 0x58, 0x20, 0xc1, 0xa4, 0xc0, 0xa8, 0xc1, 0x13, 0xc4, 0x99, 0x0f, 0x33, 0x59, 0x49, 0x9a,
-	0x4b, 0x12, 0x8b, 0x75, 0xc5, 0x05, 0xf9, 0x79, 0xc5, 0xa9, 0x46, 0x79, 0x5c, 0x7c, 0xce, 0x10,
-	0x27, 0x07, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x0a, 0xc5, 0x70, 0x09, 0x62, 0x28, 0x17, 0x52,
-	0x80, 0x39, 0x01, 0x97, 0xc3, 0xa5, 0x14, 0xf1, 0xa8, 0x80, 0xd8, 0xa5, 0xc4, 0xa0, 0xc1, 0x98,
-	0xc4, 0x06, 0x0e, 0x02, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x9b, 0x2a, 0x94, 0xb4, 0x29,
-	0x01, 0x00, 0x00,
+	0x9b, 0x58, 0x20, 0xc1, 0xa4, 0xc0, 0xa8, 0xc1, 0x13, 0xc4, 0x99, 0x0f, 0x33, 0xd9, 0x8a, 0xed,
+	0xd3, 0x74, 0x0d, 0x26, 0x0e, 0x46, 0x25, 0x69, 0x2e, 0x49, 0x2c, 0xd6, 0x16, 0x17, 0xe4, 0xe7,
+	0x15, 0xa7, 0x1a, 0xe5, 0x71, 0xf1, 0x39, 0x43, 0x9c, 0x1e, 0x9c, 0x5a, 0x54, 0x96, 0x99, 0x9c,
+	0x2a, 0x14, 0xc3, 0x25, 0x88, 0xa1, 0x5c, 0x48, 0x01, 0xe6, 0x14, 0x5c, 0x1e, 0x90, 0x52, 0xc4,
+	0xa3, 0x02, 0x62, 0x97, 0x12, 0x83, 0x06, 0xa3, 0x93, 0x41, 0x14, 0x48, 0x5d, 0x4e, 0x62, 0x92,
+	0x5e, 0x72, 0x7e, 0xae, 0x3e, 0x84, 0xa9, 0x9b, 0x5f, 0x94, 0xae, 0x0f, 0xd1, 0xad, 0x0b, 0x0e,
+	0x29, 0xfd, 0xf4, 0x7c, 0x28, 0xbf, 0x20, 0x29, 0x89, 0x0d, 0x2c, 0x64, 0x0c, 0x08, 0x00, 0x00,
+	0xff, 0xff, 0x10, 0x0a, 0xea, 0x78, 0x63, 0x01, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/commit.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/commit.pb.go
index be20b93be476ac3120f0fbcfce97d193cc00c93d..2cebc8e33ded23cb2eeb81ed5049f2b0c1d7e646 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/commit.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/commit.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: commit.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -50,7 +50,7 @@ func (x TreeEntryResponse_ObjectType) String() string {
 	return proto.EnumName(TreeEntryResponse_ObjectType_name, int32(x))
 }
 func (TreeEntryResponse_ObjectType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{5, 0}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{5, 0}
 }
 
 type TreeEntry_EntryType int32
@@ -76,7 +76,7 @@ func (x TreeEntry_EntryType) String() string {
 	return proto.EnumName(TreeEntry_EntryType_name, int32(x))
 }
 func (TreeEntry_EntryType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{12, 0}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{12, 0}
 }
 
 type FindAllCommitsRequest_Order int32
@@ -102,7 +102,7 @@ func (x FindAllCommitsRequest_Order) String() string {
 	return proto.EnumName(FindAllCommitsRequest_Order_name, int32(x))
 }
 func (FindAllCommitsRequest_Order) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{21, 0}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{21, 0}
 }
 
 type CommitStatsRequest struct {
@@ -117,7 +117,7 @@ func (m *CommitStatsRequest) Reset()         { *m = CommitStatsRequest{} }
 func (m *CommitStatsRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitStatsRequest) ProtoMessage()    {}
 func (*CommitStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{0}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{0}
 }
 func (m *CommitStatsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitStatsRequest.Unmarshal(m, b)
@@ -165,7 +165,7 @@ func (m *CommitStatsResponse) Reset()         { *m = CommitStatsResponse{} }
 func (m *CommitStatsResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitStatsResponse) ProtoMessage()    {}
 func (*CommitStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{1}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{1}
 }
 func (m *CommitStatsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitStatsResponse.Unmarshal(m, b)
@@ -219,7 +219,7 @@ func (m *CommitIsAncestorRequest) Reset()         { *m = CommitIsAncestorRequest
 func (m *CommitIsAncestorRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitIsAncestorRequest) ProtoMessage()    {}
 func (*CommitIsAncestorRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{2}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{2}
 }
 func (m *CommitIsAncestorRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitIsAncestorRequest.Unmarshal(m, b)
@@ -271,7 +271,7 @@ func (m *CommitIsAncestorResponse) Reset()         { *m = CommitIsAncestorRespon
 func (m *CommitIsAncestorResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitIsAncestorResponse) ProtoMessage()    {}
 func (*CommitIsAncestorResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{3}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{3}
 }
 func (m *CommitIsAncestorResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitIsAncestorResponse.Unmarshal(m, b)
@@ -314,7 +314,7 @@ func (m *TreeEntryRequest) Reset()         { *m = TreeEntryRequest{} }
 func (m *TreeEntryRequest) String() string { return proto.CompactTextString(m) }
 func (*TreeEntryRequest) ProtoMessage()    {}
 func (*TreeEntryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{4}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{4}
 }
 func (m *TreeEntryRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TreeEntryRequest.Unmarshal(m, b)
@@ -380,7 +380,7 @@ func (m *TreeEntryResponse) Reset()         { *m = TreeEntryResponse{} }
 func (m *TreeEntryResponse) String() string { return proto.CompactTextString(m) }
 func (*TreeEntryResponse) ProtoMessage()    {}
 func (*TreeEntryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{5}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{5}
 }
 func (m *TreeEntryResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TreeEntryResponse.Unmarshal(m, b)
@@ -448,7 +448,7 @@ func (m *CommitsBetweenRequest) Reset()         { *m = CommitsBetweenRequest{} }
 func (m *CommitsBetweenRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitsBetweenRequest) ProtoMessage()    {}
 func (*CommitsBetweenRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{6}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{6}
 }
 func (m *CommitsBetweenRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitsBetweenRequest.Unmarshal(m, b)
@@ -500,7 +500,7 @@ func (m *CommitsBetweenResponse) Reset()         { *m = CommitsBetweenResponse{}
 func (m *CommitsBetweenResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitsBetweenResponse) ProtoMessage()    {}
 func (*CommitsBetweenResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{7}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{7}
 }
 func (m *CommitsBetweenResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitsBetweenResponse.Unmarshal(m, b)
@@ -545,7 +545,7 @@ func (m *CountCommitsRequest) Reset()         { *m = CountCommitsRequest{} }
 func (m *CountCommitsRequest) String() string { return proto.CompactTextString(m) }
 func (*CountCommitsRequest) ProtoMessage()    {}
 func (*CountCommitsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{8}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{8}
 }
 func (m *CountCommitsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CountCommitsRequest.Unmarshal(m, b)
@@ -625,7 +625,7 @@ func (m *CountCommitsResponse) Reset()         { *m = CountCommitsResponse{} }
 func (m *CountCommitsResponse) String() string { return proto.CompactTextString(m) }
 func (*CountCommitsResponse) ProtoMessage()    {}
 func (*CountCommitsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{9}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{9}
 }
 func (m *CountCommitsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CountCommitsResponse.Unmarshal(m, b)
@@ -666,7 +666,7 @@ func (m *CountDivergingCommitsRequest) Reset()         { *m = CountDivergingComm
 func (m *CountDivergingCommitsRequest) String() string { return proto.CompactTextString(m) }
 func (*CountDivergingCommitsRequest) ProtoMessage()    {}
 func (*CountDivergingCommitsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{10}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{10}
 }
 func (m *CountDivergingCommitsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CountDivergingCommitsRequest.Unmarshal(m, b)
@@ -726,7 +726,7 @@ func (m *CountDivergingCommitsResponse) Reset()         { *m = CountDivergingCom
 func (m *CountDivergingCommitsResponse) String() string { return proto.CompactTextString(m) }
 func (*CountDivergingCommitsResponse) ProtoMessage()    {}
 func (*CountDivergingCommitsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{11}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{11}
 }
 func (m *CountDivergingCommitsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CountDivergingCommitsResponse.Unmarshal(m, b)
@@ -783,7 +783,7 @@ func (m *TreeEntry) Reset()         { *m = TreeEntry{} }
 func (m *TreeEntry) String() string { return proto.CompactTextString(m) }
 func (*TreeEntry) ProtoMessage()    {}
 func (*TreeEntry) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{12}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{12}
 }
 func (m *TreeEntry) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TreeEntry.Unmarshal(m, b)
@@ -866,7 +866,7 @@ func (m *GetTreeEntriesRequest) Reset()         { *m = GetTreeEntriesRequest{} }
 func (m *GetTreeEntriesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetTreeEntriesRequest) ProtoMessage()    {}
 func (*GetTreeEntriesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{13}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{13}
 }
 func (m *GetTreeEntriesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetTreeEntriesRequest.Unmarshal(m, b)
@@ -925,7 +925,7 @@ func (m *GetTreeEntriesResponse) Reset()         { *m = GetTreeEntriesResponse{}
 func (m *GetTreeEntriesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetTreeEntriesResponse) ProtoMessage()    {}
 func (*GetTreeEntriesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{14}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{14}
 }
 func (m *GetTreeEntriesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetTreeEntriesResponse.Unmarshal(m, b)
@@ -964,7 +964,7 @@ func (m *ListFilesRequest) Reset()         { *m = ListFilesRequest{} }
 func (m *ListFilesRequest) String() string { return proto.CompactTextString(m) }
 func (*ListFilesRequest) ProtoMessage()    {}
 func (*ListFilesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{15}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{15}
 }
 func (m *ListFilesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListFilesRequest.Unmarshal(m, b)
@@ -1011,7 +1011,7 @@ func (m *ListFilesResponse) Reset()         { *m = ListFilesResponse{} }
 func (m *ListFilesResponse) String() string { return proto.CompactTextString(m) }
 func (*ListFilesResponse) ProtoMessage()    {}
 func (*ListFilesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{16}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{16}
 }
 func (m *ListFilesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListFilesResponse.Unmarshal(m, b)
@@ -1050,7 +1050,7 @@ func (m *FindCommitRequest) Reset()         { *m = FindCommitRequest{} }
 func (m *FindCommitRequest) String() string { return proto.CompactTextString(m) }
 func (*FindCommitRequest) ProtoMessage()    {}
 func (*FindCommitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{17}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{17}
 }
 func (m *FindCommitRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindCommitRequest.Unmarshal(m, b)
@@ -1096,7 +1096,7 @@ func (m *FindCommitResponse) Reset()         { *m = FindCommitResponse{} }
 func (m *FindCommitResponse) String() string { return proto.CompactTextString(m) }
 func (*FindCommitResponse) ProtoMessage()    {}
 func (*FindCommitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{18}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{18}
 }
 func (m *FindCommitResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindCommitResponse.Unmarshal(m, b)
@@ -1135,7 +1135,7 @@ func (m *ListCommitsByOidRequest) Reset()         { *m = ListCommitsByOidRequest
 func (m *ListCommitsByOidRequest) String() string { return proto.CompactTextString(m) }
 func (*ListCommitsByOidRequest) ProtoMessage()    {}
 func (*ListCommitsByOidRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{19}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{19}
 }
 func (m *ListCommitsByOidRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListCommitsByOidRequest.Unmarshal(m, b)
@@ -1180,7 +1180,7 @@ func (m *ListCommitsByOidResponse) Reset()         { *m = ListCommitsByOidRespon
 func (m *ListCommitsByOidResponse) String() string { return proto.CompactTextString(m) }
 func (*ListCommitsByOidResponse) ProtoMessage()    {}
 func (*ListCommitsByOidResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{20}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{20}
 }
 func (m *ListCommitsByOidResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListCommitsByOidResponse.Unmarshal(m, b)
@@ -1223,7 +1223,7 @@ func (m *FindAllCommitsRequest) Reset()         { *m = FindAllCommitsRequest{} }
 func (m *FindAllCommitsRequest) String() string { return proto.CompactTextString(m) }
 func (*FindAllCommitsRequest) ProtoMessage()    {}
 func (*FindAllCommitsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{21}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{21}
 }
 func (m *FindAllCommitsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllCommitsRequest.Unmarshal(m, b)
@@ -1290,7 +1290,7 @@ func (m *FindAllCommitsResponse) Reset()         { *m = FindAllCommitsResponse{}
 func (m *FindAllCommitsResponse) String() string { return proto.CompactTextString(m) }
 func (*FindAllCommitsResponse) ProtoMessage()    {}
 func (*FindAllCommitsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{22}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{22}
 }
 func (m *FindAllCommitsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllCommitsResponse.Unmarshal(m, b)
@@ -1339,7 +1339,7 @@ func (m *FindCommitsRequest) Reset()         { *m = FindCommitsRequest{} }
 func (m *FindCommitsRequest) String() string { return proto.CompactTextString(m) }
 func (*FindCommitsRequest) ProtoMessage()    {}
 func (*FindCommitsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{23}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{23}
 }
 func (m *FindCommitsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindCommitsRequest.Unmarshal(m, b)
@@ -1448,7 +1448,7 @@ func (m *FindCommitsResponse) Reset()         { *m = FindCommitsResponse{} }
 func (m *FindCommitsResponse) String() string { return proto.CompactTextString(m) }
 func (*FindCommitsResponse) ProtoMessage()    {}
 func (*FindCommitsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{24}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{24}
 }
 func (m *FindCommitsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindCommitsResponse.Unmarshal(m, b)
@@ -1487,7 +1487,7 @@ func (m *CommitLanguagesRequest) Reset()         { *m = CommitLanguagesRequest{}
 func (m *CommitLanguagesRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitLanguagesRequest) ProtoMessage()    {}
 func (*CommitLanguagesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{25}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{25}
 }
 func (m *CommitLanguagesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitLanguagesRequest.Unmarshal(m, b)
@@ -1532,7 +1532,7 @@ func (m *CommitLanguagesResponse) Reset()         { *m = CommitLanguagesResponse
 func (m *CommitLanguagesResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitLanguagesResponse) ProtoMessage()    {}
 func (*CommitLanguagesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{26}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{26}
 }
 func (m *CommitLanguagesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitLanguagesResponse.Unmarshal(m, b)
@@ -1572,7 +1572,7 @@ func (m *CommitLanguagesResponse_Language) Reset()         { *m = CommitLanguage
 func (m *CommitLanguagesResponse_Language) String() string { return proto.CompactTextString(m) }
 func (*CommitLanguagesResponse_Language) ProtoMessage()    {}
 func (*CommitLanguagesResponse_Language) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{26, 0}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{26, 0}
 }
 func (m *CommitLanguagesResponse_Language) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitLanguagesResponse_Language.Unmarshal(m, b)
@@ -1626,7 +1626,7 @@ func (m *RawBlameRequest) Reset()         { *m = RawBlameRequest{} }
 func (m *RawBlameRequest) String() string { return proto.CompactTextString(m) }
 func (*RawBlameRequest) ProtoMessage()    {}
 func (*RawBlameRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{27}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{27}
 }
 func (m *RawBlameRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RawBlameRequest.Unmarshal(m, b)
@@ -1678,7 +1678,7 @@ func (m *RawBlameResponse) Reset()         { *m = RawBlameResponse{} }
 func (m *RawBlameResponse) String() string { return proto.CompactTextString(m) }
 func (*RawBlameResponse) ProtoMessage()    {}
 func (*RawBlameResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{28}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{28}
 }
 func (m *RawBlameResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RawBlameResponse.Unmarshal(m, b)
@@ -1718,7 +1718,7 @@ func (m *LastCommitForPathRequest) Reset()         { *m = LastCommitForPathReque
 func (m *LastCommitForPathRequest) String() string { return proto.CompactTextString(m) }
 func (*LastCommitForPathRequest) ProtoMessage()    {}
 func (*LastCommitForPathRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{29}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{29}
 }
 func (m *LastCommitForPathRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_LastCommitForPathRequest.Unmarshal(m, b)
@@ -1771,7 +1771,7 @@ func (m *LastCommitForPathResponse) Reset()         { *m = LastCommitForPathResp
 func (m *LastCommitForPathResponse) String() string { return proto.CompactTextString(m) }
 func (*LastCommitForPathResponse) ProtoMessage()    {}
 func (*LastCommitForPathResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{30}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{30}
 }
 func (m *LastCommitForPathResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_LastCommitForPathResponse.Unmarshal(m, b)
@@ -1814,7 +1814,7 @@ func (m *ListLastCommitsForTreeRequest) Reset()         { *m = ListLastCommitsFo
 func (m *ListLastCommitsForTreeRequest) String() string { return proto.CompactTextString(m) }
 func (*ListLastCommitsForTreeRequest) ProtoMessage()    {}
 func (*ListLastCommitsForTreeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{31}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{31}
 }
 func (m *ListLastCommitsForTreeRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListLastCommitsForTreeRequest.Unmarshal(m, b)
@@ -1880,7 +1880,7 @@ func (m *ListLastCommitsForTreeResponse) Reset()         { *m = ListLastCommitsF
 func (m *ListLastCommitsForTreeResponse) String() string { return proto.CompactTextString(m) }
 func (*ListLastCommitsForTreeResponse) ProtoMessage()    {}
 func (*ListLastCommitsForTreeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{32}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{32}
 }
 func (m *ListLastCommitsForTreeResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListLastCommitsForTreeResponse.Unmarshal(m, b)
@@ -1923,7 +1923,7 @@ func (m *ListLastCommitsForTreeResponse_CommitForTree) String() string {
 }
 func (*ListLastCommitsForTreeResponse_CommitForTree) ProtoMessage() {}
 func (*ListLastCommitsForTreeResponse_CommitForTree) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{32, 0}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{32, 0}
 }
 func (m *ListLastCommitsForTreeResponse_CommitForTree) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListLastCommitsForTreeResponse_CommitForTree.Unmarshal(m, b)
@@ -1973,7 +1973,7 @@ func (m *CommitsByMessageRequest) Reset()         { *m = CommitsByMessageRequest
 func (m *CommitsByMessageRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitsByMessageRequest) ProtoMessage()    {}
 func (*CommitsByMessageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{33}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{33}
 }
 func (m *CommitsByMessageRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitsByMessageRequest.Unmarshal(m, b)
@@ -2047,7 +2047,7 @@ func (m *CommitsByMessageResponse) Reset()         { *m = CommitsByMessageRespon
 func (m *CommitsByMessageResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitsByMessageResponse) ProtoMessage()    {}
 func (*CommitsByMessageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{34}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{34}
 }
 func (m *CommitsByMessageResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitsByMessageResponse.Unmarshal(m, b)
@@ -2086,7 +2086,7 @@ func (m *FilterShasWithSignaturesRequest) Reset()         { *m = FilterShasWithS
 func (m *FilterShasWithSignaturesRequest) String() string { return proto.CompactTextString(m) }
 func (*FilterShasWithSignaturesRequest) ProtoMessage()    {}
 func (*FilterShasWithSignaturesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{35}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{35}
 }
 func (m *FilterShasWithSignaturesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FilterShasWithSignaturesRequest.Unmarshal(m, b)
@@ -2131,7 +2131,7 @@ func (m *FilterShasWithSignaturesResponse) Reset()         { *m = FilterShasWith
 func (m *FilterShasWithSignaturesResponse) String() string { return proto.CompactTextString(m) }
 func (*FilterShasWithSignaturesResponse) ProtoMessage()    {}
 func (*FilterShasWithSignaturesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{36}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{36}
 }
 func (m *FilterShasWithSignaturesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FilterShasWithSignaturesResponse.Unmarshal(m, b)
@@ -2170,7 +2170,7 @@ func (m *ExtractCommitSignatureRequest) Reset()         { *m = ExtractCommitSign
 func (m *ExtractCommitSignatureRequest) String() string { return proto.CompactTextString(m) }
 func (*ExtractCommitSignatureRequest) ProtoMessage()    {}
 func (*ExtractCommitSignatureRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{37}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{37}
 }
 func (m *ExtractCommitSignatureRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExtractCommitSignatureRequest.Unmarshal(m, b)
@@ -2218,7 +2218,7 @@ func (m *ExtractCommitSignatureResponse) Reset()         { *m = ExtractCommitSig
 func (m *ExtractCommitSignatureResponse) String() string { return proto.CompactTextString(m) }
 func (*ExtractCommitSignatureResponse) ProtoMessage()    {}
 func (*ExtractCommitSignatureResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{38}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{38}
 }
 func (m *ExtractCommitSignatureResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExtractCommitSignatureResponse.Unmarshal(m, b)
@@ -2264,7 +2264,7 @@ func (m *GetCommitSignaturesRequest) Reset()         { *m = GetCommitSignaturesR
 func (m *GetCommitSignaturesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetCommitSignaturesRequest) ProtoMessage()    {}
 func (*GetCommitSignaturesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{39}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{39}
 }
 func (m *GetCommitSignaturesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetCommitSignaturesRequest.Unmarshal(m, b)
@@ -2313,7 +2313,7 @@ func (m *GetCommitSignaturesResponse) Reset()         { *m = GetCommitSignatures
 func (m *GetCommitSignaturesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetCommitSignaturesResponse) ProtoMessage()    {}
 func (*GetCommitSignaturesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{40}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{40}
 }
 func (m *GetCommitSignaturesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetCommitSignaturesResponse.Unmarshal(m, b)
@@ -2366,7 +2366,7 @@ func (m *GetCommitMessagesRequest) Reset()         { *m = GetCommitMessagesReque
 func (m *GetCommitMessagesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetCommitMessagesRequest) ProtoMessage()    {}
 func (*GetCommitMessagesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{41}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{41}
 }
 func (m *GetCommitMessagesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetCommitMessagesRequest.Unmarshal(m, b)
@@ -2413,7 +2413,7 @@ func (m *GetCommitMessagesResponse) Reset()         { *m = GetCommitMessagesResp
 func (m *GetCommitMessagesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetCommitMessagesResponse) ProtoMessage()    {}
 func (*GetCommitMessagesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_ab0cc8c8e149b4af, []int{42}
+	return fileDescriptor_commit_35518e4c3cf3fa03, []int{42}
 }
 func (m *GetCommitMessagesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetCommitMessagesResponse.Unmarshal(m, b)
@@ -3622,126 +3622,130 @@ var _CommitService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "commit.proto",
 }
 
-func init() { proto.RegisterFile("commit.proto", fileDescriptor_commit_ab0cc8c8e149b4af) }
-
-var fileDescriptor_commit_ab0cc8c8e149b4af = []byte{
-	// 1879 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x5b, 0x6f, 0xdb, 0xc8,
-	0x15, 0x36, 0x75, 0xe7, 0x91, 0xeb, 0x95, 0x27, 0x37, 0x99, 0xb6, 0x63, 0xef, 0xec, 0x66, 0xeb,
-	0xc5, 0x16, 0x4a, 0xe0, 0x5e, 0xd0, 0x3e, 0x15, 0xf6, 0x46, 0x76, 0xed, 0x26, 0xd1, 0x82, 0x16,
-	0x10, 0xb4, 0x28, 0x20, 0xd0, 0xe2, 0x48, 0x9a, 0x86, 0x12, 0xb5, 0xe4, 0xc8, 0xb1, 0xfa, 0xd0,
-	0xf7, 0x02, 0x45, 0xdf, 0xfb, 0x03, 0xfa, 0xd8, 0x87, 0xfe, 0x84, 0x7d, 0xe9, 0x0f, 0xe8, 0xcf,
-	0x59, 0xf4, 0x61, 0x31, 0x17, 0x72, 0x48, 0x89, 0xb4, 0x93, 0x78, 0x95, 0x17, 0x82, 0x73, 0x66,
-	0xe6, 0xdc, 0x66, 0xce, 0x77, 0xce, 0x19, 0x58, 0xef, 0xfb, 0xe3, 0x31, 0x65, 0xad, 0x69, 0xe0,
-	0x33, 0x1f, 0x55, 0x86, 0x94, 0x39, 0xde, 0xdc, 0x5a, 0x0f, 0x47, 0x4e, 0x40, 0x5c, 0x49, 0xb5,
-	0xf6, 0x86, 0xbe, 0x3f, 0xf4, 0xc8, 0x53, 0x31, 0xba, 0x9c, 0x0d, 0x9e, 0x32, 0x3a, 0x26, 0x21,
-	0x73, 0xc6, 0x53, 0xb9, 0x00, 0xbb, 0x80, 0xbe, 0x16, 0x6c, 0x2e, 0x98, 0xc3, 0x42, 0x9b, 0x7c,
-	0x3b, 0x23, 0x21, 0x43, 0x87, 0x00, 0x01, 0x99, 0xfa, 0x21, 0x65, 0x7e, 0x30, 0x6f, 0x1a, 0xfb,
-	0xc6, 0x41, 0xfd, 0x10, 0xb5, 0xa4, 0x84, 0x96, 0x1d, 0xcf, 0xd8, 0x89, 0x55, 0xc8, 0x82, 0x5a,
-	0x40, 0xae, 0x68, 0x48, 0xfd, 0x49, 0xb3, 0xb0, 0x6f, 0x1c, 0xac, 0xdb, 0xf1, 0x18, 0xf7, 0xe1,
-	0x5e, 0x4a, 0x4a, 0x38, 0xf5, 0x27, 0x21, 0x41, 0x0d, 0x28, 0xfa, 0xd4, 0x15, 0xfc, 0x4d, 0x9b,
-	0xff, 0xa2, 0x1d, 0x30, 0x1d, 0xd7, 0xa5, 0x8c, 0xfa, 0x93, 0x50, 0x70, 0x29, 0xdb, 0x9a, 0xc0,
-	0x67, 0x5d, 0xe2, 0x11, 0x39, 0x5b, 0x94, 0xb3, 0x31, 0x01, 0xff, 0xcd, 0x80, 0x47, 0x52, 0xca,
-	0x59, 0x78, 0x34, 0xe9, 0x93, 0x90, 0xf9, 0xc1, 0x5d, 0x0c, 0xda, 0x83, 0xba, 0xa3, 0xd8, 0xf4,
-	0xa8, 0x2b, 0xb4, 0x31, 0x6d, 0x88, 0x48, 0x67, 0x2e, 0xda, 0x82, 0x5a, 0x7f, 0x44, 0x3d, 0x97,
-	0xcf, 0x16, 0xc5, 0x6c, 0x55, 0x8c, 0xcf, 0x5c, 0xfc, 0x0c, 0x9a, 0xcb, 0xaa, 0x28, 0xab, 0xef,
-	0x43, 0xf9, 0xca, 0xf1, 0x66, 0x44, 0xa8, 0x51, 0xb3, 0xe5, 0x00, 0xff, 0xdd, 0x80, 0x46, 0x37,
-	0x20, 0xa4, 0x3d, 0x61, 0xc1, 0x7c, 0x45, 0xe7, 0x80, 0x10, 0x94, 0xa6, 0x0e, 0x1b, 0x09, 0x6d,
-	0xd7, 0x6d, 0xf1, 0xcf, 0xd5, 0xf1, 0xe8, 0x98, 0xb2, 0x66, 0x69, 0xdf, 0x38, 0x28, 0xda, 0x72,
-	0x80, 0xff, 0x67, 0xc0, 0x66, 0x42, 0x1d, 0xa5, 0xfa, 0xaf, 0xa1, 0xc4, 0xe6, 0x53, 0xa9, 0xf9,
-	0xc6, 0xe1, 0xe7, 0x91, 0x26, 0x4b, 0x0b, 0x5b, 0x9d, 0xcb, 0x3f, 0x93, 0x3e, 0xeb, 0xce, 0xa7,
-	0xc4, 0x16, 0x3b, 0xa2, 0xa3, 0x2e, 0xe8, 0xa3, 0x46, 0x50, 0x0a, 0xe9, 0x5f, 0x88, 0xd0, 0xa5,
-	0x68, 0x8b, 0x7f, 0x4e, 0x1b, 0xfb, 0x2e, 0x11, 0xaa, 0x94, 0x6d, 0xf1, 0xcf, 0x69, 0xae, 0xc3,
-	0x9c, 0x66, 0x59, 0xea, 0xcc, 0xff, 0xf1, 0x2f, 0x01, 0xb4, 0x04, 0x04, 0x50, 0xf9, 0xba, 0xf3,
-	0xf2, 0xe5, 0x59, 0xb7, 0xb1, 0x86, 0x6a, 0x50, 0x3a, 0x7e, 0xd1, 0x39, 0x6e, 0x18, 0xfc, 0xaf,
-	0x6b, 0xb7, 0xdb, 0x8d, 0x02, 0xaa, 0x42, 0xb1, 0x7b, 0x74, 0xda, 0x28, 0x62, 0x1f, 0x1e, 0xc8,
-	0x53, 0x09, 0x8f, 0x09, 0x7b, 0x4b, 0xc8, 0xe4, 0x2e, 0x7e, 0x46, 0x50, 0x1a, 0x04, 0xfe, 0x58,
-	0xf9, 0x58, 0xfc, 0xa3, 0x0d, 0x28, 0x30, 0x5f, 0x79, 0xb7, 0xc0, 0x7c, 0xdc, 0x86, 0x87, 0x8b,
-	0x02, 0x95, 0x27, 0xbf, 0x82, 0xaa, 0x0c, 0xdf, 0xb0, 0x69, 0xec, 0x17, 0x0f, 0xea, 0x87, 0x9b,
-	0x91, 0xb8, 0x53, 0xca, 0xe4, 0x1e, 0x3b, 0x5a, 0x81, 0xff, 0x51, 0xe0, 0xf1, 0x33, 0x9b, 0xa8,
-	0x89, 0x55, 0x85, 0x29, 0x7a, 0x06, 0x65, 0x67, 0xc0, 0x48, 0x20, 0x2c, 0xa8, 0x1f, 0x5a, 0x2d,
-	0x89, 0x1e, 0xad, 0x08, 0x3d, 0x5a, 0xdd, 0x08, 0x3d, 0x6c, 0xb9, 0x10, 0x1d, 0x42, 0xe5, 0x92,
-	0x0c, 0xfc, 0x40, 0x1e, 0xd9, 0xcd, 0x5b, 0xd4, 0xca, 0xf8, 0x12, 0x96, 0x13, 0x97, 0x70, 0x1b,
-	0xcc, 0xb1, 0x73, 0xdd, 0xeb, 0x73, 0x23, 0x9b, 0x15, 0x71, 0xfa, 0xb5, 0xb1, 0x73, 0x2d, 0x8c,
-	0xe6, 0x77, 0xc7, 0xf1, 0xbc, 0x66, 0x55, 0x84, 0x0b, 0xff, 0xc5, 0x3f, 0x83, 0xfb, 0x69, 0x7f,
-	0xe8, 0xd0, 0x92, 0x2c, 0x0c, 0xc1, 0x42, 0x0e, 0xf0, 0xbf, 0x0c, 0xd8, 0x11, 0xcb, 0x9f, 0xd3,
-	0x2b, 0x12, 0x0c, 0xe9, 0x64, 0xf8, 0x23, 0xf8, 0xf1, 0x1d, 0x8e, 0x3f, 0x6d, 0x55, 0x35, 0x6d,
-	0xd5, 0x79, 0xa9, 0x56, 0x6a, 0x94, 0xcf, 0x4b, 0xb5, 0x72, 0xa3, 0x72, 0x5e, 0xaa, 0x55, 0x1a,
-	0x55, 0xdc, 0x83, 0xdd, 0x1c, 0x35, 0x95, 0x79, 0xbb, 0x00, 0x1e, 0x19, 0xb0, 0x5e, 0xd2, 0x46,
-	0x93, 0x53, 0xa4, 0x9f, 0xf6, 0xa0, 0x1e, 0xd0, 0xe1, 0x28, 0x9a, 0x97, 0xf0, 0x09, 0x82, 0x24,
-	0x16, 0xe0, 0xef, 0x0d, 0x30, 0xe3, 0x58, 0xcd, 0x40, 0xdf, 0x2d, 0xa8, 0x05, 0xbe, 0xcf, 0x7a,
-	0x3a, 0x52, 0xab, 0x7c, 0xdc, 0x91, 0xd1, 0xba, 0x84, 0x1c, 0x4f, 0x15, 0x1a, 0x94, 0x04, 0x1a,
-	0x6c, 0x2f, 0xa1, 0x41, 0x4b, 0x7c, 0x13, 0x20, 0x10, 0x85, 0x77, 0x39, 0x11, 0xde, 0xbb, 0x00,
-	0xf2, 0x9a, 0x0b, 0xa9, 0x15, 0x21, 0xd5, 0x94, 0x14, 0x2e, 0x77, 0x1b, 0xcc, 0x81, 0xe7, 0xb0,
-	0x9e, 0x10, 0x5e, 0x95, 0xf7, 0x95, 0x13, 0xbe, 0x71, 0xd8, 0x08, 0x7f, 0x05, 0x66, 0x2c, 0x22,
-	0x8e, 0xfc, 0xb5, 0x38, 0xf2, 0x8d, 0x04, 0x32, 0x14, 0xf1, 0x3f, 0x0d, 0x78, 0x70, 0x4a, 0x58,
-	0xa4, 0x1d, 0x25, 0xe1, 0xc7, 0x44, 0xd9, 0x1d, 0x30, 0x03, 0xd2, 0x9f, 0x05, 0x21, 0xbd, 0x92,
-	0x0e, 0xab, 0xd9, 0x9a, 0xc0, 0x71, 0x62, 0x51, 0x35, 0x8d, 0x13, 0x44, 0x92, 0x16, 0x71, 0x42,
-	0x83, 0x6e, 0xb4, 0x02, 0x5f, 0x42, 0xe3, 0x05, 0x0d, 0xd9, 0x09, 0xf5, 0x56, 0x66, 0x1c, 0xfe,
-	0x12, 0x36, 0x13, 0x32, 0x74, 0xdc, 0x71, 0x2b, 0xa5, 0x8e, 0xeb, 0xb6, 0x1c, 0xe0, 0x3e, 0x6c,
-	0x9e, 0xd0, 0x89, 0xab, 0xd0, 0x6c, 0x45, 0xfa, 0xfc, 0x16, 0x50, 0x52, 0x88, 0x52, 0xe8, 0x4b,
-	0xa8, 0xc8, 0x3b, 0xa4, 0x24, 0x64, 0xa0, 0xab, 0x5a, 0x80, 0x7b, 0xf0, 0x88, 0x1b, 0x14, 0xe1,
-	0xf4, 0xbc, 0x43, 0xdd, 0xbb, 0xe8, 0x1a, 0x27, 0xba, 0xa2, 0x8a, 0x2a, 0x7c, 0x0a, 0xcd, 0x65,
-	0x01, 0x1f, 0x92, 0x06, 0xbe, 0x37, 0xe0, 0x01, 0xb7, 0xf5, 0xc8, 0xf3, 0x56, 0x9c, 0x08, 0x52,
-	0xc0, 0x55, 0x5c, 0x80, 0x63, 0x9e, 0xb8, 0xdf, 0xd0, 0x69, 0x94, 0xa4, 0xf9, 0x3f, 0xfa, 0x0d,
-	0x94, 0xfd, 0xc0, 0x25, 0x81, 0x08, 0xed, 0x8d, 0xc3, 0xcf, 0x22, 0xd9, 0x99, 0xea, 0xb6, 0x3a,
-	0x7c, 0xa9, 0x2d, 0x77, 0xe0, 0x27, 0x50, 0x16, 0x63, 0x1e, 0xb6, 0xaf, 0x3a, 0xaf, 0xda, 0x2a,
-	0x80, 0x3b, 0xdf, 0x74, 0x64, 0x12, 0x7f, 0x7e, 0xd4, 0x6d, 0x37, 0x0a, 0x3c, 0x44, 0x16, 0x99,
-	0x7d, 0x88, 0x0f, 0xff, 0x5f, 0x48, 0xde, 0x97, 0x95, 0x39, 0x30, 0x2e, 0xaa, 0xa4, 0xf3, 0xe4,
-	0x00, 0x3d, 0x84, 0x8a, 0x3f, 0x18, 0x84, 0x84, 0x29, 0xdf, 0xa9, 0x91, 0x0e, 0x9f, 0x72, 0x22,
-	0x7c, 0xf8, 0xea, 0x81, 0xef, 0x79, 0xfe, 0x5b, 0x81, 0x8a, 0x35, 0x5b, 0x8d, 0x38, 0xcc, 0x73,
-	0x9f, 0xf7, 0xc6, 0x24, 0x18, 0x92, 0x50, 0xa5, 0x45, 0xe0, 0xa4, 0x97, 0x82, 0x82, 0x3e, 0x85,
-	0x75, 0x97, 0x86, 0xce, 0xa5, 0x47, 0x7a, 0x6f, 0x1d, 0xef, 0x4d, 0xb3, 0x26, 0x56, 0xd4, 0x15,
-	0xed, 0xb5, 0xe3, 0xbd, 0xd1, 0x99, 0xde, 0x7c, 0xff, 0x4c, 0x0f, 0xef, 0x9c, 0xe9, 0x55, 0xe2,
-	0xae, 0xeb, 0xc4, 0x7d, 0x0c, 0xf7, 0x52, 0xde, 0xff, 0x90, 0x23, 0x1c, 0x45, 0x45, 0xd5, 0x0b,
-	0x67, 0x32, 0x9c, 0x39, 0xc3, 0xd5, 0x61, 0xdd, 0xbf, 0xe3, 0x8e, 0x22, 0x21, 0x4a, 0xa9, 0x7c,
-	0x02, 0xa6, 0x17, 0x11, 0x95, 0xd2, 0x07, 0x91, 0xa8, 0x9c, 0x3d, 0xad, 0x88, 0x62, 0xeb, 0xad,
-	0xd6, 0x39, 0xd4, 0x22, 0x32, 0x8f, 0xac, 0x89, 0x33, 0x26, 0x2a, 0x25, 0x8b, 0x7f, 0x7e, 0x37,
-	0x44, 0x47, 0x27, 0x94, 0x2b, 0xd8, 0x72, 0x20, 0x0b, 0x1d, 0xcf, 0x0f, 0x54, 0xdf, 0x21, 0x07,
-	0x78, 0x06, 0x9f, 0xd8, 0xce, 0xdb, 0x63, 0xcf, 0x19, 0x93, 0x8f, 0x98, 0xdb, 0xf0, 0x17, 0xd0,
-	0xd0, 0x62, 0x95, 0x7b, 0xa2, 0xaa, 0xdd, 0x48, 0x54, 0xed, 0x7f, 0x85, 0xe6, 0x0b, 0x27, 0x02,
-	0xc2, 0x13, 0x3f, 0xe0, 0x39, 0xfc, 0x63, 0xea, 0x79, 0x02, 0x5b, 0x19, 0xf2, 0xdf, 0x3f, 0x63,
-	0xfc, 0xc7, 0x80, 0x5d, 0x8e, 0xe8, 0x9a, 0x59, 0x78, 0xe2, 0x07, 0x3c, 0x1f, 0xff, 0x98, 0xd6,
-	0x98, 0xef, 0xd3, 0xb7, 0x65, 0x40, 0x4c, 0x39, 0x09, 0x31, 0xf8, 0xbf, 0x06, 0x3c, 0xce, 0xd3,
-	0x59, 0x79, 0xe0, 0xd5, 0x62, 0x10, 0xfe, 0x22, 0xd2, 0xf8, 0xe6, 0x8d, 0xad, 0xd8, 0xa1, 0x82,
-	0x1a, 0x31, 0xb1, 0xba, 0xf0, 0x93, 0xd4, 0x4c, 0xc2, 0xc5, 0x85, 0x5b, 0x5c, 0x9c, 0x32, 0xd8,
-	0x94, 0x06, 0x9f, 0x97, 0x6a, 0x46, 0xa3, 0x80, 0xbf, 0x8b, 0x63, 0x32, 0x3c, 0x9e, 0xbf, 0x24,
-	0x61, 0xc8, 0xe3, 0x69, 0x45, 0x97, 0x48, 0x3b, 0xb3, 0xb8, 0x88, 0xd7, 0x19, 0xae, 0xcf, 0xea,
-	0x6b, 0xee, 0x43, 0xf9, 0xdb, 0x19, 0x09, 0xe6, 0xaa, 0xb0, 0x95, 0x03, 0x5e, 0x11, 0x2c, 0x9b,
-	0xf0, 0x21, 0x50, 0x48, 0x61, 0xef, 0x84, 0x7a, 0x8c, 0x04, 0x17, 0x23, 0x27, 0x7c, 0x4d, 0xd9,
-	0xe8, 0x82, 0x0e, 0x27, 0x0e, 0x9b, 0x05, 0xe4, 0xae, 0xbd, 0x4d, 0x38, 0x72, 0x42, 0x51, 0xc4,
-	0xac, 0xdb, 0xe2, 0x1f, 0xff, 0x0a, 0xf6, 0xf3, 0x45, 0xe9, 0xa0, 0x17, 0xfb, 0x8c, 0xc4, 0xbe,
-	0x29, 0xec, 0xb6, 0xaf, 0x59, 0xe0, 0xf4, 0x95, 0xf2, 0xf1, 0xb6, 0xbb, 0x28, 0xb8, 0x0d, 0xaa,
-	0x45, 0xd0, 0x0f, 0x33, 0x35, 0x49, 0x38, 0x73, 0x71, 0x0f, 0x1e, 0xe7, 0x49, 0x54, 0x7a, 0xee,
-	0x80, 0x19, 0x46, 0x44, 0x85, 0x50, 0x9a, 0x20, 0xf2, 0x2b, 0x1d, 0x4e, 0x88, 0xdb, 0x63, 0xe4,
-	0x9a, 0xa9, 0x4b, 0x01, 0x92, 0xd4, 0x25, 0xd7, 0x0c, 0xfb, 0x60, 0x9d, 0x92, 0x45, 0xe6, 0x77,
-	0x72, 0xb8, 0x6e, 0x82, 0xa8, 0x1b, 0xaa, 0xda, 0xd1, 0x8c, 0x0c, 0x0a, 0xf1, 0x1c, 0xb6, 0x33,
-	0x05, 0x2a, 0x73, 0x52, 0xde, 0x30, 0xd2, 0xde, 0x48, 0xdb, 0x5a, 0xb8, 0xc5, 0xd6, 0xe2, 0x92,
-	0xad, 0x63, 0x68, 0xc6, 0xa2, 0xd5, 0x55, 0x5d, 0xa5, 0xa5, 0x36, 0x6c, 0x65, 0x88, 0x7b, 0x17,
-	0x3b, 0x9b, 0x50, 0x1d, 0xcb, 0x0d, 0xca, 0xca, 0x68, 0x78, 0xf8, 0xdd, 0x46, 0x04, 0x44, 0x17,
-	0x24, 0xb8, 0xa2, 0x7d, 0x82, 0x5e, 0x43, 0x63, 0xf1, 0x75, 0x0e, 0xed, 0xa5, 0x93, 0xf7, 0xd2,
-	0x13, 0xa2, 0xb5, 0x9f, 0xbf, 0x40, 0xea, 0x87, 0xd7, 0xd0, 0xf3, 0x64, 0x7f, 0xdd, 0xcc, 0x78,
-	0x1e, 0x93, 0xac, 0xb6, 0x72, 0x1f, 0xce, 0xf0, 0xda, 0x33, 0x03, 0x5d, 0xc0, 0x46, 0xfa, 0xd5,
-	0x08, 0xed, 0xa6, 0x65, 0x2f, 0x3c, 0x5f, 0x59, 0x8f, 0xf3, 0xa6, 0x13, 0x4c, 0x7f, 0x0f, 0xeb,
-	0xc9, 0x27, 0x13, 0xb4, 0xad, 0xf7, 0x2c, 0x3d, 0x2c, 0x59, 0x3b, 0xd9, 0x93, 0xb1, 0x9d, 0x03,
-	0x78, 0x90, 0xf9, 0x52, 0x81, 0x3e, 0x4f, 0x6d, 0xcc, 0x79, 0x6f, 0xb1, 0x9e, 0xdc, 0xb2, 0x2a,
-	0x96, 0x73, 0x01, 0x1b, 0xe9, 0xbe, 0x58, 0x7b, 0x22, 0xb3, 0x95, 0xd7, 0x9e, 0xc8, 0x6e, 0xa7,
-	0x85, 0x27, 0x9e, 0x83, 0x19, 0x77, 0xb0, 0xfa, 0x90, 0x16, 0x1b, 0x67, 0x7d, 0x48, 0x4b, 0xed,
-	0xae, 0xe0, 0xd2, 0x06, 0xd0, 0x95, 0x2c, 0xda, 0x4a, 0x36, 0x3c, 0xa9, 0x86, 0xd7, 0xb2, 0xb2,
-	0xa6, 0x62, 0x0b, 0x7f, 0x07, 0xf5, 0xc4, 0xcb, 0x38, 0xb2, 0xd2, 0x27, 0x99, 0x7c, 0x94, 0xb7,
-	0xb6, 0x33, 0xe7, 0x92, 0xbe, 0x4a, 0x37, 0x48, 0xda, 0x57, 0x99, 0x5d, 0x98, 0xf6, 0x55, 0x76,
-	0x5f, 0x25, 0xac, 0x3c, 0x87, 0x7a, 0xa2, 0x5e, 0x47, 0x19, 0xb6, 0x2c, 0xab, 0x97, 0x51, 0xe0,
-	0x0b, 0x5e, 0x5d, 0xf8, 0x64, 0xa1, 0x30, 0x46, 0x8f, 0x73, 0x2b, 0x66, 0xc9, 0x73, 0xef, 0x96,
-	0x8a, 0x1a, 0xaf, 0xa1, 0x23, 0xa8, 0x45, 0xc5, 0x27, 0x7a, 0x14, 0x83, 0x4f, 0xba, 0x0a, 0xb6,
-	0x9a, 0xcb, 0x13, 0x09, 0xc5, 0xfe, 0x08, 0x9b, 0x4b, 0x75, 0x21, 0x8a, 0xc3, 0x3d, 0xaf, 0x64,
-	0xb5, 0x3e, 0xbd, 0x61, 0x45, 0xac, 0xde, 0x1b, 0x78, 0x98, 0x5d, 0x3d, 0xa1, 0x27, 0xb7, 0x55,
-	0x57, 0x52, 0xca, 0x17, 0xef, 0x56, 0x84, 0x09, 0x43, 0xfe, 0x10, 0xe1, 0x9a, 0xae, 0x2b, 0x16,
-	0x71, 0x6d, 0xa9, 0x68, 0x5a, 0xc4, 0xb5, 0xe5, 0x92, 0x24, 0x62, 0xbd, 0xf8, 0x88, 0xa1, 0x59,
-	0xe7, 0xbc, 0x9f, 0x68, 0xd6, 0x79, 0xef, 0x1f, 0x82, 0x75, 0x08, 0xcd, 0xbc, 0xca, 0x02, 0xfd,
-	0x54, 0x5f, 0xaa, 0x1b, 0xcb, 0x1c, 0xeb, 0xe0, 0xf6, 0x85, 0x91, 0xc8, 0x03, 0xe3, 0x99, 0xc1,
-	0xcf, 0x25, 0xbb, 0x48, 0xd0, 0xe7, 0x72, 0x63, 0xd9, 0xa2, 0xcf, 0xe5, 0xe6, 0x5a, 0x43, 0x58,
-	0x78, 0x09, 0xf7, 0x32, 0xf2, 0x37, 0xc2, 0x09, 0xb0, 0xca, 0xa9, 0x26, 0xac, 0xcf, 0x6e, 0x5c,
-	0x93, 0x90, 0xf1, 0x27, 0xd8, 0x5c, 0xca, 0x9c, 0xfa, 0x12, 0xe7, 0xe5, 0x70, 0x7d, 0x89, 0x73,
-	0xd3, 0x2e, 0xe7, 0x7e, 0x59, 0x11, 0x5d, 0xfe, 0xcf, 0x7f, 0x08, 0x00, 0x00, 0xff, 0xff, 0xd7,
-	0x68, 0x06, 0x91, 0x74, 0x1c, 0x00, 0x00,
+func init() { proto.RegisterFile("commit.proto", fileDescriptor_commit_35518e4c3cf3fa03) }
+
+var fileDescriptor_commit_35518e4c3cf3fa03 = []byte{
+	// 1942 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0x4b, 0x6f, 0xe3, 0xc8,
+	0x11, 0x36, 0xf5, 0x24, 0x4b, 0x8e, 0x57, 0xee, 0x79, 0xc9, 0xb4, 0x3d, 0xf6, 0x72, 0x77, 0x36,
+	0x5e, 0x6c, 0x56, 0x36, 0x9c, 0x07, 0x92, 0x5c, 0x02, 0x7b, 0xc7, 0x76, 0xc6, 0x99, 0x19, 0x2d,
+	0x68, 0x01, 0x83, 0x2c, 0x02, 0x08, 0xb4, 0xd8, 0x92, 0xb9, 0xa6, 0x44, 0x0d, 0xd9, 0xb2, 0xad,
+	0x00, 0xb9, 0x04, 0x41, 0xee, 0x01, 0x82, 0xe4, 0x9c, 0x1f, 0xb0, 0x3f, 0x20, 0xc7, 0x1c, 0x73,
+	0xc9, 0x21, 0x3f, 0x25, 0xc7, 0x9c, 0x82, 0x7e, 0xb1, 0x49, 0x91, 0xb4, 0x67, 0xc6, 0xe3, 0xc9,
+	0x45, 0x60, 0x57, 0x77, 0xd7, 0xab, 0xbb, 0xbe, 0xaa, 0x6a, 0xc1, 0x62, 0x3f, 0x18, 0x8d, 0x3c,
+	0xd2, 0x9e, 0x84, 0x01, 0x09, 0x50, 0x6d, 0xe8, 0x11, 0xc7, 0x9f, 0x99, 0x8b, 0xd1, 0x99, 0x13,
+	0x62, 0x97, 0x53, 0xcd, 0x8d, 0x61, 0x10, 0x0c, 0x7d, 0xbc, 0xcd, 0x46, 0xa7, 0xd3, 0xc1, 0x36,
+	0xf1, 0x46, 0x38, 0x22, 0xce, 0x68, 0xc2, 0x17, 0x58, 0x3e, 0xa0, 0xaf, 0x18, 0x9b, 0x13, 0xe2,
+	0x90, 0xc8, 0xc6, 0xaf, 0xa7, 0x38, 0x22, 0x68, 0x17, 0x20, 0xc4, 0x93, 0x20, 0xf2, 0x48, 0x10,
+	0xce, 0x5a, 0xda, 0xa6, 0xb6, 0xd5, 0xd8, 0x45, 0x6d, 0x2e, 0xa1, 0x6d, 0xc7, 0x33, 0x76, 0x62,
+	0x15, 0x32, 0x41, 0x0f, 0xf1, 0x85, 0x17, 0x79, 0xc1, 0xb8, 0x55, 0xda, 0xd4, 0xb6, 0x16, 0xed,
+	0x78, 0xfc, 0xf3, 0xda, 0x7f, 0xfe, 0xba, 0x55, 0xd2, 0x4b, 0x56, 0x1f, 0xee, 0xa5, 0xa4, 0x45,
+	0x93, 0x60, 0x1c, 0x61, 0xd4, 0x84, 0x72, 0xe0, 0xb9, 0x4c, 0x8e, 0x61, 0xd3, 0x4f, 0xb4, 0x06,
+	0x86, 0xe3, 0xba, 0x1e, 0xf1, 0x82, 0x71, 0xc4, 0xb8, 0x55, 0x6d, 0x45, 0xa0, 0xb3, 0x2e, 0xf6,
+	0x31, 0x9f, 0x2d, 0xf3, 0xd9, 0x98, 0x60, 0xfd, 0x49, 0x83, 0x47, 0x5c, 0xca, 0xb3, 0x68, 0x6f,
+	0xdc, 0xc7, 0x11, 0x09, 0xc2, 0xdb, 0x18, 0xb6, 0x01, 0x0d, 0x47, 0xb0, 0xe9, 0x79, 0x2e, 0xd3,
+	0xc6, 0xb0, 0x41, 0x92, 0x9e, 0xb9, 0x68, 0x05, 0xf4, 0xfe, 0x99, 0xe7, 0xbb, 0x74, 0xb6, 0xcc,
+	0x66, 0xeb, 0x6c, 0xfc, 0xcc, 0x8d, 0x0d, 0xdf, 0x81, 0x56, 0x56, 0x25, 0x61, 0xfd, 0x7d, 0xa8,
+	0x5e, 0x38, 0xfe, 0x14, 0x33, 0x75, 0x74, 0x9b, 0x0f, 0xac, 0x3f, 0x6b, 0xd0, 0xec, 0x86, 0x18,
+	0x1f, 0x8c, 0x49, 0x38, 0xbb, 0xa3, 0x73, 0x41, 0x08, 0x2a, 0x13, 0x87, 0x9c, 0x31, 0xad, 0x17,
+	0x6d, 0xf6, 0x4d, 0xd5, 0xf1, 0xbd, 0x91, 0x47, 0x5a, 0x95, 0x4d, 0x6d, 0xab, 0x6c, 0xf3, 0x41,
+	0x6c, 0xc8, 0xbf, 0x35, 0x58, 0x4e, 0xa8, 0x25, 0x4c, 0xf8, 0x29, 0x54, 0xc8, 0x6c, 0xc2, 0x2d,
+	0x58, 0xda, 0xfd, 0x54, 0x6a, 0x94, 0x59, 0xd8, 0xee, 0x9c, 0x7e, 0x8b, 0xfb, 0xa4, 0x3b, 0x9b,
+	0x60, 0x9b, 0xed, 0x90, 0x47, 0x5f, 0x52, 0x47, 0x8f, 0xa0, 0x12, 0x79, 0xbf, 0xc5, 0x4c, 0xa7,
+	0xb2, 0xcd, 0xbe, 0x29, 0x6d, 0x14, 0xb8, 0x98, 0xa9, 0x54, 0xb5, 0xd9, 0x37, 0xa5, 0xb9, 0x0e,
+	0x71, 0x5a, 0x55, 0xae, 0x3b, 0xfd, 0xb6, 0x7e, 0x0c, 0xa0, 0x24, 0x20, 0x80, 0xda, 0x57, 0x9d,
+	0x17, 0x2f, 0x9e, 0x75, 0x9b, 0x0b, 0x48, 0x87, 0xca, 0xfe, 0xf3, 0xce, 0x7e, 0x53, 0xa3, 0x5f,
+	0x5d, 0xfb, 0xe0, 0xa0, 0x59, 0x42, 0x75, 0x28, 0x77, 0xf7, 0x8e, 0x9a, 0x65, 0xeb, 0x12, 0x1e,
+	0xf0, 0xd3, 0x89, 0xf6, 0x31, 0xb9, 0xc4, 0x78, 0x7c, 0x1b, 0x7f, 0x23, 0xa8, 0x0c, 0xc2, 0x60,
+	0x24, 0x7c, 0xcd, 0xbe, 0xd1, 0x12, 0x94, 0x48, 0x20, 0xbc, 0x5c, 0x22, 0x41, 0xec, 0xcd, 0x03,
+	0x78, 0x38, 0x2f, 0x58, 0x78, 0xf4, 0x0b, 0xa8, 0xf3, 0xf0, 0x8e, 0x5a, 0xda, 0x66, 0x79, 0xab,
+	0xb1, 0xbb, 0x2c, 0xc5, 0x1e, 0x79, 0x84, 0xef, 0xb1, 0xe5, 0x0a, 0xeb, 0x2f, 0x25, 0x1a, 0x57,
+	0xd3, 0xb1, 0x98, 0xb8, 0xab, 0x30, 0x46, 0x3b, 0x50, 0x75, 0x06, 0x04, 0x87, 0xcc, 0x92, 0xc6,
+	0xae, 0xd9, 0xe6, 0xe8, 0xd2, 0x96, 0xe8, 0xd2, 0xee, 0x4a, 0x74, 0xb1, 0xf9, 0x42, 0xb4, 0x0b,
+	0xb5, 0x53, 0x3c, 0x08, 0x42, 0x7e, 0x74, 0xd7, 0x6f, 0x11, 0x2b, 0xe3, 0x4b, 0x59, 0x4d, 0x5c,
+	0xca, 0x55, 0x30, 0x46, 0xce, 0x55, 0xaf, 0x4f, 0x8d, 0x6c, 0xd5, 0xd8, 0x2d, 0xd0, 0x47, 0xce,
+	0x15, 0x33, 0x9a, 0xde, 0x21, 0xc7, 0xf7, 0x5b, 0x75, 0x16, 0x3e, 0xf4, 0x33, 0xf6, 0xef, 0x0f,
+	0xe0, 0x7e, 0xda, 0x2f, 0x2a, 0xe4, 0x38, 0x2b, 0x8d, 0xb1, 0xe2, 0x03, 0xeb, 0x3b, 0x0d, 0xd6,
+	0xd8, 0xf2, 0xa7, 0xde, 0x05, 0x0e, 0x87, 0xde, 0x78, 0xf8, 0x1e, 0xfc, 0xf9, 0x06, 0xd7, 0x21,
+	0x6d, 0x5d, 0x3d, 0x6d, 0x9d, 0xb4, 0xe5, 0xb8, 0xa2, 0x57, 0x9a, 0xd5, 0xe3, 0x8a, 0x5e, 0x6d,
+	0xd6, 0x8e, 0x2b, 0x7a, 0xad, 0x59, 0xb7, 0x7a, 0xb0, 0x5e, 0xa0, 0xae, 0x30, 0x73, 0x1d, 0xc0,
+	0xc7, 0x03, 0xd2, 0x4b, 0xda, 0x6a, 0x50, 0x0a, 0xf7, 0xdb, 0x06, 0x34, 0x42, 0x6f, 0x78, 0x26,
+	0xe7, 0x39, 0xcc, 0x02, 0x23, 0xb1, 0x05, 0xd6, 0x7f, 0x35, 0x30, 0xe2, 0x18, 0xce, 0x41, 0xe9,
+	0x15, 0xd0, 0xc3, 0x20, 0x20, 0x3d, 0x15, 0xc1, 0x75, 0x3a, 0xee, 0xf0, 0x28, 0xce, 0x20, 0xcb,
+	0xb6, 0x40, 0x89, 0x0a, 0x43, 0x89, 0xd5, 0x0c, 0x4a, 0xb4, 0xd9, 0x6f, 0x02, 0x1c, 0x64, 0xd8,
+	0x57, 0x13, 0x61, 0xbf, 0x0e, 0xc0, 0xaf, 0x3d, 0x93, 0x5a, 0x63, 0x52, 0x0d, 0x4e, 0xa1, 0x72,
+	0x57, 0xc1, 0x18, 0xf8, 0x0e, 0xe9, 0x31, 0xe1, 0x75, 0x7e, 0x7f, 0x29, 0xe1, 0x6b, 0x87, 0x9c,
+	0x59, 0x5f, 0x80, 0x11, 0x8b, 0x88, 0x11, 0x61, 0x21, 0x46, 0x04, 0x2d, 0x81, 0x18, 0x65, 0xeb,
+	0x6f, 0x1a, 0x3c, 0x38, 0xc2, 0x44, 0x6a, 0xe7, 0xe1, 0xe8, 0x43, 0xa2, 0xf0, 0x1a, 0x18, 0x21,
+	0xee, 0x4f, 0xc3, 0xc8, 0xbb, 0xe0, 0x0e, 0xd3, 0x6d, 0x45, 0x48, 0xe2, 0xc7, 0xbc, 0x8a, 0x0a,
+	0x3f, 0x30, 0x27, 0xcd, 0xe3, 0x87, 0x02, 0x65, 0xb9, 0xc2, 0xfa, 0x16, 0x9a, 0xcf, 0xbd, 0x88,
+	0x1c, 0x7a, 0x3e, 0xbe, 0xf3, 0x12, 0xe0, 0x73, 0x58, 0x4e, 0xc8, 0x52, 0xf1, 0x48, 0xad, 0xe6,
+	0xba, 0x2e, 0xda, 0x7c, 0x60, 0x9d, 0xc3, 0xf2, 0xa1, 0x37, 0x76, 0x05, 0xda, 0xdd, 0xb1, 0x5e,
+	0xbf, 0x00, 0x94, 0x14, 0x26, 0x14, 0xfb, 0x1c, 0x6a, 0xfc, 0x6e, 0x09, 0x49, 0x39, 0x28, 0x2c,
+	0x16, 0x58, 0x43, 0x78, 0x44, 0x0d, 0x93, 0x78, 0x3e, 0xeb, 0x78, 0xee, 0x6d, 0x74, 0x8e, 0x13,
+	0x63, 0x59, 0x44, 0x5b, 0xac, 0xe9, 0x11, 0xb4, 0xb2, 0x82, 0xde, 0x25, 0x6d, 0xfc, 0xbe, 0x04,
+	0x0f, 0xa8, 0xcd, 0x7b, 0xbe, 0x7f, 0xc7, 0x89, 0x23, 0x05, 0x70, 0xe5, 0x39, 0xf8, 0xa6, 0x09,
+	0xff, 0xdc, 0x9b, 0xc8, 0xe4, 0x4e, 0xbf, 0xd1, 0xcf, 0xa0, 0x1a, 0x84, 0x2e, 0x0e, 0x59, 0xe8,
+	0x2f, 0xed, 0x7e, 0x22, 0x65, 0xe7, 0xaa, 0xdb, 0xee, 0xd0, 0xa5, 0x36, 0xdf, 0x61, 0x3d, 0x81,
+	0x2a, 0x1b, 0xd3, 0xb0, 0x7e, 0xd9, 0x79, 0x79, 0x20, 0x02, 0xbc, 0xf3, 0x75, 0x87, 0x27, 0xff,
+	0xa7, 0x7b, 0xdd, 0x83, 0x66, 0x29, 0x19, 0x42, 0xf3, 0x4c, 0xdf, 0xc5, 0x97, 0x7f, 0x28, 0x27,
+	0xef, 0xcf, 0x9d, 0x39, 0x32, 0x2e, 0xce, 0xb8, 0x13, 0xf9, 0x00, 0x3d, 0x84, 0x5a, 0x30, 0x18,
+	0x44, 0x98, 0x08, 0x1f, 0x8a, 0x91, 0x0a, 0xab, 0x6a, 0x22, 0xac, 0xe8, 0xea, 0x41, 0xe0, 0xfb,
+	0xc1, 0x25, 0x43, 0x4f, 0xdd, 0x16, 0x23, 0x9a, 0x0e, 0xa8, 0xef, 0x7b, 0x23, 0x1c, 0x0e, 0x71,
+	0x24, 0xd2, 0x29, 0x50, 0xd2, 0x0b, 0x46, 0x41, 0x1f, 0xc3, 0xa2, 0xeb, 0x45, 0xce, 0xa9, 0x8f,
+	0x7b, 0x97, 0x8e, 0x7f, 0xde, 0xd2, 0xd9, 0x8a, 0x86, 0xa0, 0xbd, 0x72, 0xfc, 0x73, 0x55, 0x21,
+	0x18, 0x6f, 0x5f, 0x21, 0xc0, 0x1b, 0x57, 0x08, 0x22, 0xe1, 0x37, 0xb2, 0x09, 0x7f, 0x1f, 0xee,
+	0xa5, 0x4e, 0xe1, 0x5d, 0x8e, 0x72, 0x22, 0x8b, 0xb2, 0xe7, 0xce, 0x78, 0x38, 0x75, 0x86, 0x77,
+	0x8f, 0x89, 0xdf, 0xc5, 0x1d, 0x4b, 0x42, 0xa4, 0x50, 0xfd, 0x10, 0x0c, 0x5f, 0x12, 0x85, 0xf2,
+	0x5b, 0x52, 0x64, 0xc1, 0x9e, 0xb6, 0xa4, 0xd8, 0x6a, 0xab, 0x79, 0x0c, 0xba, 0x24, 0xd3, 0x88,
+	0x1b, 0x3b, 0x23, 0x2c, 0x52, 0x39, 0xfb, 0xa6, 0x77, 0x85, 0x75, 0x8e, 0x4c, 0xc9, 0x92, 0xcd,
+	0x07, 0xbc, 0x50, 0xf2, 0x83, 0x50, 0xf4, 0x35, 0x7c, 0x60, 0xfd, 0x0e, 0x3e, 0xb2, 0x9d, 0xcb,
+	0x7d, 0xdf, 0x19, 0xe1, 0x0f, 0x98, 0x13, 0x63, 0x77, 0x7d, 0x06, 0x4d, 0x25, 0x5e, 0xb8, 0x49,
+	0x76, 0x03, 0x5a, 0xa2, 0x1b, 0xf8, 0xa3, 0x06, 0xad, 0xe7, 0x8e, 0x44, 0xca, 0xc3, 0x20, 0xa4,
+	0x45, 0xc0, 0xff, 0x43, 0xe1, 0x43, 0x58, 0xc9, 0xd1, 0xe3, 0xed, 0x53, 0xcc, 0xdf, 0x35, 0x58,
+	0xa7, 0xd0, 0xaf, 0x98, 0x45, 0x87, 0x41, 0x48, 0x13, 0xfa, 0xfb, 0xb4, 0xca, 0x78, 0x9b, 0x06,
+	0x31, 0x07, 0x83, 0xaa, 0x49, 0x0c, 0x8a, 0x7d, 0xf0, 0x2f, 0x0d, 0x1e, 0x17, 0xe9, 0x2e, 0x3c,
+	0xf1, 0x72, 0x3e, 0x4a, 0x7f, 0x24, 0x35, 0xbf, 0x7e, 0x63, 0x3b, 0x76, 0x2c, 0xa3, 0x4a, 0x26,
+	0x66, 0x17, 0xbe, 0x97, 0x9a, 0x49, 0xb8, 0xba, 0x74, 0x83, 0xab, 0x53, 0x86, 0x1b, 0xdc, 0xf0,
+	0xe3, 0x8a, 0xae, 0x25, 0x12, 0xc7, 0x3f, 0xe3, 0xa0, 0x8d, 0xf6, 0x67, 0x2f, 0x70, 0x14, 0xd1,
+	0x80, 0xbb, 0xa3, 0xcb, 0xa5, 0x9c, 0x5b, 0x9e, 0x07, 0xf8, 0x9c, 0xa3, 0xc8, 0x6b, 0xa0, 0xee,
+	0x43, 0xf5, 0xf5, 0x14, 0x87, 0x33, 0x51, 0x31, 0xf3, 0x41, 0xb2, 0xa4, 0xc8, 0x9a, 0xf2, 0x2e,
+	0xd8, 0xf9, 0x1a, 0x36, 0x0e, 0x3d, 0x9f, 0xe0, 0xf0, 0xe4, 0xcc, 0x89, 0x5e, 0x79, 0xe4, 0xec,
+	0xc4, 0x1b, 0x8e, 0x1d, 0x32, 0x0d, 0xf1, 0x6d, 0x9b, 0xa8, 0xe8, 0xcc, 0x89, 0x58, 0x35, 0xb4,
+	0x68, 0xb3, 0xef, 0x58, 0xf7, 0x9f, 0xc0, 0x66, 0xb1, 0x48, 0x85, 0x0e, 0x6c, 0xbf, 0xa6, 0xf6,
+	0x5b, 0x57, 0xb0, 0x7e, 0x70, 0x45, 0x42, 0xa7, 0x2f, 0x8c, 0x88, 0xb7, 0xdd, 0x46, 0xd1, 0x55,
+	0x10, 0xbd, 0x88, 0x7a, 0x29, 0xd2, 0x39, 0x21, 0xf1, 0x18, 0xd4, 0x83, 0xc7, 0x45, 0x92, 0x85,
+	0xbe, 0x6b, 0x60, 0x44, 0x92, 0x28, 0x20, 0x4d, 0x11, 0x58, 0xa2, 0xf6, 0x86, 0x63, 0xec, 0xf6,
+	0x08, 0xbe, 0x22, 0xe2, 0xb2, 0x00, 0x27, 0x75, 0xf1, 0x15, 0xb1, 0x2e, 0xc1, 0x3c, 0xc2, 0xf3,
+	0xcc, 0x6f, 0x75, 0x00, 0xaa, 0xeb, 0xf2, 0xdc, 0x48, 0x14, 0xa5, 0x86, 0x34, 0x4c, 0x9d, 0xc5,
+	0x0c, 0x56, 0x73, 0x05, 0x0b, 0xb3, 0x52, 0xde, 0xd1, 0xd2, 0xde, 0x49, 0xdb, 0x5c, 0xba, 0xc1,
+	0xe6, 0x72, 0xc6, 0xe6, 0x29, 0xb4, 0x62, 0xd1, 0xe2, 0x0a, 0x7f, 0x08, 0x8b, 0x6d, 0x58, 0xc9,
+	0x11, 0xfb, 0x26, 0xf6, 0xb6, 0xa0, 0x3e, 0xe2, 0x1b, 0x84, 0xb5, 0x72, 0xb8, 0xfb, 0x8f, 0x25,
+	0x09, 0x5c, 0x27, 0x38, 0xbc, 0xf0, 0xfa, 0x18, 0xbd, 0x82, 0xe6, 0xfc, 0xf3, 0x21, 0xda, 0x48,
+	0x57, 0x01, 0x99, 0xb7, 0x4e, 0x73, 0xb3, 0x78, 0x01, 0xd7, 0xcf, 0x5a, 0x40, 0x4f, 0x93, 0x0d,
+	0x7e, 0x2b, 0xe7, 0xdd, 0x8e, 0xb3, 0x5a, 0x29, 0x7c, 0xd1, 0xb3, 0x16, 0x76, 0x34, 0x74, 0x02,
+	0x4b, 0xe9, 0x67, 0x2c, 0xb4, 0x9e, 0x96, 0x3d, 0xf7, 0xae, 0x66, 0x3e, 0x2e, 0x9a, 0x4e, 0x30,
+	0xfd, 0x15, 0x2c, 0x26, 0xdf, 0x6e, 0xd0, 0xaa, 0xda, 0x93, 0x79, 0xe9, 0x32, 0xd7, 0xf2, 0x27,
+	0x63, 0x3b, 0x07, 0xf0, 0x20, 0xf7, 0xa9, 0x04, 0x7d, 0x9a, 0xda, 0x58, 0xf0, 0xf0, 0x63, 0x3e,
+	0xb9, 0x61, 0x55, 0x2c, 0xe7, 0x04, 0x96, 0xd2, 0x0d, 0xb9, 0xf2, 0x44, 0xee, 0x5b, 0x82, 0xf2,
+	0x44, 0x7e, 0x1f, 0xcf, 0x3c, 0xf1, 0x14, 0x8c, 0xb8, 0x65, 0x56, 0x87, 0x34, 0xdf, 0xb1, 0xab,
+	0x43, 0xca, 0xf4, 0xd7, 0x8c, 0xcb, 0x01, 0x80, 0x2a, 0x8d, 0xd1, 0x4a, 0xb2, 0xa3, 0x4a, 0x75,
+	0xd8, 0xa6, 0x99, 0x37, 0x15, 0x5b, 0xf8, 0x4b, 0x68, 0x24, 0x9e, 0xf0, 0x91, 0x99, 0x3e, 0xc9,
+	0xe4, 0xbf, 0x08, 0xe6, 0x6a, 0xee, 0x5c, 0xd2, 0x57, 0xe9, 0xce, 0x4b, 0xf9, 0x2a, 0xb7, 0xcd,
+	0x53, 0xbe, 0xca, 0x6f, 0xd8, 0x98, 0x95, 0xc7, 0xd0, 0x48, 0x34, 0x00, 0x28, 0xc7, 0x96, 0xac,
+	0x7a, 0x39, 0x1d, 0x03, 0xe3, 0xd5, 0x85, 0x8f, 0xe6, 0x2a, 0x6c, 0xf4, 0xb8, 0xb0, 0xf4, 0xe6,
+	0x3c, 0x37, 0x6e, 0x28, 0xcd, 0xad, 0x05, 0xb4, 0x07, 0xba, 0xac, 0x5e, 0xd1, 0xa3, 0x18, 0x84,
+	0xd2, 0xe5, 0xb4, 0xd9, 0xca, 0x4e, 0x24, 0x14, 0xfb, 0x06, 0x96, 0x33, 0xf5, 0x24, 0x8a, 0xc3,
+	0xbd, 0xa8, 0xe4, 0x35, 0x3f, 0xbe, 0x66, 0x45, 0xac, 0xde, 0x39, 0x3c, 0xcc, 0xaf, 0xb6, 0xd0,
+	0x93, 0x9b, 0xaa, 0x31, 0x2e, 0xe5, 0xb3, 0x37, 0x2b, 0xda, 0x98, 0x21, 0xbf, 0x96, 0xb8, 0xa6,
+	0xea, 0x8e, 0x79, 0x5c, 0xcb, 0x14, 0x57, 0xf3, 0xb8, 0x96, 0x2d, 0x59, 0x24, 0xeb, 0xf9, 0x57,
+	0x12, 0xc5, 0xba, 0xe0, 0xa1, 0x46, 0xb1, 0x2e, 0x7a, 0x60, 0x61, 0xac, 0x23, 0x68, 0x15, 0x55,
+	0x1c, 0xe8, 0xfb, 0xea, 0x52, 0x5d, 0x5b, 0x06, 0x99, 0x5b, 0x37, 0x2f, 0x94, 0x22, 0xb7, 0xb4,
+	0x1d, 0x8d, 0x9e, 0x4b, 0x7e, 0xd1, 0xa0, 0xce, 0xe5, 0xda, 0x72, 0x46, 0x9d, 0xcb, 0xf5, 0xb5,
+	0x07, 0xb3, 0xf0, 0x14, 0xee, 0xe5, 0xe4, 0x71, 0x64, 0x25, 0xc0, 0xaa, 0xa0, 0xba, 0x30, 0x3f,
+	0xb9, 0x76, 0x4d, 0x42, 0xc6, 0x6f, 0x60, 0x39, 0x93, 0x39, 0xd5, 0x25, 0x2e, 0xca, 0xe5, 0xea,
+	0x12, 0x17, 0xa6, 0x5d, 0xca, 0x7d, 0x7f, 0xe7, 0x1b, 0xba, 0xce, 0x77, 0x4e, 0xdb, 0xfd, 0x60,
+	0xb4, 0xcd, 0x3f, 0xbf, 0x0c, 0xc2, 0xe1, 0x36, 0xdf, 0xfd, 0x25, 0x7b, 0x5d, 0xd8, 0x1e, 0x06,
+	0x62, 0x3c, 0x39, 0x3d, 0xad, 0x31, 0xd2, 0x0f, 0xff, 0x17, 0x00, 0x00, 0xff, 0xff, 0xad, 0x41,
+	0x2d, 0xba, 0x57, 0x1d, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/conflicts.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/conflicts.pb.go
index 4181df05a7d02a5dff43f6ff81423c1bf63cb5f8..5c90c331b7e5ba62c2b0c6b234c9d90b2d84fb7c 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/conflicts.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/conflicts.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: conflicts.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -36,7 +36,7 @@ func (m *ListConflictFilesRequest) Reset()         { *m = ListConflictFilesReque
 func (m *ListConflictFilesRequest) String() string { return proto.CompactTextString(m) }
 func (*ListConflictFilesRequest) ProtoMessage()    {}
 func (*ListConflictFilesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conflicts_46d86b81eab9244c, []int{0}
+	return fileDescriptor_conflicts_cfde09b9517b3e8b, []int{0}
 }
 func (m *ListConflictFilesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListConflictFilesRequest.Unmarshal(m, b)
@@ -92,7 +92,7 @@ func (m *ConflictFileHeader) Reset()         { *m = ConflictFileHeader{} }
 func (m *ConflictFileHeader) String() string { return proto.CompactTextString(m) }
 func (*ConflictFileHeader) ProtoMessage()    {}
 func (*ConflictFileHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conflicts_46d86b81eab9244c, []int{1}
+	return fileDescriptor_conflicts_cfde09b9517b3e8b, []int{1}
 }
 func (m *ConflictFileHeader) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ConflictFileHeader.Unmarshal(m, b)
@@ -161,7 +161,7 @@ func (m *ConflictFile) Reset()         { *m = ConflictFile{} }
 func (m *ConflictFile) String() string { return proto.CompactTextString(m) }
 func (*ConflictFile) ProtoMessage()    {}
 func (*ConflictFile) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conflicts_46d86b81eab9244c, []int{2}
+	return fileDescriptor_conflicts_cfde09b9517b3e8b, []int{2}
 }
 func (m *ConflictFile) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ConflictFile.Unmarshal(m, b)
@@ -299,7 +299,7 @@ func (m *ListConflictFilesResponse) Reset()         { *m = ListConflictFilesResp
 func (m *ListConflictFilesResponse) String() string { return proto.CompactTextString(m) }
 func (*ListConflictFilesResponse) ProtoMessage()    {}
 func (*ListConflictFilesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conflicts_46d86b81eab9244c, []int{3}
+	return fileDescriptor_conflicts_cfde09b9517b3e8b, []int{3}
 }
 func (m *ListConflictFilesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListConflictFilesResponse.Unmarshal(m, b)
@@ -344,7 +344,7 @@ func (m *ResolveConflictsRequestHeader) Reset()         { *m = ResolveConflictsR
 func (m *ResolveConflictsRequestHeader) String() string { return proto.CompactTextString(m) }
 func (*ResolveConflictsRequestHeader) ProtoMessage()    {}
 func (*ResolveConflictsRequestHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conflicts_46d86b81eab9244c, []int{4}
+	return fileDescriptor_conflicts_cfde09b9517b3e8b, []int{4}
 }
 func (m *ResolveConflictsRequestHeader) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResolveConflictsRequestHeader.Unmarshal(m, b)
@@ -434,7 +434,7 @@ func (m *ResolveConflictsRequest) Reset()         { *m = ResolveConflictsRequest
 func (m *ResolveConflictsRequest) String() string { return proto.CompactTextString(m) }
 func (*ResolveConflictsRequest) ProtoMessage()    {}
 func (*ResolveConflictsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conflicts_46d86b81eab9244c, []int{5}
+	return fileDescriptor_conflicts_cfde09b9517b3e8b, []int{5}
 }
 func (m *ResolveConflictsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResolveConflictsRequest.Unmarshal(m, b)
@@ -572,7 +572,7 @@ func (m *ResolveConflictsResponse) Reset()         { *m = ResolveConflictsRespon
 func (m *ResolveConflictsResponse) String() string { return proto.CompactTextString(m) }
 func (*ResolveConflictsResponse) ProtoMessage()    {}
 func (*ResolveConflictsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_conflicts_46d86b81eab9244c, []int{6}
+	return fileDescriptor_conflicts_cfde09b9517b3e8b, []int{6}
 }
 func (m *ResolveConflictsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResolveConflictsResponse.Unmarshal(m, b)
@@ -775,44 +775,47 @@ var _ConflictsService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "conflicts.proto",
 }
 
-func init() { proto.RegisterFile("conflicts.proto", fileDescriptor_conflicts_46d86b81eab9244c) }
-
-var fileDescriptor_conflicts_46d86b81eab9244c = []byte{
-	// 575 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xd1, 0x6a, 0x13, 0x41,
-	0x14, 0x86, 0xbb, 0x6d, 0x93, 0x34, 0xa7, 0xdb, 0x34, 0x1d, 0x94, 0x6e, 0x03, 0xa1, 0xdb, 0xad,
-	0x85, 0xd5, 0x8b, 0x20, 0xd1, 0xfb, 0x42, 0x4a, 0x35, 0x88, 0x45, 0x19, 0xf1, 0x42, 0x10, 0x96,
-	0xed, 0xee, 0x69, 0x76, 0x64, 0xb3, 0x13, 0x67, 0x66, 0x0b, 0x79, 0x19, 0xf1, 0x41, 0x7c, 0x03,
-	0x1f, 0xc8, 0x5b, 0xc9, 0xcc, 0xee, 0x26, 0x6d, 0x92, 0x2a, 0x7a, 0xfb, 0x9f, 0x8f, 0x73, 0xfe,
-	0x33, 0xe7, 0x67, 0x60, 0x3f, 0xe2, 0xd9, 0x4d, 0xca, 0x22, 0x25, 0x7b, 0x13, 0xc1, 0x15, 0x27,
-	0xf5, 0x11, 0x53, 0x61, 0x3a, 0xed, 0xd8, 0x32, 0x09, 0x05, 0xc6, 0x46, 0xf5, 0xbe, 0x59, 0xe0,
-	0xbc, 0x65, 0x52, 0x5d, 0x14, 0xf4, 0x2b, 0x96, 0xa2, 0xa4, 0xf8, 0x35, 0x47, 0xa9, 0x48, 0x1f,
-	0x40, 0xe0, 0x84, 0x4b, 0xa6, 0xb8, 0x98, 0x3a, 0x96, 0x6b, 0xf9, 0xbb, 0x7d, 0xd2, 0x33, 0x7d,
-	0x7a, 0xb4, 0xaa, 0xd0, 0x05, 0x8a, 0x3c, 0x81, 0x16, 0xcf, 0x45, 0x10, 0xf1, 0xf1, 0x98, 0xa9,
-	0x80, 0xb3, 0xd8, 0xd9, 0x74, 0x2d, 0xbf, 0x49, 0x6d, 0x9e, 0x8b, 0x0b, 0x2d, 0xbe, 0x63, 0x31,
-	0xf1, 0xa1, 0xad, 0x12, 0x64, 0x77, 0xb8, 0x2d, 0xcd, 0xb5, 0xb4, 0x5e, 0x91, 0xde, 0x0f, 0x0b,
-	0xc8, 0xa2, 0xb9, 0x21, 0x86, 0x31, 0x8a, 0x7f, 0xb2, 0xd6, 0x05, 0x58, 0xb2, 0xd5, 0x8c, 0x2a,
-	0x4f, 0x5d, 0x00, 0xe3, 0x69, 0x12, 0xaa, 0x44, 0xbb, 0xb1, 0x69, 0x53, 0x2b, 0xef, 0x43, 0x95,
-	0x90, 0x23, 0xd8, 0x99, 0x2d, 0xa6, 0x8b, 0xdb, 0xba, 0xd8, 0xe0, 0xf9, 0x9d, 0xd2, 0x98, 0xc7,
-	0xe8, 0xd4, 0x5c, 0xcb, 0xaf, 0xe9, 0xd2, 0x15, 0x8f, 0xd1, 0x9b, 0x82, 0xbd, 0xe8, 0x9e, 0xbc,
-	0x84, 0x7a, 0xa2, 0x37, 0x28, 0x3c, 0x77, 0x4a, 0xcf, 0xcb, 0x3b, 0x0e, 0x37, 0x68, 0xc1, 0x92,
-	0x0e, 0x34, 0x22, 0x9e, 0x29, 0xcc, 0x94, 0xb6, 0x6d, 0x0f, 0x37, 0x68, 0x29, 0x0c, 0x0e, 0xe1,
-	0x71, 0x79, 0xea, 0xe0, 0x86, 0xa5, 0x18, 0x4c, 0xc2, 0x69, 0xca, 0xc3, 0xd8, 0x7b, 0x0d, 0x47,
-	0x2b, 0x2e, 0x2b, 0x27, 0x3c, 0x93, 0x48, 0x9e, 0x41, 0x6d, 0x06, 0x4b, 0xc7, 0x72, 0xb7, 0xfc,
-	0xdd, 0xfe, 0xa3, 0x55, 0x36, 0xa8, 0x41, 0xbc, 0x5f, 0x9b, 0xd0, 0xa5, 0x28, 0x79, 0x7a, 0x8b,
-	0x65, 0xb9, 0x8c, 0xc8, 0x7f, 0x5c, 0xe3, 0xef, 0x82, 0x72, 0x0e, 0x07, 0x2a, 0x14, 0x23, 0x54,
-	0xc1, 0xc2, 0x80, 0xad, 0xb5, 0x03, 0xda, 0x06, 0x9e, 0x2b, 0x2b, 0x93, 0xb6, 0xbd, 0x2a, 0x69,
-	0xe4, 0x14, 0xf6, 0x24, 0xcf, 0x45, 0x84, 0xc1, 0xb5, 0x08, 0xb3, 0x28, 0xd1, 0xa7, 0xb4, 0xa9,
-	0x6d, 0xc4, 0x81, 0xd6, 0x66, 0x50, 0xe1, 0xa7, 0x80, 0xea, 0x06, 0x32, 0x62, 0x01, 0x9d, 0x41,
-	0xab, 0x98, 0x36, 0x46, 0x29, 0xc3, 0x11, 0x3a, 0x0d, 0x4d, 0xed, 0x19, 0xf5, 0xca, 0x88, 0xc4,
-	0x85, 0xed, 0x5c, 0xa2, 0x70, 0x76, 0xf4, 0x3a, 0x76, 0xb9, 0xce, 0x47, 0x89, 0x82, 0xea, 0x8a,
-	0xf7, 0xdd, 0x82, 0xc3, 0x35, 0x2f, 0x4f, 0xce, 0xef, 0x25, 0xe9, 0x6c, 0xfe, 0x1c, 0x0f, 0x9c,
-	0x6a, 0x21, 0x54, 0xc7, 0x00, 0xfa, 0xbe, 0xc1, 0x17, 0xc9, 0xb3, 0x2a, 0x57, 0x4d, 0xad, 0xbd,
-	0x91, 0x3c, 0x1b, 0x9c, 0xc2, 0x89, 0x30, 0xbd, 0x82, 0xea, 0x33, 0x09, 0x84, 0xe9, 0x56, 0xa5,
-	0xec, 0x12, 0x9c, 0xe5, 0x81, 0x45, 0xc8, 0x9e, 0x42, 0x5b, 0x37, 0xc8, 0x15, 0xe3, 0x59, 0x80,
-	0x42, 0x70, 0x63, 0xb6, 0x49, 0xf7, 0xe7, 0xfa, 0xe5, 0x4c, 0xee, 0xff, 0xb4, 0xa0, 0x5d, 0x35,
-	0xf8, 0x80, 0xe2, 0x96, 0x45, 0x48, 0x3e, 0xc3, 0xc1, 0x52, 0x82, 0x89, 0x5b, 0xee, 0xb9, 0xee,
-	0xdb, 0xea, 0x9c, 0x3c, 0x40, 0x18, 0x67, 0xde, 0xc6, 0x73, 0x8b, 0x7c, 0x82, 0xf6, 0x7d, 0xe7,
-	0xe4, 0xf8, 0x0f, 0x8f, 0xd8, 0x71, 0xd7, 0x03, 0x65, 0x6b, 0xdf, 0xba, 0xae, 0xeb, 0xcf, 0xf5,
-	0xc5, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2c, 0xb1, 0x16, 0xeb, 0x85, 0x05, 0x00, 0x00,
+func init() { proto.RegisterFile("conflicts.proto", fileDescriptor_conflicts_cfde09b9517b3e8b) }
+
+var fileDescriptor_conflicts_cfde09b9517b3e8b = []byte{
+	// 622 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xc1, 0x4e, 0xdb, 0x4e,
+	0x10, 0xc6, 0x71, 0x80, 0x40, 0x06, 0x03, 0x61, 0xf5, 0xff, 0x0b, 0x13, 0x09, 0x61, 0x4c, 0x91,
+	0xdc, 0x4a, 0x04, 0x94, 0xf6, 0xd4, 0x0b, 0x52, 0x10, 0x2d, 0xaa, 0x8a, 0x5a, 0xb9, 0xea, 0xa1,
+	0x55, 0x25, 0xcb, 0xb1, 0x87, 0xc4, 0x95, 0xe3, 0x71, 0x77, 0xd7, 0x48, 0x79, 0x92, 0xbe, 0x41,
+	0xd5, 0x87, 0xe8, 0x1b, 0xf4, 0x6d, 0x7a, 0xe9, 0xb5, 0xca, 0xae, 0x6d, 0x02, 0x49, 0x68, 0xd5,
+	0xde, 0x92, 0x6f, 0x7e, 0x99, 0xfd, 0x66, 0xe7, 0xcb, 0xc2, 0x66, 0x48, 0xe9, 0x55, 0x12, 0x87,
+	0x52, 0xb4, 0x33, 0x4e, 0x92, 0x58, 0xbd, 0x1f, 0xcb, 0x20, 0x19, 0xb5, 0x4c, 0x31, 0x08, 0x38,
+	0x46, 0x5a, 0x75, 0xbe, 0x18, 0x60, 0xbd, 0x8c, 0x85, 0x3c, 0x2b, 0xe8, 0x67, 0x71, 0x82, 0xc2,
+	0xc3, 0x4f, 0x39, 0x0a, 0xc9, 0x3a, 0x00, 0x1c, 0x33, 0x12, 0xb1, 0x24, 0x3e, 0xb2, 0x0c, 0xdb,
+	0x70, 0xd7, 0x3a, 0xac, 0xad, 0xfb, 0xb4, 0xbd, 0xaa, 0xe2, 0x4d, 0x50, 0xec, 0x01, 0x6c, 0x50,
+	0xce, 0xfd, 0x90, 0x86, 0xc3, 0x58, 0xfa, 0x14, 0x47, 0x56, 0xcd, 0x36, 0xdc, 0x86, 0x67, 0x52,
+	0xce, 0xcf, 0x94, 0xf8, 0x2a, 0x8e, 0x98, 0x0b, 0x4d, 0x39, 0xc0, 0xf8, 0x16, 0xb7, 0xa8, 0xb8,
+	0x0d, 0xa5, 0x57, 0xe4, 0xd3, 0xfa, 0x8f, 0xcf, 0x6e, 0x6d, 0xb5, 0xe6, 0x7c, 0x33, 0x80, 0x4d,
+	0x9a, 0xbc, 0xc0, 0x20, 0x42, 0xfe, 0x57, 0x16, 0x77, 0x01, 0xa6, 0xec, 0x35, 0xc2, 0xca, 0xdb,
+	0x2e, 0x80, 0xf6, 0x96, 0x05, 0x72, 0xa0, 0x5c, 0x99, 0x5e, 0x43, 0x29, 0xaf, 0x03, 0x39, 0x60,
+	0x3b, 0xb0, 0x3a, 0x1e, 0x50, 0x15, 0x97, 0x54, 0x71, 0x85, 0xf2, 0x5b, 0xa5, 0x21, 0x45, 0x68,
+	0x2d, 0xdb, 0x86, 0xbb, 0xac, 0x4a, 0x97, 0x14, 0xa1, 0x33, 0x02, 0x73, 0xd2, 0x3d, 0x7b, 0x02,
+	0xf5, 0x81, 0x9a, 0xa0, 0xf0, 0xdc, 0x2a, 0x3d, 0x4f, 0xcf, 0x78, 0xb1, 0xe0, 0x15, 0x2c, 0x6b,
+	0xc1, 0x4a, 0x48, 0xa9, 0xc4, 0x54, 0x2a, 0xdb, 0xe6, 0xc5, 0x82, 0x57, 0x0a, 0xdd, 0x6d, 0xf8,
+	0xbf, 0x5c, 0xb9, 0x7f, 0x15, 0x27, 0xe8, 0x67, 0xc1, 0x28, 0xa1, 0x20, 0x72, 0x9e, 0xc3, 0xce,
+	0x8c, 0x0d, 0x8b, 0x8c, 0x52, 0x81, 0xec, 0x11, 0x2c, 0x8f, 0x61, 0x61, 0x19, 0xf6, 0xa2, 0xbb,
+	0xd6, 0xf9, 0x6f, 0x96, 0x0d, 0x4f, 0x23, 0xce, 0xcf, 0x1a, 0xec, 0x7a, 0x28, 0x28, 0xb9, 0xc6,
+	0xb2, 0x5c, 0x46, 0xe5, 0x1f, 0xb6, 0xf1, 0x67, 0x81, 0x39, 0x85, 0x2d, 0x19, 0xf0, 0x3e, 0x4a,
+	0x7f, 0xe2, 0x80, 0xc5, 0xb9, 0x07, 0x34, 0x35, 0x7c, 0xa3, 0xcc, 0x4c, 0xdc, 0xd2, 0xac, 0xc4,
+	0xb1, 0x03, 0x58, 0x17, 0x94, 0xf3, 0x10, 0xfd, 0x1e, 0x0f, 0xd2, 0x70, 0xa0, 0x56, 0x69, 0x7a,
+	0xa6, 0x16, 0xbb, 0x4a, 0x1b, 0x43, 0x85, 0x9f, 0x02, 0xaa, 0x6b, 0x48, 0x8b, 0x05, 0x74, 0x08,
+	0x1b, 0xc5, 0x69, 0x43, 0x14, 0x22, 0xe8, 0xa3, 0xb5, 0xa2, 0xa8, 0x75, 0xad, 0x5e, 0x6a, 0x91,
+	0xd9, 0xb0, 0x94, 0x0b, 0xe4, 0xd6, 0xaa, 0x1a, 0xc7, 0x2c, 0xc7, 0x79, 0x2b, 0x90, 0x7b, 0xaa,
+	0xe2, 0x7c, 0x35, 0x60, 0x7b, 0xce, 0xcd, 0xb3, 0xd3, 0x3b, 0x49, 0x3a, 0xbc, 0xb9, 0x8e, 0x7b,
+	0x56, 0x35, 0x11, 0xaa, 0x3d, 0x00, 0xb5, 0x5f, 0xff, 0xa3, 0xa0, 0xb4, 0xca, 0x55, 0x43, 0x69,
+	0x2f, 0x04, 0xa5, 0xc5, 0x5f, 0xd0, 0xe8, 0x1e, 0xc0, 0x3e, 0xd7, 0x3d, 0xfd, 0xea, 0x71, 0xf1,
+	0xb9, 0xee, 0x5a, 0xa5, 0xed, 0x1c, 0xac, 0xe9, 0x83, 0x8b, 0xb0, 0x3d, 0x84, 0xa6, 0x6a, 0x90,
+	0xcb, 0x98, 0x52, 0x1f, 0x39, 0x27, 0x6d, 0xba, 0xe1, 0x6d, 0xde, 0xe8, 0xe7, 0x63, 0xb9, 0xf3,
+	0xdd, 0x80, 0x66, 0xd5, 0xe0, 0x0d, 0xf2, 0xeb, 0x38, 0x44, 0xf6, 0x01, 0xb6, 0xa6, 0x92, 0xcc,
+	0xec, 0x72, 0xde, 0x79, 0xcf, 0x58, 0x6b, 0xff, 0x1e, 0x42, 0x3b, 0x73, 0x16, 0x4e, 0x0c, 0xf6,
+	0x0e, 0x9a, 0x77, 0x9d, 0xb3, 0xbd, 0xdf, 0x5c, 0x66, 0xcb, 0x9e, 0x0f, 0x94, 0xad, 0x5d, 0xa3,
+	0x7b, 0xf2, 0x7e, 0x8c, 0x25, 0x41, 0xaf, 0x1d, 0xd2, 0xf0, 0x58, 0x7f, 0x3c, 0x22, 0xde, 0x3f,
+	0xd6, 0x3f, 0x3e, 0x52, 0x6f, 0xf1, 0x71, 0x9f, 0x8a, 0xef, 0x59, 0xaf, 0x57, 0x57, 0xd2, 0xe3,
+	0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa1, 0x0c, 0xe9, 0xcc, 0xc7, 0x05, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go
index 489154d27986cb8d4bea63a59e964b5fe62e81f2..a1f8f283800a62a07879ec5cce8af9718a628209 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: diff.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -52,7 +52,7 @@ func (m *CommitDiffRequest) Reset()         { *m = CommitDiffRequest{} }
 func (m *CommitDiffRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitDiffRequest) ProtoMessage()    {}
 func (*CommitDiffRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{0}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{0}
 }
 func (m *CommitDiffRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitDiffRequest.Unmarshal(m, b)
@@ -200,7 +200,7 @@ func (m *CommitDiffResponse) Reset()         { *m = CommitDiffResponse{} }
 func (m *CommitDiffResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitDiffResponse) ProtoMessage()    {}
 func (*CommitDiffResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{1}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{1}
 }
 func (m *CommitDiffResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitDiffResponse.Unmarshal(m, b)
@@ -318,7 +318,7 @@ func (m *CommitDeltaRequest) Reset()         { *m = CommitDeltaRequest{} }
 func (m *CommitDeltaRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitDeltaRequest) ProtoMessage()    {}
 func (*CommitDeltaRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{2}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{2}
 }
 func (m *CommitDeltaRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitDeltaRequest.Unmarshal(m, b)
@@ -383,7 +383,7 @@ func (m *CommitDelta) Reset()         { *m = CommitDelta{} }
 func (m *CommitDelta) String() string { return proto.CompactTextString(m) }
 func (*CommitDelta) ProtoMessage()    {}
 func (*CommitDelta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{3}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{3}
 }
 func (m *CommitDelta) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitDelta.Unmarshal(m, b)
@@ -456,7 +456,7 @@ func (m *CommitDeltaResponse) Reset()         { *m = CommitDeltaResponse{} }
 func (m *CommitDeltaResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitDeltaResponse) ProtoMessage()    {}
 func (*CommitDeltaResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{4}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{4}
 }
 func (m *CommitDeltaResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitDeltaResponse.Unmarshal(m, b)
@@ -495,7 +495,7 @@ func (m *CommitPatchRequest) Reset()         { *m = CommitPatchRequest{} }
 func (m *CommitPatchRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitPatchRequest) ProtoMessage()    {}
 func (*CommitPatchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{5}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{5}
 }
 func (m *CommitPatchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitPatchRequest.Unmarshal(m, b)
@@ -540,7 +540,7 @@ func (m *CommitPatchResponse) Reset()         { *m = CommitPatchResponse{} }
 func (m *CommitPatchResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitPatchResponse) ProtoMessage()    {}
 func (*CommitPatchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{6}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{6}
 }
 func (m *CommitPatchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitPatchResponse.Unmarshal(m, b)
@@ -580,7 +580,7 @@ func (m *RawDiffRequest) Reset()         { *m = RawDiffRequest{} }
 func (m *RawDiffRequest) String() string { return proto.CompactTextString(m) }
 func (*RawDiffRequest) ProtoMessage()    {}
 func (*RawDiffRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{7}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{7}
 }
 func (m *RawDiffRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RawDiffRequest.Unmarshal(m, b)
@@ -632,7 +632,7 @@ func (m *RawDiffResponse) Reset()         { *m = RawDiffResponse{} }
 func (m *RawDiffResponse) String() string { return proto.CompactTextString(m) }
 func (*RawDiffResponse) ProtoMessage()    {}
 func (*RawDiffResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{8}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{8}
 }
 func (m *RawDiffResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RawDiffResponse.Unmarshal(m, b)
@@ -672,7 +672,7 @@ func (m *RawPatchRequest) Reset()         { *m = RawPatchRequest{} }
 func (m *RawPatchRequest) String() string { return proto.CompactTextString(m) }
 func (*RawPatchRequest) ProtoMessage()    {}
 func (*RawPatchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{9}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{9}
 }
 func (m *RawPatchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RawPatchRequest.Unmarshal(m, b)
@@ -724,7 +724,7 @@ func (m *RawPatchResponse) Reset()         { *m = RawPatchResponse{} }
 func (m *RawPatchResponse) String() string { return proto.CompactTextString(m) }
 func (*RawPatchResponse) ProtoMessage()    {}
 func (*RawPatchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{10}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{10}
 }
 func (m *RawPatchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RawPatchResponse.Unmarshal(m, b)
@@ -764,7 +764,7 @@ func (m *DiffStatsRequest) Reset()         { *m = DiffStatsRequest{} }
 func (m *DiffStatsRequest) String() string { return proto.CompactTextString(m) }
 func (*DiffStatsRequest) ProtoMessage()    {}
 func (*DiffStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{11}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{11}
 }
 func (m *DiffStatsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DiffStatsRequest.Unmarshal(m, b)
@@ -818,7 +818,7 @@ func (m *DiffStats) Reset()         { *m = DiffStats{} }
 func (m *DiffStats) String() string { return proto.CompactTextString(m) }
 func (*DiffStats) ProtoMessage()    {}
 func (*DiffStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{12}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{12}
 }
 func (m *DiffStats) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DiffStats.Unmarshal(m, b)
@@ -870,7 +870,7 @@ func (m *DiffStatsResponse) Reset()         { *m = DiffStatsResponse{} }
 func (m *DiffStatsResponse) String() string { return proto.CompactTextString(m) }
 func (*DiffStatsResponse) ProtoMessage()    {}
 func (*DiffStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_diff_068a9eeeafb93491, []int{13}
+	return fileDescriptor_diff_696f647dc4d0db76, []int{13}
 }
 func (m *DiffStatsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DiffStatsResponse.Unmarshal(m, b)
@@ -1317,62 +1317,65 @@ var _DiffService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "diff.proto",
 }
 
-func init() { proto.RegisterFile("diff.proto", fileDescriptor_diff_068a9eeeafb93491) }
-
-var fileDescriptor_diff_068a9eeeafb93491 = []byte{
-	// 864 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcb, 0x6e, 0x23, 0x45,
-	0x14, 0xa5, 0xe3, 0x47, 0xda, 0xd7, 0x1d, 0x27, 0xa9, 0xa0, 0x4c, 0xc7, 0xc3, 0xc2, 0x6a, 0xcd,
-	0xc3, 0x08, 0x29, 0x42, 0x61, 0xc3, 0x02, 0x21, 0x31, 0x13, 0x81, 0x32, 0x4a, 0xc4, 0xa8, 0x59,
-	0xb0, 0x60, 0xd1, 0xaa, 0xb8, 0xaa, 0xdd, 0x25, 0xba, 0xbb, 0x4c, 0x55, 0x11, 0x27, 0xbf, 0x01,
-	0x7c, 0x02, 0x12, 0x1b, 0xf6, 0xfc, 0x1a, 0x4b, 0x54, 0xb7, 0xfa, 0xe5, 0xc4, 0x9a, 0x4d, 0x58,
-	0x64, 0xe7, 0x7b, 0xce, 0xe9, 0x5b, 0xa7, 0xee, 0xa3, 0x12, 0x00, 0x26, 0xd2, 0xf4, 0x74, 0xa5,
-	0xa4, 0x91, 0x64, 0xb8, 0x14, 0x86, 0xe6, 0x77, 0xd3, 0x40, 0x67, 0x54, 0x71, 0xe6, 0xd0, 0xe8,
-	0xcf, 0x3e, 0x1c, 0xbe, 0x95, 0x45, 0x21, 0xcc, 0xb9, 0x48, 0xd3, 0x98, 0xff, 0xf2, 0x2b, 0xd7,
-	0x86, 0x9c, 0x01, 0x28, 0xbe, 0x92, 0x5a, 0x18, 0xa9, 0xee, 0x42, 0x6f, 0xe6, 0xcd, 0xc7, 0x67,
-	0xe4, 0xd4, 0x25, 0x38, 0x8d, 0x1b, 0x26, 0xee, 0xa8, 0xc8, 0x0b, 0x98, 0xe4, 0x3c, 0x35, 0xc9,
-	0x02, 0xb3, 0x25, 0x82, 0x85, 0x3b, 0x33, 0x6f, 0x3e, 0x8a, 0x03, 0x8b, 0xba, 0x23, 0x2e, 0x18,
-	0x79, 0x05, 0xfb, 0x4a, 0x2c, 0xb3, 0xae, 0xac, 0x87, 0xb2, 0x3d, 0x84, 0x1b, 0xdd, 0x97, 0x10,
-	0x8a, 0x65, 0x29, 0x15, 0x4f, 0xd6, 0x99, 0x30, 0x5c, 0xaf, 0xe8, 0x82, 0x27, 0x8b, 0x8c, 0x96,
-	0x4b, 0x1e, 0xf6, 0x67, 0xde, 0xdc, 0x8f, 0x8f, 0x1d, 0xff, 0x63, 0x43, 0xbf, 0x45, 0x96, 0x7c,
-	0x0c, 0x83, 0x15, 0x35, 0x99, 0x0e, 0x07, 0xb3, 0xde, 0x3c, 0x88, 0x5d, 0x40, 0x5e, 0xc2, 0x64,
-	0x21, 0xf3, 0x9c, 0xae, 0x34, 0x4f, 0x6c, 0x51, 0x74, 0x38, 0xc4, 0x2c, 0x7b, 0x35, 0x6a, 0xaf,
-	0x8f, 0x32, 0x5e, 0xa6, 0x52, 0x2d, 0x78, 0x92, 0x8b, 0x42, 0x18, 0x1d, 0xee, 0x3a, 0x59, 0x85,
-	0x5e, 0x22, 0x48, 0x9e, 0xc3, 0xa8, 0xa0, 0xb7, 0x49, 0x2a, 0x72, 0xae, 0x43, 0x7f, 0xe6, 0xcd,
-	0x07, 0xb1, 0x5f, 0xd0, 0xdb, 0x6f, 0x6d, 0x5c, 0x93, 0xb9, 0x28, 0xb9, 0x0e, 0x47, 0x0d, 0x79,
-	0x69, 0xe3, 0x9a, 0xbc, 0xbe, 0x33, 0x5c, 0x87, 0xd0, 0x90, 0x6f, 0x6c, 0x6c, 0x8b, 0x63, 0xc9,
-	0x15, 0x35, 0x8b, 0xac, 0x92, 0x4c, 0x50, 0xb2, 0x57, 0xd0, 0xdb, 0xf7, 0x16, 0x75, 0xba, 0x17,
-	0x30, 0xd1, 0x34, 0xe5, 0x49, 0xeb, 0x61, 0x8c, 0xb2, 0xc0, 0xa2, 0x57, 0xb5, 0x8f, 0xae, 0xca,
-	0x99, 0x09, 0x36, 0x54, 0xce, 0x50, 0x57, 0xe5, 0x8e, 0xdc, 0xdb, 0x50, 0xe1, 0x89, 0xd1, 0xbf,
-	0x3b, 0x40, 0xba, 0x63, 0xa2, 0x57, 0xb2, 0xd4, 0xdc, 0xde, 0x26, 0x55, 0xb2, 0xb0, 0x8e, 0x33,
-	0x1c, 0x93, 0x20, 0xf6, 0x2d, 0xf0, 0x9e, 0x9a, 0x8c, 0x3c, 0x83, 0x5d, 0x23, 0x1d, 0xb5, 0x83,
-	0xd4, 0xd0, 0xc8, 0x9a, 0xc0, 0xaf, 0x9a, 0xde, 0x0f, 0x6d, 0x78, 0xc1, 0xc8, 0x11, 0x0c, 0x8c,
-	0xb4, 0x70, 0x1f, 0xe1, 0xbe, 0x91, 0x17, 0x8c, 0x9c, 0x80, 0x2f, 0x73, 0x96, 0x14, 0x92, 0xf1,
-	0x70, 0x80, 0xd6, 0x76, 0x65, 0xce, 0xae, 0x24, 0xe3, 0x96, 0x2a, 0xf9, 0xda, 0x51, 0x43, 0x47,
-	0x95, 0x7c, 0x8d, 0xd4, 0x31, 0x0c, 0xaf, 0x45, 0x49, 0xd5, 0x5d, 0xd5, 0xc0, 0x2a, 0xb2, 0xd7,
-	0x55, 0x74, 0x5d, 0x95, 0x98, 0x51, 0x43, 0xb1, 0x43, 0x41, 0x1c, 0x28, 0xba, 0xc6, 0x0a, 0x9f,
-	0x53, 0x43, 0xc9, 0x0c, 0x02, 0x5e, 0xb2, 0x44, 0xa6, 0x4e, 0x88, 0x8d, 0xf2, 0x63, 0xe0, 0x25,
-	0xfb, 0x3e, 0x45, 0x15, 0x79, 0x0d, 0xfb, 0xf2, 0x86, 0xab, 0x34, 0x97, 0xeb, 0xa4, 0xa0, 0xea,
-	0x67, 0xae, 0xb0, 0x07, 0x7e, 0x3c, 0xa9, 0xe1, 0x2b, 0x44, 0xc9, 0x27, 0x30, 0xaa, 0x47, 0x8c,
-	0x61, 0x03, 0xfc, 0xb8, 0x05, 0x6c, 0x01, 0x8d, 0x94, 0x49, 0x4e, 0xd5, 0x92, 0x63, 0xe1, 0xfd,
-	0xd8, 0x37, 0x52, 0x5e, 0xda, 0xf8, 0x5d, 0xdf, 0xf7, 0x0f, 0x46, 0xd1, 0xdf, 0x5e, 0x53, 0x7a,
-	0x9e, 0x1b, 0xfa, 0x74, 0x56, 0xb4, 0x59, 0xb4, 0x7e, 0x67, 0xd1, 0xa2, 0xbf, 0x3c, 0x18, 0x77,
-	0xec, 0x3e, 0xdd, 0x11, 0x89, 0xde, 0xc0, 0xd1, 0x46, 0x5d, 0xab, 0x99, 0xfe, 0x0c, 0x86, 0xcc,
-	0x02, 0x3a, 0xf4, 0x66, 0xbd, 0xf9, 0xf8, 0xec, 0xa8, 0x2e, 0x6a, 0x57, 0x5c, 0x49, 0x22, 0x56,
-	0xf7, 0x06, 0xa7, 0xe2, 0x31, 0xbd, 0x99, 0x82, 0xaf, 0xf8, 0x8d, 0xd0, 0x42, 0x96, 0x55, 0x2d,
-	0x9a, 0x38, 0xfa, 0xb4, 0x76, 0x5a, 0x9d, 0x52, 0x39, 0x25, 0xd0, 0xc7, 0x09, 0x76, 0x55, 0xc5,
-	0xdf, 0xd1, 0x6f, 0x1e, 0x4c, 0x62, 0xba, 0x7e, 0x52, 0x8f, 0x79, 0xf4, 0x12, 0xf6, 0x1b, 0x4f,
-	0x1f, 0xf0, 0xfe, 0xbb, 0x87, 0xba, 0x47, 0x97, 0xf2, 0xff, 0x35, 0xff, 0x0a, 0x0e, 0x5a, 0x53,
-	0x1f, 0x70, 0xff, 0x87, 0x07, 0x07, 0xf6, 0x8a, 0x3f, 0x18, 0x6a, 0xf4, 0xd3, 0xb1, 0xff, 0x13,
-	0x8c, 0x1a, 0x57, 0xd6, 0x77, 0x67, 0x0f, 0xf1, 0xb7, 0x7d, 0xa0, 0x28, 0x63, 0xc2, 0x08, 0x59,
-	0x6a, 0x3c, 0x69, 0x10, 0xb7, 0x80, 0x65, 0x19, 0xcf, 0xb9, 0x63, 0x7b, 0x8e, 0x6d, 0x80, 0xe8,
-	0x2b, 0x38, 0xec, 0x5c, 0xb9, 0x2a, 0xce, 0x6b, 0x18, 0x68, 0x0b, 0x54, 0xfb, 0x73, 0x58, 0x5f,
-	0xb7, 0x55, 0x3a, 0xfe, 0xec, 0x9f, 0x1e, 0x8c, 0x11, 0xe4, 0xea, 0x46, 0x2c, 0x38, 0xf9, 0x0e,
-	0xa0, 0xfd, 0x1b, 0x43, 0x4e, 0xee, 0xed, 0x5d, 0x3b, 0xd1, 0xd3, 0xe9, 0x36, 0xca, 0x9d, 0x1e,
-	0x7d, 0xf4, 0xb9, 0x47, 0xde, 0x6d, 0x3e, 0x41, 0xd3, 0x6d, 0x1b, 0x5c, 0xa5, 0x7a, 0xbe, 0x95,
-	0xdb, 0x96, 0xcb, 0xbd, 0xfb, 0xf7, 0x72, 0x75, 0x67, 0xf5, 0x7e, 0xae, 0x8d, 0x91, 0xc1, 0x5c,
-	0x5f, 0xc3, 0x6e, 0xb5, 0x07, 0xe4, 0xb8, 0x19, 0x82, 0x8d, 0x65, 0x9d, 0x3e, 0x7b, 0x80, 0x77,
-	0xbe, 0xff, 0x06, 0xfc, 0x7a, 0x14, 0x49, 0x57, 0xb8, 0xe1, 0x22, 0x7c, 0x48, 0x74, 0x52, 0x9c,
-	0x77, 0xc7, 0x21, 0x7c, 0xd8, 0x9a, 0x2a, 0xc9, 0xc9, 0x16, 0xa6, 0xcd, 0x72, 0x3d, 0xc4, 0x7f,
-	0x1e, 0xbf, 0xf8, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xbb, 0xf5, 0x8b, 0xe3, 0x60, 0x0a, 0x00, 0x00,
+func init() { proto.RegisterFile("diff.proto", fileDescriptor_diff_696f647dc4d0db76) }
+
+var fileDescriptor_diff_696f647dc4d0db76 = []byte{
+	// 909 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcf, 0x6f, 0xe3, 0x44,
+	0x14, 0xc6, 0x4d, 0xe2, 0x3a, 0x2f, 0x6e, 0xda, 0x4e, 0x51, 0xd7, 0xcd, 0x72, 0x88, 0xa2, 0xfd,
+	0x11, 0x84, 0xb6, 0x5d, 0x95, 0x0b, 0x42, 0x08, 0x89, 0x6e, 0x05, 0xea, 0xaa, 0x15, 0x2b, 0x73,
+	0x40, 0x82, 0x83, 0x35, 0xc9, 0x8c, 0x93, 0x11, 0xb6, 0x27, 0xcc, 0x0c, 0x4d, 0xfb, 0x97, 0x20,
+	0x01, 0x77, 0x2e, 0x1c, 0x91, 0xf8, 0xbf, 0x38, 0x71, 0x44, 0xf3, 0xc6, 0x76, 0x9c, 0x36, 0xda,
+	0xcb, 0x6a, 0xa5, 0xde, 0x3c, 0xdf, 0xf7, 0xf9, 0xcd, 0xfb, 0xf1, 0x3d, 0x27, 0x00, 0x4c, 0xa4,
+	0xe9, 0xf1, 0x42, 0x49, 0x23, 0x89, 0x3f, 0x13, 0x86, 0x66, 0xb7, 0x83, 0x50, 0xcf, 0xa9, 0xe2,
+	0xcc, 0xa1, 0xa3, 0xbf, 0xda, 0xb0, 0xff, 0x4a, 0xe6, 0xb9, 0x30, 0xe7, 0x22, 0x4d, 0x63, 0xfe,
+	0xf3, 0x2f, 0x5c, 0x1b, 0x72, 0x0a, 0xa0, 0xf8, 0x42, 0x6a, 0x61, 0xa4, 0xba, 0x8d, 0xbc, 0xa1,
+	0x37, 0xee, 0x9d, 0x92, 0x63, 0x17, 0xe0, 0x38, 0xae, 0x99, 0xb8, 0xa1, 0x22, 0x4f, 0xa0, 0x9f,
+	0xf1, 0xd4, 0x24, 0x53, 0x8c, 0x96, 0x08, 0x16, 0x6d, 0x0d, 0xbd, 0x71, 0x37, 0x0e, 0x2d, 0xea,
+	0xae, 0xb8, 0x60, 0xe4, 0x19, 0xec, 0x2a, 0x31, 0x9b, 0x37, 0x65, 0x2d, 0x94, 0xed, 0x20, 0x5c,
+	0xeb, 0x3e, 0x83, 0x48, 0xcc, 0x0a, 0xa9, 0x78, 0xb2, 0x9c, 0x0b, 0xc3, 0xf5, 0x82, 0x4e, 0x79,
+	0x32, 0x9d, 0xd3, 0x62, 0xc6, 0xa3, 0xf6, 0xd0, 0x1b, 0x07, 0xf1, 0xa1, 0xe3, 0xbf, 0xaf, 0xe9,
+	0x57, 0xc8, 0x92, 0x0f, 0xa1, 0xb3, 0xa0, 0x66, 0xae, 0xa3, 0xce, 0xb0, 0x35, 0x0e, 0x63, 0x77,
+	0x20, 0x4f, 0xa1, 0x3f, 0x95, 0x59, 0x46, 0x17, 0x9a, 0x27, 0xb6, 0x29, 0x3a, 0xf2, 0x31, 0xca,
+	0x4e, 0x85, 0xda, 0xf2, 0x51, 0xc6, 0x8b, 0x54, 0xaa, 0x29, 0x4f, 0x32, 0x91, 0x0b, 0xa3, 0xa3,
+	0x6d, 0x27, 0x2b, 0xd1, 0x4b, 0x04, 0xc9, 0x63, 0xe8, 0xe6, 0xf4, 0x26, 0x49, 0x45, 0xc6, 0x75,
+	0x14, 0x0c, 0xbd, 0x71, 0x27, 0x0e, 0x72, 0x7a, 0xf3, 0xb5, 0x3d, 0x57, 0x64, 0x26, 0x0a, 0xae,
+	0xa3, 0x6e, 0x4d, 0x5e, 0xda, 0x73, 0x45, 0x4e, 0x6e, 0x0d, 0xd7, 0x11, 0xd4, 0xe4, 0x99, 0x3d,
+	0xdb, 0xe6, 0x58, 0x72, 0x41, 0xcd, 0x74, 0x5e, 0x4a, 0xfa, 0x28, 0xd9, 0xc9, 0xe9, 0xcd, 0x1b,
+	0x8b, 0x3a, 0xdd, 0x13, 0xe8, 0x6b, 0x9a, 0xf2, 0x64, 0x95, 0x43, 0x0f, 0x65, 0xa1, 0x45, 0xaf,
+	0xaa, 0x3c, 0x9a, 0x2a, 0x97, 0x4c, 0xb8, 0xa6, 0x72, 0x09, 0x35, 0x55, 0xee, 0xca, 0x9d, 0x35,
+	0x15, 0xde, 0xf8, 0xb9, 0xff, 0xef, 0xaf, 0xe3, 0xad, 0x60, 0x6b, 0xf4, 0xdf, 0x16, 0x90, 0xa6,
+	0x5d, 0xf4, 0x42, 0x16, 0x9a, 0xdb, 0xaa, 0x52, 0x25, 0x73, 0x9b, 0xf9, 0x1c, 0xed, 0x12, 0xc6,
+	0x81, 0x05, 0xde, 0x50, 0x33, 0x27, 0x8f, 0x60, 0xdb, 0x48, 0x47, 0x6d, 0x21, 0xe5, 0x1b, 0x59,
+	0x11, 0xf8, 0x56, 0xed, 0x01, 0xdf, 0x1e, 0x2f, 0x18, 0x39, 0x80, 0x8e, 0x91, 0x16, 0x6e, 0x23,
+	0xdc, 0x36, 0xf2, 0x82, 0x91, 0x23, 0x08, 0x64, 0xc6, 0x92, 0x5c, 0x32, 0x1e, 0x75, 0x30, 0xc5,
+	0x6d, 0x99, 0xb1, 0x2b, 0xc9, 0xb8, 0xa5, 0x0a, 0xbe, 0x74, 0x94, 0xef, 0xa8, 0x82, 0x2f, 0x91,
+	0x3a, 0x04, 0x7f, 0x22, 0x0a, 0xaa, 0x6e, 0xcb, 0x41, 0x96, 0x27, 0x5b, 0xb6, 0xa2, 0xcb, 0xb2,
+	0xd5, 0x8c, 0x1a, 0x8a, 0x93, 0x0a, 0xe3, 0x50, 0xd1, 0x25, 0x76, 0xfa, 0x9c, 0x1a, 0x4a, 0x86,
+	0x10, 0xf2, 0x82, 0x25, 0x32, 0x75, 0x42, 0x1c, 0x58, 0x10, 0x03, 0x2f, 0xd8, 0xb7, 0x29, 0xaa,
+	0xc8, 0x73, 0xd8, 0x95, 0xd7, 0x5c, 0xa5, 0x99, 0x5c, 0x26, 0x39, 0x55, 0x3f, 0x71, 0x85, 0xb3,
+	0x08, 0xe2, 0x7e, 0x05, 0x5f, 0x21, 0x4a, 0x3e, 0x82, 0x6e, 0x65, 0x35, 0x86, 0x83, 0x08, 0xe2,
+	0x15, 0x60, 0x1b, 0x68, 0xa4, 0x4c, 0x32, 0xaa, 0x66, 0x1c, 0x07, 0x10, 0xc4, 0x81, 0x91, 0xf2,
+	0xd2, 0x9e, 0x5f, 0xb7, 0x83, 0x60, 0xaf, 0x3b, 0xfa, 0xdb, 0xab, 0x5b, 0xcf, 0x33, 0x43, 0x1f,
+	0xce, 0xaa, 0xd6, 0x0b, 0xd7, 0x6e, 0x2c, 0x5c, 0xed, 0x98, 0x3f, 0x3d, 0xe8, 0x35, 0xd2, 0x7e,
+	0xb8, 0x56, 0x19, 0x9d, 0xc1, 0xc1, 0x5a, 0x7f, 0x4b, 0x6f, 0x7f, 0x02, 0x3e, 0xb3, 0x80, 0x8e,
+	0xbc, 0x61, 0x6b, 0xdc, 0x3b, 0x3d, 0xa8, 0x9a, 0xdb, 0x14, 0x97, 0x92, 0x51, 0x56, 0xcd, 0x08,
+	0xdd, 0xf1, 0x2e, 0x33, 0x1a, 0x40, 0xa0, 0xf8, 0xb5, 0xd0, 0x42, 0x16, 0x65, 0x2f, 0xea, 0x73,
+	0xdd, 0xdb, 0x8f, 0xab, 0x8c, 0xcb, 0xdb, 0xca, 0x8c, 0x09, 0xb4, 0xd1, 0xd1, 0xae, 0xbb, 0xf8,
+	0x3c, 0xfa, 0xcd, 0x83, 0x7e, 0x4c, 0x97, 0x0f, 0xea, 0x23, 0x5f, 0xd7, 0xf1, 0x14, 0x76, 0xeb,
+	0xdc, 0xde, 0x52, 0xc3, 0xef, 0x1e, 0xea, 0xde, 0xb9, 0xb5, 0xef, 0xa7, 0x88, 0x67, 0xb0, 0xb7,
+	0x4a, 0xee, 0x2d, 0x55, 0xfc, 0xe1, 0xc1, 0x9e, 0x2d, 0xf5, 0x3b, 0x43, 0x8d, 0x7e, 0x78, 0x65,
+	0xfc, 0x08, 0xdd, 0x3a, 0x3b, 0x9b, 0x7f, 0x63, 0x4f, 0xf1, 0xd9, 0x7e, 0xc8, 0x28, 0x63, 0xc2,
+	0x08, 0x59, 0x68, 0xbc, 0xb1, 0x13, 0xaf, 0x00, 0xcb, 0x32, 0x9e, 0x71, 0xc7, 0xb6, 0x1c, 0x5b,
+	0x03, 0xa3, 0x2f, 0x60, 0xbf, 0x51, 0x7a, 0xd9, 0xa4, 0xe7, 0xd0, 0xd1, 0x16, 0x28, 0xf7, 0x6b,
+	0xbf, 0x2a, 0x7b, 0xa5, 0x74, 0xfc, 0xe9, 0x3f, 0x2d, 0xe8, 0x21, 0xc8, 0xd5, 0xb5, 0x98, 0x72,
+	0xf2, 0x0d, 0xc0, 0xea, 0xb7, 0x88, 0x1c, 0xdd, 0xd9, 0xcb, 0x95, 0xd3, 0x07, 0x83, 0x4d, 0x94,
+	0xbb, 0x7d, 0xf4, 0xc1, 0x4b, 0x8f, 0xbc, 0x5e, 0xff, 0x44, 0x0d, 0x36, 0x6d, 0x78, 0x19, 0xea,
+	0xf1, 0x46, 0x6e, 0x53, 0x2c, 0xf7, 0xfb, 0x70, 0x27, 0x56, 0xd3, 0xbb, 0x77, 0x63, 0xad, 0x59,
+	0x07, 0x63, 0x7d, 0x09, 0xdb, 0xe5, 0x5e, 0x90, 0xc3, 0xda, 0x0c, 0x6b, 0x4b, 0x3c, 0x78, 0x74,
+	0x0f, 0x6f, 0xbc, 0xff, 0x15, 0x04, 0x95, 0x25, 0x49, 0x53, 0xb8, 0x96, 0x45, 0x74, 0x9f, 0x68,
+	0x84, 0x38, 0x6f, 0xda, 0x21, 0xba, 0x3f, 0x9a, 0x32, 0xc8, 0xd1, 0x06, 0x66, 0x15, 0xe5, 0xec,
+	0xe5, 0x0f, 0x96, 0xcf, 0xe8, 0xe4, 0x78, 0x2a, 0xf3, 0x13, 0xf7, 0xf8, 0x42, 0xaa, 0xd9, 0x89,
+	0x7b, 0xeb, 0x05, 0xfe, 0x17, 0x3d, 0x99, 0xc9, 0xf2, 0xbc, 0x98, 0x4c, 0x7c, 0x84, 0x3e, 0xfd,
+	0x3f, 0x00, 0x00, 0xff, 0xff, 0x3f, 0xbe, 0x4d, 0xc2, 0xc2, 0x0a, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/go.mod b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/go.mod
new file mode 100644
index 0000000000000000000000000000000000000000..4d26a5c3dc3aeec1e74745652a14df5d349440b0
--- /dev/null
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/go.mod
@@ -0,0 +1,9 @@
+module gitlab.com/gitlab-org/gitaly-proto/go/gitalypb
+
+go 1.12
+
+require (
+	github.com/golang/protobuf v1.3.1
+	golang.org/x/net v0.0.0-20190313220215-9f648a60d977
+	google.golang.org/grpc v1.19.0
+)
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/go.sum b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/go.sum
new file mode 100644
index 0000000000000000000000000000000000000000..e3221426dca1a51a214943b79cda7ce1bc5f90fd
--- /dev/null
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/go.sum
@@ -0,0 +1,26 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190313220215-9f648a60d977 h1:actzWV6iWn3GLqN8dZjzsB+CLt+gaV2+wsxroxiQI8I=
+golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8 h1:Nw54tB0rB7hY/N0NQvRW8DG4Yk3Q6T9cu9RcFQDu1tc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/grpc v1.19.0 h1:cfg4PD8YEdSFnm7qLV4++93WcmhH2nIUhMjhdCvl3j8=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/namespace.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/namespace.pb.go
index a7e4f9aab8ef564672af6106df954bdc14cd6607..e8a3102991b2db2031a2a61b0f30fb9060eab42b 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/namespace.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/namespace.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: namespace.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -35,7 +35,7 @@ func (m *AddNamespaceRequest) Reset()         { *m = AddNamespaceRequest{} }
 func (m *AddNamespaceRequest) String() string { return proto.CompactTextString(m) }
 func (*AddNamespaceRequest) ProtoMessage()    {}
 func (*AddNamespaceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_namespace_01eaf6181e9c17a0, []int{0}
+	return fileDescriptor_namespace_43c8213dcd148a76, []int{0}
 }
 func (m *AddNamespaceRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AddNamespaceRequest.Unmarshal(m, b)
@@ -81,7 +81,7 @@ func (m *RemoveNamespaceRequest) Reset()         { *m = RemoveNamespaceRequest{}
 func (m *RemoveNamespaceRequest) String() string { return proto.CompactTextString(m) }
 func (*RemoveNamespaceRequest) ProtoMessage()    {}
 func (*RemoveNamespaceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_namespace_01eaf6181e9c17a0, []int{1}
+	return fileDescriptor_namespace_43c8213dcd148a76, []int{1}
 }
 func (m *RemoveNamespaceRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RemoveNamespaceRequest.Unmarshal(m, b)
@@ -128,7 +128,7 @@ func (m *RenameNamespaceRequest) Reset()         { *m = RenameNamespaceRequest{}
 func (m *RenameNamespaceRequest) String() string { return proto.CompactTextString(m) }
 func (*RenameNamespaceRequest) ProtoMessage()    {}
 func (*RenameNamespaceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_namespace_01eaf6181e9c17a0, []int{2}
+	return fileDescriptor_namespace_43c8213dcd148a76, []int{2}
 }
 func (m *RenameNamespaceRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RenameNamespaceRequest.Unmarshal(m, b)
@@ -181,7 +181,7 @@ func (m *NamespaceExistsRequest) Reset()         { *m = NamespaceExistsRequest{}
 func (m *NamespaceExistsRequest) String() string { return proto.CompactTextString(m) }
 func (*NamespaceExistsRequest) ProtoMessage()    {}
 func (*NamespaceExistsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_namespace_01eaf6181e9c17a0, []int{3}
+	return fileDescriptor_namespace_43c8213dcd148a76, []int{3}
 }
 func (m *NamespaceExistsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_NamespaceExistsRequest.Unmarshal(m, b)
@@ -226,7 +226,7 @@ func (m *NamespaceExistsResponse) Reset()         { *m = NamespaceExistsResponse
 func (m *NamespaceExistsResponse) String() string { return proto.CompactTextString(m) }
 func (*NamespaceExistsResponse) ProtoMessage()    {}
 func (*NamespaceExistsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_namespace_01eaf6181e9c17a0, []int{4}
+	return fileDescriptor_namespace_43c8213dcd148a76, []int{4}
 }
 func (m *NamespaceExistsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_NamespaceExistsResponse.Unmarshal(m, b)
@@ -263,7 +263,7 @@ func (m *AddNamespaceResponse) Reset()         { *m = AddNamespaceResponse{} }
 func (m *AddNamespaceResponse) String() string { return proto.CompactTextString(m) }
 func (*AddNamespaceResponse) ProtoMessage()    {}
 func (*AddNamespaceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_namespace_01eaf6181e9c17a0, []int{5}
+	return fileDescriptor_namespace_43c8213dcd148a76, []int{5}
 }
 func (m *AddNamespaceResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AddNamespaceResponse.Unmarshal(m, b)
@@ -293,7 +293,7 @@ func (m *RemoveNamespaceResponse) Reset()         { *m = RemoveNamespaceResponse
 func (m *RemoveNamespaceResponse) String() string { return proto.CompactTextString(m) }
 func (*RemoveNamespaceResponse) ProtoMessage()    {}
 func (*RemoveNamespaceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_namespace_01eaf6181e9c17a0, []int{6}
+	return fileDescriptor_namespace_43c8213dcd148a76, []int{6}
 }
 func (m *RemoveNamespaceResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RemoveNamespaceResponse.Unmarshal(m, b)
@@ -323,7 +323,7 @@ func (m *RenameNamespaceResponse) Reset()         { *m = RenameNamespaceResponse
 func (m *RenameNamespaceResponse) String() string { return proto.CompactTextString(m) }
 func (*RenameNamespaceResponse) ProtoMessage()    {}
 func (*RenameNamespaceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_namespace_01eaf6181e9c17a0, []int{7}
+	return fileDescriptor_namespace_43c8213dcd148a76, []int{7}
 }
 func (m *RenameNamespaceResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RenameNamespaceResponse.Unmarshal(m, b)
@@ -525,27 +525,30 @@ var _NamespaceService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "namespace.proto",
 }
 
-func init() { proto.RegisterFile("namespace.proto", fileDescriptor_namespace_01eaf6181e9c17a0) }
-
-var fileDescriptor_namespace_01eaf6181e9c17a0 = []byte{
-	// 291 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xcf, 0x4b, 0xcc, 0x4d,
-	0x2d, 0x2e, 0x48, 0x4c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c,
-	0x49, 0xcc, 0xa9, 0x54, 0xf2, 0xe1, 0x12, 0x76, 0x4c, 0x49, 0xf1, 0x83, 0xc9, 0x06, 0xa5, 0x16,
-	0x96, 0xa6, 0x16, 0x97, 0x08, 0x29, 0x72, 0xf1, 0x14, 0x97, 0xe4, 0x17, 0x25, 0xa6, 0xa7, 0xc6,
-	0x83, 0x74, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x06, 0x71, 0x43, 0xc5, 0x40, 0xca, 0x85, 0x84,
-	0xb8, 0x58, 0xc0, 0x52, 0x4c, 0x60, 0x29, 0x30, 0x5b, 0xc9, 0x9f, 0x4b, 0x2c, 0x28, 0x35, 0x37,
-	0xbf, 0x2c, 0x95, 0x5a, 0x06, 0xc6, 0x83, 0x0c, 0x04, 0xb1, 0xc8, 0x34, 0x30, 0xad, 0x28, 0x3f,
-	0x17, 0x66, 0x20, 0x88, 0x2d, 0xc4, 0xc7, 0xc5, 0x54, 0x92, 0x2f, 0xc1, 0x0c, 0x16, 0x61, 0x2a,
-	0xc9, 0x07, 0xb9, 0x18, 0x6e, 0xb4, 0x6b, 0x45, 0x66, 0x71, 0x49, 0x31, 0x85, 0x2e, 0x36, 0xe4,
-	0x12, 0xc7, 0x30, 0xb0, 0xb8, 0x20, 0x3f, 0xaf, 0x38, 0x55, 0x48, 0x8c, 0x8b, 0x2d, 0x15, 0x2c,
-	0x02, 0x36, 0x8b, 0x23, 0x08, 0xca, 0x53, 0x12, 0xe3, 0x12, 0x41, 0x8d, 0x03, 0x88, 0x7a, 0x25,
-	0x49, 0x2e, 0x71, 0x8c, 0xd0, 0x44, 0x96, 0x42, 0x0b, 0x17, 0x88, 0x94, 0xd1, 0x43, 0x26, 0x2e,
-	0x01, 0xb8, 0x68, 0x70, 0x6a, 0x51, 0x59, 0x66, 0x72, 0xaa, 0x90, 0x37, 0x17, 0x0f, 0xb2, 0x15,
-	0x42, 0xd2, 0x7a, 0x90, 0xf8, 0xd7, 0xc3, 0x12, 0xf9, 0x52, 0x32, 0xd8, 0x25, 0xa1, 0x56, 0x33,
-	0x08, 0x85, 0x70, 0xf1, 0xa3, 0xb9, 0x4b, 0x48, 0x0e, 0xa6, 0x05, 0x7b, 0xf4, 0x4b, 0xc9, 0xe3,
-	0x94, 0x47, 0x35, 0x15, 0xc5, 0x4b, 0xc8, 0xa6, 0x62, 0x4b, 0x03, 0xc8, 0xa6, 0x62, 0x0d, 0x0b,
-	0x88, 0xa9, 0x68, 0xd1, 0x81, 0x30, 0x15, 0x7b, 0xc4, 0x23, 0x4c, 0xc5, 0x11, 0x8f, 0x4a, 0x0c,
-	0x49, 0x6c, 0xe0, 0x4c, 0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x36, 0x4b, 0x73, 0x57,
-	0x03, 0x00, 0x00,
+func init() { proto.RegisterFile("namespace.proto", fileDescriptor_namespace_43c8213dcd148a76) }
+
+var fileDescriptor_namespace_43c8213dcd148a76 = []byte{
+	// 341 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x93, 0xcb, 0x4e, 0x02, 0x31,
+	0x14, 0x86, 0xa1, 0x9a, 0x09, 0x1e, 0x89, 0x98, 0x6a, 0x00, 0xd1, 0x78, 0xe9, 0x8a, 0x0d, 0x83,
+	0x97, 0x9d, 0x3b, 0x4d, 0x5c, 0x99, 0xb8, 0x18, 0x49, 0x4c, 0xdc, 0x98, 0x02, 0xc7, 0x91, 0x84,
+	0xa1, 0x63, 0x5b, 0x89, 0x3e, 0x89, 0xcf, 0xe7, 0x2b, 0xf8, 0x04, 0xa6, 0xed, 0x00, 0x03, 0x94,
+	0x8d, 0x61, 0xd7, 0xfe, 0xff, 0xe9, 0x77, 0xe6, 0x5c, 0x06, 0x2a, 0x23, 0x9e, 0xa0, 0x4a, 0x79,
+	0x0f, 0xc3, 0x54, 0x0a, 0x2d, 0x68, 0x10, 0x0f, 0x34, 0x1f, 0x7e, 0x35, 0xca, 0xea, 0x8d, 0x4b,
+	0xec, 0x3b, 0x95, 0x75, 0x60, 0xef, 0xa6, 0xdf, 0x7f, 0x98, 0xc4, 0x46, 0xf8, 0xfe, 0x81, 0x4a,
+	0xd3, 0x33, 0x28, 0x2b, 0x2d, 0x24, 0x8f, 0xf1, 0xc5, 0x70, 0xea, 0xc5, 0xd3, 0x62, 0x73, 0x2b,
+	0xda, 0xce, 0x34, 0x13, 0x4e, 0x29, 0x6c, 0x5a, 0x8b, 0x58, 0xcb, 0x9e, 0xaf, 0x83, 0xdf, 0xef,
+	0x26, 0x29, 0x15, 0xd9, 0x13, 0x54, 0x23, 0x4c, 0xc4, 0x18, 0xd7, 0x0d, 0x8e, 0x0d, 0xd8, 0x28,
+	0xff, 0x04, 0xbf, 0x4a, 0x91, 0x4c, 0xc0, 0xe6, 0x4c, 0x77, 0x80, 0x68, 0x51, 0xdf, 0xb0, 0x0a,
+	0xd1, 0x22, 0x5f, 0xc1, 0x34, 0xc5, 0xdd, 0xe7, 0x40, 0x69, 0xb5, 0x96, 0x0a, 0x08, 0xbb, 0x80,
+	0xda, 0x12, 0x58, 0xa5, 0x62, 0xa4, 0x90, 0x56, 0x21, 0x40, 0xab, 0x58, 0x66, 0x29, 0xca, 0x6e,
+	0xac, 0x0a, 0xfb, 0xf3, 0x33, 0x72, 0xf1, 0xec, 0x00, 0x6a, 0x4b, 0x5d, 0xce, 0x5b, 0x0b, 0x7d,
+	0x72, 0xd6, 0xe5, 0x0f, 0x81, 0xdd, 0xa9, 0xfa, 0x88, 0x72, 0x3c, 0xe8, 0x21, 0xbd, 0x87, 0x72,
+	0x3e, 0x05, 0x3d, 0x0c, 0xdd, 0xb6, 0x84, 0x9e, 0xe5, 0x68, 0x1c, 0xf9, 0xcd, 0x2c, 0x75, 0x81,
+	0x76, 0xa0, 0xb2, 0xf0, 0x5d, 0xf4, 0x78, 0xf2, 0xc4, 0xbf, 0x16, 0x8d, 0x93, 0x95, 0xfe, 0x3c,
+	0x75, 0xae, 0xa4, 0x3c, 0xd5, 0xb7, 0x13, 0x79, 0xaa, 0xb7, 0x17, 0x8e, 0xba, 0x30, 0x8e, 0x19,
+	0xd5, 0xbf, 0x00, 0x33, 0xea, 0x8a, 0x39, 0xb2, 0xc2, 0xed, 0xf9, 0xb3, 0x89, 0x19, 0xf2, 0x6e,
+	0xd8, 0x13, 0x49, 0xdb, 0x1d, 0x5b, 0x42, 0xc6, 0x6d, 0xf7, 0xb2, 0x65, 0xff, 0xbd, 0x76, 0x2c,
+	0xb2, 0x7b, 0xda, 0xed, 0x06, 0x56, 0xba, 0xfa, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xf7, 0xce, 0x4c,
+	0xf1, 0xb7, 0x03, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/notifications.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/notifications.pb.go
index 63c4a90bb8c2f945cc0e40ef9f3aba46d94b0fbd..11dac57d3c2d5e657b6c90c59503fbd822931bc9 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/notifications.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/notifications.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: notifications.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -34,7 +34,7 @@ func (m *PostReceiveRequest) Reset()         { *m = PostReceiveRequest{} }
 func (m *PostReceiveRequest) String() string { return proto.CompactTextString(m) }
 func (*PostReceiveRequest) ProtoMessage()    {}
 func (*PostReceiveRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_notifications_671e57d33093424c, []int{0}
+	return fileDescriptor_notifications_d4195fd8574bef8b, []int{0}
 }
 func (m *PostReceiveRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PostReceiveRequest.Unmarshal(m, b)
@@ -71,7 +71,7 @@ func (m *PostReceiveResponse) Reset()         { *m = PostReceiveResponse{} }
 func (m *PostReceiveResponse) String() string { return proto.CompactTextString(m) }
 func (*PostReceiveResponse) ProtoMessage()    {}
 func (*PostReceiveResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_notifications_671e57d33093424c, []int{1}
+	return fileDescriptor_notifications_d4195fd8574bef8b, []int{1}
 }
 func (m *PostReceiveResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PostReceiveResponse.Unmarshal(m, b)
@@ -168,19 +168,22 @@ var _NotificationService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "notifications.proto",
 }
 
-func init() { proto.RegisterFile("notifications.proto", fileDescriptor_notifications_671e57d33093424c) }
+func init() { proto.RegisterFile("notifications.proto", fileDescriptor_notifications_d4195fd8574bef8b) }
 
-var fileDescriptor_notifications_671e57d33093424c = []byte{
-	// 170 bytes of a gzipped FileDescriptorProto
+var fileDescriptor_notifications_d4195fd8574bef8b = []byte{
+	// 209 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xce, 0xcb, 0x2f, 0xc9,
 	0x4c, 0xcb, 0x4c, 0x4e, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
 	0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81,
-	0x88, 0x2a, 0x79, 0x70, 0x09, 0x05, 0xe4, 0x17, 0x97, 0x04, 0xa5, 0x26, 0xa7, 0x66, 0x96, 0xa5,
+	0x88, 0x2a, 0x05, 0x70, 0x09, 0x05, 0xe4, 0x17, 0x97, 0x04, 0xa5, 0x26, 0xa7, 0x66, 0x96, 0xa5,
 	0x06, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x15, 0xa5, 0x16, 0xe4, 0x17,
 	0x67, 0x96, 0xe4, 0x17, 0x55, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xe9, 0x41, 0x0c,
-	0xd0, 0x0b, 0x82, 0xcb, 0x04, 0x21, 0xa9, 0x52, 0x12, 0xe5, 0x12, 0x46, 0x31, 0xa9, 0xb8, 0x20,
-	0x3f, 0xaf, 0x38, 0xd5, 0x28, 0x9e, 0x4b, 0xd8, 0x0f, 0xc9, 0x35, 0xc1, 0xa9, 0x45, 0x65, 0x99,
-	0xc9, 0xa9, 0x42, 0x1e, 0x5c, 0xdc, 0x48, 0xaa, 0x85, 0xa4, 0x60, 0x86, 0x63, 0x3a, 0x46, 0x4a,
-	0x1a, 0xab, 0x1c, 0xc4, 0x78, 0x25, 0x86, 0x24, 0x36, 0xb0, 0x47, 0x8c, 0x01, 0x01, 0x00, 0x00,
-	0xff, 0xff, 0x98, 0xea, 0xcc, 0xff, 0xf5, 0x00, 0x00, 0x00,
+	0xd0, 0x0b, 0x82, 0xcb, 0x04, 0x21, 0xa9, 0xb2, 0x62, 0xfb, 0x34, 0x5d, 0x83, 0x89, 0x83, 0x49,
+	0x49, 0x94, 0x4b, 0x18, 0xc5, 0xc4, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0xa3, 0x78, 0x2e, 0x61,
+	0x3f, 0x24, 0x57, 0x05, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x0a, 0x79, 0x70, 0x71, 0x23, 0xa9,
+	0x16, 0x92, 0x82, 0x59, 0x82, 0xe9, 0x28, 0x29, 0x69, 0xac, 0x72, 0x10, 0xe3, 0x95, 0x18, 0x9c,
+	0x0c, 0xa2, 0x40, 0xf2, 0x39, 0x89, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x10, 0xa6, 0x6e, 0x7e,
+	0x51, 0xba, 0x3e, 0x44, 0x97, 0x2e, 0xd8, 0xbf, 0xfa, 0xe9, 0xf9, 0x50, 0x7e, 0x41, 0x52, 0x12,
+	0x1b, 0x58, 0xc8, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x55, 0x04, 0xb1, 0x1c, 0x2f, 0x01, 0x00,
+	0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/objectpool.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/objectpool.pb.go
index 12e4adab5d1d01acd6187843d78a24dfa8e9ebf0..bc6a03b2fd91f999e71ec0fb101e2d001ae6b76c 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/objectpool.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/objectpool.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: objectpool.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -37,7 +37,7 @@ func (m *CreateObjectPoolRequest) Reset()         { *m = CreateObjectPoolRequest
 func (m *CreateObjectPoolRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateObjectPoolRequest) ProtoMessage()    {}
 func (*CreateObjectPoolRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_objectpool_ab2e688e2665ce1f, []int{0}
+	return fileDescriptor_objectpool_52b9473682df345b, []int{0}
 }
 func (m *CreateObjectPoolRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateObjectPoolRequest.Unmarshal(m, b)
@@ -81,7 +81,7 @@ func (m *CreateObjectPoolResponse) Reset()         { *m = CreateObjectPoolRespon
 func (m *CreateObjectPoolResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateObjectPoolResponse) ProtoMessage()    {}
 func (*CreateObjectPoolResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_objectpool_ab2e688e2665ce1f, []int{1}
+	return fileDescriptor_objectpool_52b9473682df345b, []int{1}
 }
 func (m *CreateObjectPoolResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateObjectPoolResponse.Unmarshal(m, b)
@@ -114,7 +114,7 @@ func (m *DeleteObjectPoolRequest) Reset()         { *m = DeleteObjectPoolRequest
 func (m *DeleteObjectPoolRequest) String() string { return proto.CompactTextString(m) }
 func (*DeleteObjectPoolRequest) ProtoMessage()    {}
 func (*DeleteObjectPoolRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_objectpool_ab2e688e2665ce1f, []int{2}
+	return fileDescriptor_objectpool_52b9473682df345b, []int{2}
 }
 func (m *DeleteObjectPoolRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteObjectPoolRequest.Unmarshal(m, b)
@@ -151,7 +151,7 @@ func (m *DeleteObjectPoolResponse) Reset()         { *m = DeleteObjectPoolRespon
 func (m *DeleteObjectPoolResponse) String() string { return proto.CompactTextString(m) }
 func (*DeleteObjectPoolResponse) ProtoMessage()    {}
 func (*DeleteObjectPoolResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_objectpool_ab2e688e2665ce1f, []int{3}
+	return fileDescriptor_objectpool_52b9473682df345b, []int{3}
 }
 func (m *DeleteObjectPoolResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteObjectPoolResponse.Unmarshal(m, b)
@@ -183,7 +183,7 @@ func (m *LinkRepositoryToObjectPoolRequest) Reset()         { *m = LinkRepositor
 func (m *LinkRepositoryToObjectPoolRequest) String() string { return proto.CompactTextString(m) }
 func (*LinkRepositoryToObjectPoolRequest) ProtoMessage()    {}
 func (*LinkRepositoryToObjectPoolRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_objectpool_ab2e688e2665ce1f, []int{4}
+	return fileDescriptor_objectpool_52b9473682df345b, []int{4}
 }
 func (m *LinkRepositoryToObjectPoolRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_LinkRepositoryToObjectPoolRequest.Unmarshal(m, b)
@@ -227,7 +227,7 @@ func (m *LinkRepositoryToObjectPoolResponse) Reset()         { *m = LinkReposito
 func (m *LinkRepositoryToObjectPoolResponse) String() string { return proto.CompactTextString(m) }
 func (*LinkRepositoryToObjectPoolResponse) ProtoMessage()    {}
 func (*LinkRepositoryToObjectPoolResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_objectpool_ab2e688e2665ce1f, []int{5}
+	return fileDescriptor_objectpool_52b9473682df345b, []int{5}
 }
 func (m *LinkRepositoryToObjectPoolResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_LinkRepositoryToObjectPoolResponse.Unmarshal(m, b)
@@ -261,7 +261,7 @@ func (m *UnlinkRepositoryFromObjectPoolRequest) Reset()         { *m = UnlinkRep
 func (m *UnlinkRepositoryFromObjectPoolRequest) String() string { return proto.CompactTextString(m) }
 func (*UnlinkRepositoryFromObjectPoolRequest) ProtoMessage()    {}
 func (*UnlinkRepositoryFromObjectPoolRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_objectpool_ab2e688e2665ce1f, []int{6}
+	return fileDescriptor_objectpool_52b9473682df345b, []int{6}
 }
 func (m *UnlinkRepositoryFromObjectPoolRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UnlinkRepositoryFromObjectPoolRequest.Unmarshal(m, b)
@@ -307,7 +307,7 @@ func (m *UnlinkRepositoryFromObjectPoolResponse) Reset() {
 func (m *UnlinkRepositoryFromObjectPoolResponse) String() string { return proto.CompactTextString(m) }
 func (*UnlinkRepositoryFromObjectPoolResponse) ProtoMessage()    {}
 func (*UnlinkRepositoryFromObjectPoolResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_objectpool_ab2e688e2665ce1f, []int{7}
+	return fileDescriptor_objectpool_52b9473682df345b, []int{7}
 }
 func (m *UnlinkRepositoryFromObjectPoolResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UnlinkRepositoryFromObjectPoolResponse.Unmarshal(m, b)
@@ -338,7 +338,7 @@ func (m *ReduplicateRepositoryRequest) Reset()         { *m = ReduplicateReposit
 func (m *ReduplicateRepositoryRequest) String() string { return proto.CompactTextString(m) }
 func (*ReduplicateRepositoryRequest) ProtoMessage()    {}
 func (*ReduplicateRepositoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_objectpool_ab2e688e2665ce1f, []int{8}
+	return fileDescriptor_objectpool_52b9473682df345b, []int{8}
 }
 func (m *ReduplicateRepositoryRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReduplicateRepositoryRequest.Unmarshal(m, b)
@@ -375,7 +375,7 @@ func (m *ReduplicateRepositoryResponse) Reset()         { *m = ReduplicateReposi
 func (m *ReduplicateRepositoryResponse) String() string { return proto.CompactTextString(m) }
 func (*ReduplicateRepositoryResponse) ProtoMessage()    {}
 func (*ReduplicateRepositoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_objectpool_ab2e688e2665ce1f, []int{9}
+	return fileDescriptor_objectpool_52b9473682df345b, []int{9}
 }
 func (m *ReduplicateRepositoryResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReduplicateRepositoryResponse.Unmarshal(m, b)
@@ -614,31 +614,34 @@ var _ObjectPoolService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "objectpool.proto",
 }
 
-func init() { proto.RegisterFile("objectpool.proto", fileDescriptor_objectpool_ab2e688e2665ce1f) }
-
-var fileDescriptor_objectpool_ab2e688e2665ce1f = []byte{
-	// 368 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xcd, 0x4e, 0xc2, 0x40,
-	0x14, 0x85, 0x29, 0x31, 0x2c, 0x2e, 0x2e, 0x70, 0x12, 0x03, 0x99, 0xa8, 0x60, 0x03, 0x06, 0x49,
-	0xec, 0x02, 0x1e, 0x41, 0xe3, 0xca, 0xa8, 0xa9, 0x1a, 0x97, 0xa6, 0xc0, 0x15, 0x47, 0x6b, 0x6f,
-	0x9d, 0x0e, 0x26, 0xb8, 0x73, 0xef, 0xc2, 0xc7, 0xf0, 0x31, 0x0d, 0xf4, 0x8f, 0x1f, 0x87, 0x36,
-	0x86, 0x1d, 0x21, 0x27, 0xdf, 0xf9, 0x66, 0xe6, 0x00, 0x54, 0xa8, 0xff, 0x8c, 0x03, 0xe5, 0x13,
-	0xb9, 0x96, 0x2f, 0x49, 0x11, 0x2b, 0x8d, 0x84, 0x72, 0xdc, 0x09, 0xdf, 0x0e, 0x9e, 0x1c, 0x89,
-	0xc3, 0xf0, 0x5b, 0xf3, 0x03, 0xaa, 0xa7, 0x12, 0x1d, 0x85, 0x57, 0xb3, 0xfc, 0x35, 0x91, 0x6b,
-	0xe3, 0xdb, 0x18, 0x03, 0xc5, 0x7a, 0x50, 0x0e, 0x21, 0x0f, 0x53, 0x4a, 0xcd, 0x68, 0x18, 0xed,
-	0x72, 0x97, 0x59, 0x21, 0xc6, 0x9a, 0xcb, 0x03, 0x25, 0x9f, 0x59, 0x07, 0x4a, 0x24, 0xc5, 0x48,
-	0x78, 0xb5, 0xe2, 0x62, 0xde, 0x46, 0x9f, 0x02, 0xa1, 0x48, 0x4e, 0xec, 0x28, 0x61, 0x72, 0xa8,
-	0xad, 0x76, 0x07, 0x3e, 0x79, 0x01, 0x9a, 0x97, 0x50, 0x3d, 0x43, 0x17, 0x37, 0xe5, 0x35, 0xed,
-	0x5a, 0xe5, 0x45, 0x5d, 0x5f, 0x06, 0x1c, 0x5e, 0x08, 0xef, 0x25, 0x55, 0xbc, 0xa5, 0x0d, 0x5d,
-	0x47, 0x17, 0x40, 0x26, 0xd4, 0x35, 0x57, 0x32, 0x97, 0x32, 0x9b, 0x60, 0xae, 0xb3, 0x89, 0xa4,
-	0xbf, 0x0d, 0x68, 0xdd, 0x79, 0xee, 0x42, 0xf0, 0x5c, 0xd2, 0xeb, 0xaa, 0xf8, 0xa2, 0x83, 0x91,
-	0xc7, 0x61, 0xf9, 0xb0, 0xc5, 0x5c, 0x77, 0xdc, 0x86, 0xa3, 0x2c, 0xa3, 0x48, 0xde, 0x86, 0x3d,
-	0x1b, 0x87, 0x63, 0xdf, 0x15, 0x03, 0x47, 0xe1, 0x9c, 0xc3, 0xff, 0x95, 0xcd, 0x3a, 0xec, 0x6b,
-	0x98, 0x61, 0x69, 0xf7, 0x67, 0x0b, 0x76, 0x52, 0x97, 0x1b, 0x94, 0xef, 0x62, 0x80, 0xec, 0x1e,
-	0x2a, 0xcb, 0x23, 0x64, 0xf5, 0xb8, 0x4a, 0xf3, 0xd3, 0xe0, 0x0d, 0x7d, 0x20, 0x3a, 0x61, 0x61,
-	0x0a, 0x5e, 0x5e, 0x5c, 0x0a, 0xd6, 0x6c, 0x3b, 0x05, 0x6b, 0xc7, 0x5a, 0x60, 0x63, 0xe0, 0xfa,
-	0x7d, 0xb0, 0xe3, 0x98, 0x90, 0xb9, 0x68, 0xde, 0xc9, 0x13, 0x4d, 0x6a, 0x3f, 0x0d, 0x38, 0x58,
-	0xff, 0xbc, 0xec, 0x24, 0x06, 0xe6, 0x1a, 0x26, 0xb7, 0xf2, 0xc6, 0x13, 0x87, 0x47, 0xd8, 0xfd,
-	0xf3, 0x8d, 0x59, 0x33, 0x1d, 0x87, 0x7e, 0x56, 0xbc, 0x95, 0x91, 0x8a, 0x7b, 0xfa, 0xa5, 0xd9,
-	0x9f, 0x63, 0xef, 0x37, 0x00, 0x00, 0xff, 0xff, 0xc1, 0xa5, 0x91, 0xe0, 0x46, 0x05, 0x00, 0x00,
+func init() { proto.RegisterFile("objectpool.proto", fileDescriptor_objectpool_52b9473682df345b) }
+
+var fileDescriptor_objectpool_52b9473682df345b = []byte{
+	// 415 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xcd, 0x4e, 0xfa, 0x40,
+	0x14, 0xc5, 0x19, 0xf2, 0x4f, 0xf3, 0xcf, 0xc5, 0x05, 0x4e, 0x62, 0x20, 0x8d, 0x0a, 0x36, 0x60,
+	0x90, 0x84, 0x62, 0x60, 0xe7, 0x52, 0x8d, 0x2b, 0x13, 0x4d, 0xfd, 0x4a, 0xd8, 0x98, 0xb6, 0x8c,
+	0xb5, 0x5a, 0x7a, 0xeb, 0xb4, 0x98, 0xb0, 0xd4, 0x67, 0x30, 0xd1, 0x47, 0xf0, 0xf9, 0x7c, 0x02,
+	0x03, 0xfd, 0x04, 0x2c, 0x54, 0xc3, 0x6e, 0x98, 0x9c, 0x39, 0xe7, 0x77, 0x67, 0x0e, 0x85, 0x22,
+	0x6a, 0x0f, 0x4c, 0xf7, 0x1c, 0x44, 0x4b, 0x76, 0x38, 0x7a, 0x48, 0x05, 0xc3, 0xf4, 0x54, 0x6b,
+	0x24, 0xae, 0xb9, 0xf7, 0x2a, 0x67, 0x7d, 0x7f, 0x57, 0x7a, 0x25, 0x50, 0x3a, 0xe2, 0x4c, 0xf5,
+	0xd8, 0xd9, 0xe4, 0xc0, 0x39, 0xa2, 0xa5, 0xb0, 0xa7, 0x21, 0x73, 0x3d, 0xda, 0x85, 0x82, 0xef,
+	0x72, 0x3b, 0xb6, 0x29, 0x93, 0x2a, 0x69, 0x14, 0x3a, 0x54, 0xf6, 0x7d, 0xe4, 0x84, 0x1e, 0x30,
+	0x5a, 0xd3, 0x26, 0x08, 0xc8, 0x4d, 0xc3, 0xb4, 0xcb, 0xf9, 0x69, 0xbd, 0xc2, 0x1c, 0x74, 0x4d,
+	0x0f, 0xf9, 0x48, 0x09, 0x14, 0x07, 0xc2, 0xd7, 0x7b, 0x23, 0xff, 0x9f, 0x48, 0x22, 0x94, 0xe7,
+	0x19, 0x5c, 0x07, 0x6d, 0x97, 0x49, 0xd7, 0x50, 0x3a, 0x66, 0x16, 0x5b, 0x15, 0x5f, 0x32, 0x73,
+	0xde, 0x37, 0xc8, 0x7c, 0x23, 0xb0, 0x73, 0x6a, 0xda, 0x8f, 0x31, 0xf2, 0x25, 0xae, 0xe8, 0x7a,
+	0x3a, 0x00, 0x3c, 0x72, 0x5d, 0x70, 0x45, 0x09, 0x55, 0x84, 0x5c, 0x03, 0x69, 0x11, 0x55, 0x00,
+	0xff, 0x41, 0xa0, 0x7e, 0x65, 0x5b, 0x53, 0xc2, 0x13, 0x8e, 0x83, 0xf9, 0x01, 0xa6, 0x59, 0x48,
+	0x16, 0x96, 0xd9, 0xa1, 0xf3, 0xbf, 0xba, 0xf3, 0x06, 0xec, 0x2e, 0x23, 0x0b, 0x86, 0xe8, 0xc1,
+	0xa6, 0xc2, 0xfa, 0x43, 0xc7, 0x32, 0x75, 0xd5, 0x63, 0x09, 0x96, 0xbf, 0xa3, 0x47, 0x14, 0x15,
+	0xd8, 0x4a, 0xf1, 0xf6, 0xc3, 0x3b, 0x9f, 0xff, 0x60, 0x3d, 0x66, 0xba, 0x60, 0xfc, 0xd9, 0xd4,
+	0x19, 0xbd, 0x81, 0xe2, 0x6c, 0x49, 0x69, 0x25, 0x8c, 0x4c, 0xf9, 0x0b, 0x89, 0xd5, 0x74, 0x41,
+	0x30, 0x69, 0x6e, 0x6c, 0x3c, 0xdb, 0xc4, 0xd8, 0x38, 0xa5, 0xfb, 0xb1, 0x71, 0x6a, 0x89, 0x73,
+	0x74, 0x08, 0x62, 0x7a, 0x5f, 0xe8, 0x5e, 0xe8, 0xb0, 0xb4, 0xe9, 0x62, 0x33, 0x8b, 0x34, 0x8a,
+	0x7d, 0x21, 0xb0, 0xbd, 0xf8, 0x99, 0x69, 0x2b, 0x34, 0xcc, 0x54, 0x54, 0x51, 0xce, 0x2a, 0x8f,
+	0x18, 0xee, 0x60, 0xe3, 0xc7, 0x37, 0xa6, 0xb5, 0xb8, 0x24, 0xe9, 0xf5, 0x12, 0xeb, 0x4b, 0x54,
+	0x61, 0xce, 0xe1, 0x7e, 0x6f, 0xac, 0xb4, 0x54, 0x4d, 0xd6, 0x71, 0xd0, 0xf6, 0x97, 0x2d, 0xe4,
+	0x46, 0xdb, 0x3f, 0xdf, 0x9a, 0x7c, 0x64, 0xdb, 0x06, 0x06, 0xbf, 0x1d, 0x4d, 0x13, 0x26, 0x5b,
+	0xdd, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8b, 0xa8, 0x1d, 0x02, 0xa1, 0x05, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/operations.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/operations.pb.go
index 8efcd213d0e0e0ef4168b244c10945c8f42dad82..be561decc1320da8740d1660a65bb7139f741730 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/operations.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/operations.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: operations.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -55,7 +55,7 @@ func (x UserCommitFilesActionHeader_ActionType) String() string {
 	return proto.EnumName(UserCommitFilesActionHeader_ActionType_name, int32(x))
 }
 func (UserCommitFilesActionHeader_ActionType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{21, 0}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{21, 0}
 }
 
 type UserCreateBranchRequest struct {
@@ -72,7 +72,7 @@ func (m *UserCreateBranchRequest) Reset()         { *m = UserCreateBranchRequest
 func (m *UserCreateBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserCreateBranchRequest) ProtoMessage()    {}
 func (*UserCreateBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{0}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{0}
 }
 func (m *UserCreateBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCreateBranchRequest.Unmarshal(m, b)
@@ -134,7 +134,7 @@ func (m *UserCreateBranchResponse) Reset()         { *m = UserCreateBranchRespon
 func (m *UserCreateBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserCreateBranchResponse) ProtoMessage()    {}
 func (*UserCreateBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{1}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{1}
 }
 func (m *UserCreateBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCreateBranchResponse.Unmarshal(m, b)
@@ -183,7 +183,7 @@ func (m *UserUpdateBranchRequest) Reset()         { *m = UserUpdateBranchRequest
 func (m *UserUpdateBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserUpdateBranchRequest) ProtoMessage()    {}
 func (*UserUpdateBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{2}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{2}
 }
 func (m *UserUpdateBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserUpdateBranchRequest.Unmarshal(m, b)
@@ -249,7 +249,7 @@ func (m *UserUpdateBranchResponse) Reset()         { *m = UserUpdateBranchRespon
 func (m *UserUpdateBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserUpdateBranchResponse) ProtoMessage()    {}
 func (*UserUpdateBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{3}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{3}
 }
 func (m *UserUpdateBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserUpdateBranchResponse.Unmarshal(m, b)
@@ -289,7 +289,7 @@ func (m *UserDeleteBranchRequest) Reset()         { *m = UserDeleteBranchRequest
 func (m *UserDeleteBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserDeleteBranchRequest) ProtoMessage()    {}
 func (*UserDeleteBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{4}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{4}
 }
 func (m *UserDeleteBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserDeleteBranchRequest.Unmarshal(m, b)
@@ -341,7 +341,7 @@ func (m *UserDeleteBranchResponse) Reset()         { *m = UserDeleteBranchRespon
 func (m *UserDeleteBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserDeleteBranchResponse) ProtoMessage()    {}
 func (*UserDeleteBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{5}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{5}
 }
 func (m *UserDeleteBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserDeleteBranchResponse.Unmarshal(m, b)
@@ -381,7 +381,7 @@ func (m *UserDeleteTagRequest) Reset()         { *m = UserDeleteTagRequest{} }
 func (m *UserDeleteTagRequest) String() string { return proto.CompactTextString(m) }
 func (*UserDeleteTagRequest) ProtoMessage()    {}
 func (*UserDeleteTagRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{6}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{6}
 }
 func (m *UserDeleteTagRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserDeleteTagRequest.Unmarshal(m, b)
@@ -433,7 +433,7 @@ func (m *UserDeleteTagResponse) Reset()         { *m = UserDeleteTagResponse{} }
 func (m *UserDeleteTagResponse) String() string { return proto.CompactTextString(m) }
 func (*UserDeleteTagResponse) ProtoMessage()    {}
 func (*UserDeleteTagResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{7}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{7}
 }
 func (m *UserDeleteTagResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserDeleteTagResponse.Unmarshal(m, b)
@@ -475,7 +475,7 @@ func (m *UserCreateTagRequest) Reset()         { *m = UserCreateTagRequest{} }
 func (m *UserCreateTagRequest) String() string { return proto.CompactTextString(m) }
 func (*UserCreateTagRequest) ProtoMessage()    {}
 func (*UserCreateTagRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{8}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{8}
 }
 func (m *UserCreateTagRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCreateTagRequest.Unmarshal(m, b)
@@ -543,7 +543,7 @@ func (m *UserCreateTagResponse) Reset()         { *m = UserCreateTagResponse{} }
 func (m *UserCreateTagResponse) String() string { return proto.CompactTextString(m) }
 func (*UserCreateTagResponse) ProtoMessage()    {}
 func (*UserCreateTagResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{9}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{9}
 }
 func (m *UserCreateTagResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCreateTagResponse.Unmarshal(m, b)
@@ -603,7 +603,7 @@ func (m *UserMergeBranchRequest) Reset()         { *m = UserMergeBranchRequest{}
 func (m *UserMergeBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserMergeBranchRequest) ProtoMessage()    {}
 func (*UserMergeBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{10}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{10}
 }
 func (m *UserMergeBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserMergeBranchRequest.Unmarshal(m, b)
@@ -682,7 +682,7 @@ func (m *UserMergeBranchResponse) Reset()         { *m = UserMergeBranchResponse
 func (m *UserMergeBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserMergeBranchResponse) ProtoMessage()    {}
 func (*UserMergeBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{11}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{11}
 }
 func (m *UserMergeBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserMergeBranchResponse.Unmarshal(m, b)
@@ -745,7 +745,7 @@ func (m *UserMergeToRefRequest) Reset()         { *m = UserMergeToRefRequest{} }
 func (m *UserMergeToRefRequest) String() string { return proto.CompactTextString(m) }
 func (*UserMergeToRefRequest) ProtoMessage()    {}
 func (*UserMergeToRefRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{12}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{12}
 }
 func (m *UserMergeToRefRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserMergeToRefRequest.Unmarshal(m, b)
@@ -819,7 +819,7 @@ func (m *UserMergeToRefResponse) Reset()         { *m = UserMergeToRefResponse{}
 func (m *UserMergeToRefResponse) String() string { return proto.CompactTextString(m) }
 func (*UserMergeToRefResponse) ProtoMessage()    {}
 func (*UserMergeToRefResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{13}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{13}
 }
 func (m *UserMergeToRefResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserMergeToRefResponse.Unmarshal(m, b)
@@ -869,7 +869,7 @@ func (m *OperationBranchUpdate) Reset()         { *m = OperationBranchUpdate{} }
 func (m *OperationBranchUpdate) String() string { return proto.CompactTextString(m) }
 func (*OperationBranchUpdate) ProtoMessage()    {}
 func (*OperationBranchUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{14}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{14}
 }
 func (m *OperationBranchUpdate) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperationBranchUpdate.Unmarshal(m, b)
@@ -924,7 +924,7 @@ func (m *UserFFBranchRequest) Reset()         { *m = UserFFBranchRequest{} }
 func (m *UserFFBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserFFBranchRequest) ProtoMessage()    {}
 func (*UserFFBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{15}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{15}
 }
 func (m *UserFFBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserFFBranchRequest.Unmarshal(m, b)
@@ -984,7 +984,7 @@ func (m *UserFFBranchResponse) Reset()         { *m = UserFFBranchResponse{} }
 func (m *UserFFBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserFFBranchResponse) ProtoMessage()    {}
 func (*UserFFBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{16}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{16}
 }
 func (m *UserFFBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserFFBranchResponse.Unmarshal(m, b)
@@ -1035,7 +1035,7 @@ func (m *UserCherryPickRequest) Reset()         { *m = UserCherryPickRequest{} }
 func (m *UserCherryPickRequest) String() string { return proto.CompactTextString(m) }
 func (*UserCherryPickRequest) ProtoMessage()    {}
 func (*UserCherryPickRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{17}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{17}
 }
 func (m *UserCherryPickRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCherryPickRequest.Unmarshal(m, b)
@@ -1118,7 +1118,7 @@ func (m *UserCherryPickResponse) Reset()         { *m = UserCherryPickResponse{}
 func (m *UserCherryPickResponse) String() string { return proto.CompactTextString(m) }
 func (*UserCherryPickResponse) ProtoMessage()    {}
 func (*UserCherryPickResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{18}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{18}
 }
 func (m *UserCherryPickResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCherryPickResponse.Unmarshal(m, b)
@@ -1183,7 +1183,7 @@ func (m *UserRevertRequest) Reset()         { *m = UserRevertRequest{} }
 func (m *UserRevertRequest) String() string { return proto.CompactTextString(m) }
 func (*UserRevertRequest) ProtoMessage()    {}
 func (*UserRevertRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{19}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{19}
 }
 func (m *UserRevertRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserRevertRequest.Unmarshal(m, b)
@@ -1266,7 +1266,7 @@ func (m *UserRevertResponse) Reset()         { *m = UserRevertResponse{} }
 func (m *UserRevertResponse) String() string { return proto.CompactTextString(m) }
 func (*UserRevertResponse) ProtoMessage()    {}
 func (*UserRevertResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{20}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{20}
 }
 func (m *UserRevertResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserRevertResponse.Unmarshal(m, b)
@@ -1333,7 +1333,7 @@ func (m *UserCommitFilesActionHeader) Reset()         { *m = UserCommitFilesActi
 func (m *UserCommitFilesActionHeader) String() string { return proto.CompactTextString(m) }
 func (*UserCommitFilesActionHeader) ProtoMessage()    {}
 func (*UserCommitFilesActionHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{21}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{21}
 }
 func (m *UserCommitFilesActionHeader) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCommitFilesActionHeader.Unmarshal(m, b)
@@ -1409,7 +1409,7 @@ func (m *UserCommitFilesAction) Reset()         { *m = UserCommitFilesAction{} }
 func (m *UserCommitFilesAction) String() string { return proto.CompactTextString(m) }
 func (*UserCommitFilesAction) ProtoMessage()    {}
 func (*UserCommitFilesAction) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{22}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{22}
 }
 func (m *UserCommitFilesAction) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCommitFilesAction.Unmarshal(m, b)
@@ -1555,7 +1555,7 @@ func (m *UserCommitFilesRequestHeader) Reset()         { *m = UserCommitFilesReq
 func (m *UserCommitFilesRequestHeader) String() string { return proto.CompactTextString(m) }
 func (*UserCommitFilesRequestHeader) ProtoMessage()    {}
 func (*UserCommitFilesRequestHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{23}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{23}
 }
 func (m *UserCommitFilesRequestHeader) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCommitFilesRequestHeader.Unmarshal(m, b)
@@ -1652,7 +1652,7 @@ func (m *UserCommitFilesRequest) Reset()         { *m = UserCommitFilesRequest{}
 func (m *UserCommitFilesRequest) String() string { return proto.CompactTextString(m) }
 func (*UserCommitFilesRequest) ProtoMessage()    {}
 func (*UserCommitFilesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{24}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{24}
 }
 func (m *UserCommitFilesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCommitFilesRequest.Unmarshal(m, b)
@@ -1796,7 +1796,7 @@ func (m *UserCommitFilesResponse) Reset()         { *m = UserCommitFilesResponse
 func (m *UserCommitFilesResponse) String() string { return proto.CompactTextString(m) }
 func (*UserCommitFilesResponse) ProtoMessage()    {}
 func (*UserCommitFilesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_c652ed28d9f91e3b, []int{25}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{25}
 }
 func (m *UserCommitFilesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCommitFilesResponse.Unmarshal(m, b)
@@ -1854,7 +1854,7 @@ 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_operations_c652ed28d9f91e3b, []int{26}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{26}
 }
 func (m *UserRebaseRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserRebaseRequest.Unmarshal(m, b)
@@ -1936,7 +1936,7 @@ 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_operations_c652ed28d9f91e3b, []int{27}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{27}
 }
 func (m *UserRebaseResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserRebaseResponse.Unmarshal(m, b)
@@ -1995,7 +1995,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_operations_c652ed28d9f91e3b, []int{28}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{28}
 }
 func (m *UserSquashRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserSquashRequest.Unmarshal(m, b)
@@ -2083,7 +2083,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_operations_c652ed28d9f91e3b, []int{29}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{29}
 }
 func (m *UserSquashResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserSquashResponse.Unmarshal(m, b)
@@ -2131,7 +2131,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_operations_c652ed28d9f91e3b, []int{30}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{30}
 }
 func (m *UserApplyPatchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserApplyPatchRequest.Unmarshal(m, b)
@@ -2271,7 +2271,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_operations_c652ed28d9f91e3b, []int{30, 0}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{30, 0}
 }
 func (m *UserApplyPatchRequest_Header) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserApplyPatchRequest_Header.Unmarshal(m, b)
@@ -2323,7 +2323,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_operations_c652ed28d9f91e3b, []int{31}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{31}
 }
 func (m *UserApplyPatchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserApplyPatchResponse.Unmarshal(m, b)
@@ -2366,7 +2366,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_operations_c652ed28d9f91e3b, []int{32}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{32}
 }
 func (m *UserUpdateSubmoduleRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserUpdateSubmoduleRequest.Unmarshal(m, b)
@@ -2441,7 +2441,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_operations_c652ed28d9f91e3b, []int{33}
+	return fileDescriptor_operations_3e6454468a1f158c, []int{33}
 }
 func (m *UserUpdateSubmoduleResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserUpdateSubmoduleResponse.Unmarshal(m, b)
@@ -3156,122 +3156,126 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "operations.proto",
 }
 
-func init() { proto.RegisterFile("operations.proto", fileDescriptor_operations_c652ed28d9f91e3b) }
-
-var fileDescriptor_operations_c652ed28d9f91e3b = []byte{
-	// 1824 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x2b, 0x49,
-	0x11, 0xf7, 0xd8, 0xce, 0xc4, 0xae, 0x38, 0x89, 0xd3, 0xfb, 0xe5, 0xf5, 0x4b, 0x48, 0x76, 0xb2,
-	0x0b, 0x6f, 0x57, 0x28, 0x42, 0x01, 0xc1, 0x69, 0x41, 0xf9, 0x70, 0xc8, 0x2e, 0x64, 0x5f, 0x98,
-	0x24, 0x0b, 0x07, 0xa4, 0x61, 0x62, 0x77, 0xec, 0x11, 0xb6, 0x67, 0xb6, 0x67, 0x1c, 0x5e, 0x10,
-	0xe2, 0x82, 0x04, 0x57, 0x4e, 0x5c, 0x10, 0x12, 0x88, 0x1b, 0xe2, 0xc2, 0x85, 0x03, 0x07, 0xc4,
-	0x15, 0xae, 0xef, 0xc0, 0x89, 0x7f, 0xe1, 0xdd, 0xb8, 0xa3, 0xee, 0xaa, 0xf1, 0x4c, 0xcf, 0x8c,
-	0xad, 0xe4, 0x91, 0xe8, 0x3d, 0x21, 0x6e, 0x9e, 0xea, 0xea, 0xea, 0xaa, 0x5f, 0x55, 0x57, 0x55,
-	0x97, 0xa1, 0xe9, 0x07, 0x5c, 0xb8, 0x91, 0xe7, 0x8f, 0xc3, 0x9d, 0x40, 0xf8, 0x91, 0xcf, 0xcc,
-	0xbe, 0x17, 0xb9, 0xc3, 0x9b, 0x76, 0x23, 0x1c, 0xb8, 0x82, 0xf7, 0x90, 0x6a, 0xfd, 0xc9, 0x80,
-	0xb7, 0x2e, 0x42, 0x2e, 0x0e, 0x04, 0x77, 0x23, 0xbe, 0x2f, 0xdc, 0x71, 0x77, 0x60, 0xf3, 0xcf,
-	0x26, 0x3c, 0x8c, 0xd8, 0x2e, 0x80, 0xe0, 0x81, 0x1f, 0x7a, 0x91, 0x2f, 0x6e, 0x5a, 0xc6, 0x96,
-	0xf1, 0x78, 0x69, 0x97, 0xed, 0xa0, 0x98, 0x1d, 0x7b, 0xba, 0x62, 0xa7, 0xb8, 0xd8, 0x26, 0x2c,
-	0x5d, 0x2a, 0x21, 0xce, 0xd8, 0x1d, 0xf1, 0x56, 0x79, 0xcb, 0x78, 0xdc, 0xb0, 0x01, 0x49, 0x9f,
-	0xb8, 0x23, 0xce, 0xb6, 0xa0, 0x3a, 0x09, 0xb9, 0x68, 0x55, 0x94, 0xb8, 0x46, 0x2c, 0x4e, 0xea,
-	0x60, 0xab, 0x15, 0x29, 0x22, 0x8c, 0x5c, 0x11, 0x39, 0x81, 0xef, 0x8d, 0xa3, 0x56, 0x15, 0x45,
-	0x28, 0xd2, 0xa9, 0xa4, 0x58, 0x63, 0x68, 0xe5, 0x55, 0x0e, 0x03, 0x7f, 0x1c, 0x72, 0xf6, 0x79,
-	0x30, 0xf1, 0x30, 0xd2, 0x77, 0x25, 0x3e, 0x80, 0xf8, 0x68, 0x95, 0x7d, 0x00, 0x6b, 0x81, 0xe0,
-	0x8e, 0xe0, 0x5d, 0xee, 0x5d, 0x73, 0x87, 0x0b, 0xe1, 0x0b, 0xa5, 0x6d, 0xdd, 0x5e, 0x0d, 0x04,
-	0xb7, 0x91, 0xde, 0x91, 0x64, 0xeb, 0x6f, 0x84, 0xd1, 0x45, 0xd0, 0x7b, 0x55, 0x30, 0x7a, 0x13,
-	0xcc, 0x31, 0xff, 0x91, 0xe0, 0xd7, 0x04, 0x0f, 0x7d, 0x49, 0xba, 0x3f, 0xec, 0x49, 0xfa, 0x02,
-	0xd2, 0xf1, 0xcb, 0x3a, 0x42, 0xc8, 0x74, 0x0b, 0x08, 0xb2, 0x42, 0x28, 0x8c, 0x62, 0x28, 0x7e,
-	0x49, 0x50, 0x1c, 0xf2, 0x21, 0x7f, 0x35, 0xa0, 0x88, 0x4d, 0xd3, 0x35, 0x7a, 0x01, 0xd3, 0x7e,
-	0x61, 0xc0, 0xeb, 0x89, 0xa0, 0x73, 0xb7, 0xff, 0xdf, 0xd8, 0xf5, 0x36, 0xd4, 0x22, 0xb7, 0x9f,
-	0x36, 0x6a, 0x31, 0x72, 0xfb, 0xb7, 0xb4, 0xe8, 0x00, 0xde, 0xc8, 0x28, 0xf2, 0x02, 0xe6, 0xfc,
-	0x83, 0xcc, 0xc1, 0x5b, 0xf2, 0x12, 0xcd, 0x61, 0x5f, 0x80, 0xd5, 0xc8, 0x15, 0x7d, 0x1e, 0x39,
-	0x82, 0x5f, 0x7b, 0xa1, 0xe7, 0x8f, 0x29, 0x68, 0x57, 0x90, 0x6c, 0x13, 0x95, 0xb5, 0x60, 0x71,
-	0xc4, 0xc3, 0xd0, 0xed, 0x73, 0x8a, 0xde, 0xf8, 0xd3, 0xfa, 0x31, 0x22, 0x92, 0xb2, 0x85, 0x10,
-	0xd9, 0x80, 0x4a, 0xe4, 0xf6, 0xc9, 0x8a, 0xa5, 0xf8, 0x70, 0xc9, 0x21, 0xe9, 0xf2, 0x3a, 0xf0,
-	0xa7, 0x5e, 0x18, 0x85, 0x4a, 0xeb, 0x9a, 0x4d, 0x5f, 0xc5, 0x40, 0x56, 0x8a, 0x81, 0x7c, 0x66,
-	0xc0, 0x9b, 0xf2, 0xf0, 0x13, 0x2e, 0xfa, 0xf7, 0x10, 0xf1, 0x31, 0x5e, 0xe5, 0x99, 0x78, 0x3d,
-	0x82, 0x7a, 0xd7, 0x1f, 0x8d, 0xbc, 0xc8, 0xf1, 0x7a, 0xa4, 0x54, 0x0d, 0x09, 0x1f, 0xf5, 0xa4,
-	0x45, 0x94, 0xdf, 0xe8, 0xe2, 0x53, 0x3e, 0x9b, 0x89, 0x1d, 0x7b, 0x1d, 0x16, 0xdc, 0x20, 0x18,
-	0xde, 0xb4, 0x4c, 0x05, 0x01, 0x7e, 0x58, 0x7f, 0xa4, 0x8b, 0xac, 0x59, 0x45, 0xa0, 0x6a, 0x0a,
-	0x18, 0x19, 0x05, 0xf6, 0x61, 0x99, 0x6e, 0xec, 0x44, 0x25, 0x13, 0x72, 0xfc, 0x46, 0x6c, 0xc8,
-	0x93, 0xb8, 0xee, 0xa0, 0x50, 0xcc, 0x38, 0x76, 0xe3, 0x32, 0xf5, 0x55, 0x0c, 0x7f, 0xb5, 0x10,
-	0xfe, 0x8f, 0xab, 0xb5, 0x72, 0xb3, 0x62, 0xfd, 0xcb, 0xc0, 0x08, 0x50, 0xea, 0x9e, 0xfb, 0x36,
-	0xbf, 0x7a, 0x58, 0x1f, 0x6c, 0x00, 0x84, 0xfe, 0x44, 0x74, 0xb9, 0x13, 0x0e, 0x5c, 0x72, 0x42,
-	0x1d, 0x29, 0x67, 0x03, 0x77, 0xa6, 0x17, 0x36, 0x00, 0xa6, 0xa1, 0x7e, 0x45, 0x8e, 0xa8, 0xc7,
-	0x51, 0x7e, 0x95, 0x76, 0x92, 0xa9, 0x07, 0xb8, 0x9b, 0x8a, 0x31, 0x32, 0xef, 0x36, 0xce, 0xb8,
-	0x4b, 0x15, 0xfb, 0x29, 0xbc, 0x51, 0xe8, 0x9b, 0xf9, 0x27, 0xbc, 0x03, 0x0d, 0x09, 0x9c, 0xd3,
-	0x55, 0x57, 0xaf, 0x47, 0xf7, 0x68, 0x49, 0xd2, 0xf0, 0x36, 0xf6, 0xd8, 0x7b, 0xb0, 0x42, 0x11,
-	0x11, 0x33, 0x55, 0x14, 0x13, 0xc5, 0x09, 0xb1, 0x59, 0xbf, 0x35, 0xe0, 0x35, 0x69, 0xe3, 0xd1,
-	0xd1, 0xab, 0x7a, 0x89, 0xac, 0x9f, 0x53, 0xce, 0x4c, 0x54, 0x24, 0x27, 0xe4, 0x82, 0xde, 0xb8,
-	0xa7, 0xa0, 0x9f, 0xe1, 0xab, 0xbf, 0x96, 0x29, 0xe1, 0x0d, 0xb8, 0x10, 0x37, 0xa7, 0x5e, 0xf7,
-	0x87, 0x0f, 0x8b, 0xd6, 0xfb, 0x60, 0x22, 0x38, 0x74, 0x9b, 0xd7, 0x62, 0x9e, 0x6f, 0x7a, 0xd1,
-	0x81, 0x5a, 0xb0, 0x89, 0x21, 0x5b, 0xb1, 0xab, 0xb9, 0x8a, 0x3d, 0x3b, 0x13, 0x7d, 0x00, 0x6b,
-	0xd8, 0xd8, 0xa5, 0x05, 0xe0, 0x45, 0x58, 0x55, 0x0b, 0xfb, 0x89, 0x94, 0x0f, 0xa1, 0x89, 0xbc,
-	0x29, 0x6b, 0x17, 0x67, 0x5a, 0x8b, 0xdb, 0x13, 0x82, 0xf5, 0x4f, 0x4a, 0xda, 0x69, 0x00, 0xef,
-	0xd7, 0x97, 0x18, 0xeb, 0x4e, 0x24, 0x78, 0xc6, 0x97, 0xb8, 0x70, 0x2e, 0x38, 0xfa, 0x52, 0xde,
-	0x20, 0x8a, 0xc4, 0x74, 0x99, 0x59, 0x42, 0x1a, 0xb2, 0xdc, 0x21, 0x1f, 0x5a, 0x7f, 0x29, 0xc3,
-	0x9a, 0xf2, 0x1c, 0xbf, 0xe6, 0xd2, 0xe4, 0xff, 0x87, 0xc5, 0x1d, 0xc2, 0xe2, 0x99, 0x01, 0x2c,
-	0x0d, 0xde, 0xff, 0x46, 0x48, 0xfc, 0xbb, 0x0c, 0x8f, 0x54, 0xb0, 0xab, 0xfd, 0x47, 0xde, 0x90,
-	0x87, 0x7b, 0x5d, 0xa9, 0xee, 0x31, 0x77, 0x7b, 0x5c, 0xb0, 0x23, 0x30, 0x5d, 0xf5, 0xad, 0xec,
-	0x5a, 0xd9, 0xdd, 0x49, 0xbb, 0x7a, 0xc6, 0xa6, 0x1d, 0xfc, 0x38, 0xbf, 0x09, 0xb8, 0x4d, 0xbb,
-	0x65, 0x4e, 0xbd, 0xf2, 0x86, 0xdc, 0x09, 0xdc, 0x68, 0x40, 0x6d, 0x60, 0x4d, 0x12, 0x4e, 0xdd,
-	0x68, 0xc0, 0xb6, 0x61, 0x39, 0x90, 0xfd, 0x9d, 0x3f, 0x09, 0x91, 0xa1, 0xa2, 0x18, 0x1a, 0x31,
-	0x51, 0x31, 0xc9, 0x52, 0xe1, 0x86, 0xfc, 0xab, 0x5f, 0x71, 0xba, 0xfe, 0x38, 0xe2, 0xf4, 0xba,
-	0x93, 0xa5, 0x42, 0x51, 0x0f, 0x90, 0xc8, 0xde, 0x87, 0x26, 0x7f, 0xca, 0xbb, 0x93, 0x88, 0x3b,
-	0x52, 0xfe, 0xc8, 0xef, 0x61, 0xd0, 0xd4, 0xec, 0x55, 0xa2, 0x1f, 0x11, 0x59, 0x1e, 0xeb, 0x8d,
-	0xaf, 0xb8, 0x98, 0x0a, 0xc4, 0x2e, 0xa7, 0xa1, 0x88, 0x24, 0xcf, 0xba, 0x00, 0x48, 0xcc, 0x61,
-	0x00, 0xe6, 0x81, 0xdd, 0xd9, 0x3b, 0xef, 0x34, 0x4b, 0x6c, 0x05, 0x00, 0x7f, 0x3b, 0x87, 0x1f,
-	0xd9, 0x4d, 0x43, 0xae, 0x5d, 0x9c, 0x1e, 0xca, 0xb5, 0x32, 0xab, 0x41, 0xf5, 0xe4, 0xc9, 0xa7,
-	0x9d, 0x66, 0x45, 0x52, 0x0f, 0x3b, 0xdf, 0xee, 0x9c, 0x77, 0x9a, 0x55, 0x56, 0x87, 0x85, 0x83,
-	0xe3, 0x93, 0x27, 0x87, 0xcd, 0x05, 0xeb, 0x57, 0xd4, 0x94, 0xe4, 0x20, 0x64, 0x1f, 0x82, 0x39,
-	0x50, 0x30, 0x52, 0x24, 0x6d, 0xdf, 0x02, 0xf1, 0xe3, 0x92, 0x4d, 0x9b, 0x58, 0x1b, 0x16, 0x63,
-	0x73, 0x14, 0xcc, 0xc7, 0x25, 0x3b, 0x26, 0xec, 0x5b, 0xb0, 0x25, 0xef, 0xa6, 0x43, 0x01, 0x24,
-	0xf1, 0x09, 0x1d, 0x74, 0x90, 0x13, 0xb8, 0x37, 0x43, 0xdf, 0xed, 0x59, 0xbf, 0xae, 0xc0, 0x7a,
-	0xe6, 0x24, 0x4a, 0x14, 0x14, 0x11, 0x0f, 0x93, 0x2e, 0x32, 0x39, 0xa0, 0x92, 0xcb, 0x01, 0xef,
-	0xc1, 0x0a, 0xa9, 0x1d, 0xa7, 0x02, 0xcc, 0x13, 0xcb, 0x48, 0x3d, 0xa1, 0x84, 0xf0, 0x45, 0x60,
-	0xc4, 0xe6, 0x4e, 0xa2, 0x81, 0x2f, 0x50, 0x1c, 0x66, 0x8d, 0x26, 0xae, 0xec, 0xa9, 0x05, 0x25,
-	0x74, 0x07, 0x5e, 0xd3, 0xb9, 0xf9, 0xc8, 0xf5, 0x86, 0x94, 0x40, 0xd6, 0xd2, 0xec, 0x1d, 0xb9,
-	0x50, 0x9c, 0x6e, 0x16, 0x6f, 0x9f, 0x6e, 0x6a, 0xb7, 0x4e, 0x37, 0xb2, 0xf5, 0xbe, 0xf2, 0x45,
-	0x97, 0xb7, 0xea, 0xd8, 0x7a, 0xab, 0x0f, 0xeb, 0xcf, 0x71, 0x6d, 0xca, 0x79, 0x87, 0x7d, 0x3d,
-	0x13, 0x37, 0xef, 0xce, 0x88, 0x1b, 0xcd, 0x9b, 0xa9, 0xc0, 0xf9, 0xda, 0xf4, 0xa6, 0x97, 0xf5,
-	0x0c, 0x56, 0x1c, 0x77, 0xa5, 0xf8, 0x6a, 0xef, 0x6f, 0xc3, 0x3b, 0xf9, 0xa8, 0x12, 0x78, 0xca,
-	0x34, 0xac, 0xfe, 0x10, 0xcf, 0x8a, 0xd2, 0x8a, 0xdc, 0x63, 0x0a, 0xdd, 0x84, 0x25, 0x6f, 0xdc,
-	0xe3, 0x4f, 0xb5, 0xe4, 0x09, 0x8a, 0x34, 0x27, 0x29, 0xce, 0x78, 0xb6, 0xfd, 0x7e, 0x5a, 0x27,
-	0x65, 0x6e, 0x79, 0xf0, 0x66, 0x53, 0xa8, 0x63, 0x52, 0xcd, 0x26, 0x12, 0xe6, 0xbc, 0xd8, 0x36,
-	0x80, 0xae, 0x86, 0x7a, 0x62, 0x2c, 0xe0, 0x13, 0x03, 0x29, 0xf2, 0x89, 0xf1, 0x0d, 0x58, 0x13,
-	0x7c, 0xe4, 0x47, 0x3c, 0x1d, 0x7b, 0xe6, 0x4c, 0x85, 0x9b, 0xc8, 0x9c, 0x0a, 0xbe, 0x6d, 0x58,
-	0x26, 0x01, 0x74, 0x3c, 0xc6, 0x78, 0x03, 0x89, 0xe8, 0x06, 0xeb, 0x27, 0x71, 0x3d, 0x44, 0x90,
-	0xa6, 0xaf, 0x6a, 0x20, 0x7b, 0xa4, 0x6a, 0xf8, 0x24, 0x20, 0x0b, 0xa5, 0x6a, 0x77, 0xe8, 0x64,
-	0x25, 0x34, 0xfd, 0x4c, 0x9d, 0xab, 0xf5, 0xa9, 0xc8, 0x59, 0xbf, 0x23, 0x1f, 0x9d, 0x7d, 0x36,
-	0x71, 0xc3, 0x87, 0x7f, 0x10, 0x84, 0xea, 0x98, 0x94, 0x8f, 0x90, 0x30, 0xc7, 0x47, 0x72, 0x93,
-	0xba, 0xff, 0x89, 0x8b, 0x6a, 0x8a, 0x20, 0x61, 0x78, 0x0b, 0x16, 0xf9, 0xb8, 0xa7, 0x96, 0x4c,
-	0xb5, 0x64, 0xf2, 0x71, 0x4f, 0x2e, 0xbc, 0x0b, 0x26, 0xa6, 0x22, 0x6a, 0x4d, 0x74, 0x75, 0x68,
-	0xad, 0x20, 0x19, 0xd6, 0x0a, 0x92, 0xa1, 0xe5, 0xa1, 0x87, 0x62, 0x88, 0x12, 0x0f, 0x91, 0x35,
-	0x29, 0x0f, 0x21, 0x45, 0x6a, 0x30, 0x0f, 0x75, 0x7c, 0x51, 0xdb, 0x79, 0x17, 0x5a, 0xbf, 0xa1,
-	0x57, 0xc7, 0x5e, 0x10, 0x0c, 0x6f, 0x4e, 0xdd, 0x28, 0x79, 0xa3, 0xcd, 0xcd, 0x4b, 0x39, 0xf6,
-	0x9d, 0xa2, 0x82, 0x16, 0x48, 0x06, 0x1e, 0x26, 0x05, 0x8d, 0x08, 0xed, 0x9f, 0x19, 0x60, 0x3e,
-	0x68, 0x59, 0xda, 0x86, 0x65, 0x7a, 0x94, 0x93, 0x8f, 0xa9, 0x33, 0x41, 0x22, 0x5e, 0x84, 0x69,
-	0x59, 0x55, 0xd3, 0x11, 0x47, 0xe9, 0x96, 0xcb, 0x7f, 0xdf, 0xc7, 0xbc, 0x9d, 0xb6, 0xf7, 0xfe,
-	0xb2, 0x9f, 0xf5, 0xdc, 0x80, 0x76, 0x32, 0xa3, 0x3d, 0x9b, 0x5c, 0x8e, 0xfc, 0xde, 0x64, 0xc8,
-	0x1f, 0x7c, 0xce, 0x41, 0x41, 0x98, 0x9a, 0x73, 0x20, 0x65, 0xde, 0x9c, 0x63, 0x1d, 0xea, 0x61,
-	0xac, 0x60, 0x3c, 0xe6, 0x98, 0x12, 0x0a, 0x22, 0xdb, 0x2c, 0x8a, 0xec, 0xbf, 0x1b, 0xd8, 0xb6,
-	0xe6, 0x0c, 0x7e, 0x39, 0x8f, 0xee, 0x5c, 0x57, 0x5e, 0xcd, 0x75, 0xe5, 0x1f, 0x57, 0x6b, 0x95,
-	0x66, 0xd5, 0xce, 0x37, 0xfa, 0xbb, 0xcf, 0xeb, 0xd0, 0x9c, 0xea, 0x73, 0xc6, 0xc5, 0xb5, 0xd7,
-	0xe5, 0xec, 0xbb, 0xd0, 0xcc, 0xfe, 0x4f, 0xc1, 0x36, 0xb5, 0x8a, 0x9c, 0xff, 0xd3, 0xa5, 0xbd,
-	0x35, 0x9b, 0x01, 0x71, 0xb1, 0x4a, 0xb1, 0xe0, 0xf4, 0x34, 0x5f, 0x17, 0x5c, 0xf0, 0x4f, 0x85,
-	0x2e, 0xb8, 0xe8, 0x8f, 0x80, 0x44, 0x70, 0x7a, 0x96, 0xae, 0x0b, 0x2e, 0x98, 0xfb, 0xeb, 0x82,
-	0x8b, 0xc6, 0xf0, 0x56, 0x89, 0x7d, 0x02, 0xcb, 0xda, 0x00, 0x97, 0xad, 0xe7, 0xcd, 0x4c, 0x66,
-	0xd4, 0xed, 0x8d, 0x19, 0xab, 0x59, 0x79, 0xd3, 0x11, 0xb9, 0x2e, 0x2f, 0x3b, 0xc2, 0xd7, 0xe5,
-	0xe5, 0xe6, 0xea, 0x56, 0x89, 0x7d, 0x07, 0x56, 0xf4, 0xf9, 0x1b, 0xd3, 0xb6, 0xe4, 0xc6, 0x8e,
-	0xed, 0xcf, 0xcd, 0x5a, 0x9e, 0x8a, 0xfc, 0x1e, 0xac, 0x66, 0x06, 0xac, 0x2c, 0xbf, 0x49, 0x47,
-	0x72, 0x73, 0xe6, 0x7a, 0x2c, 0xf5, 0xb1, 0xf1, 0x25, 0x83, 0x7d, 0x0b, 0x1a, 0xe9, 0x29, 0x15,
-	0x7b, 0x94, 0xde, 0x96, 0x19, 0xaf, 0xb5, 0xd7, 0x8b, 0x17, 0xb3, 0x96, 0x27, 0x83, 0x12, 0xdd,
-	0xf2, 0xdc, 0x04, 0x4a, 0xb7, 0x3c, 0x3f, 0x5f, 0xb1, 0x4a, 0xac, 0x03, 0x90, 0x3c, 0xb2, 0xd9,
-	0xdb, 0x5a, 0xda, 0x49, 0x4f, 0x2d, 0xda, 0xed, 0xa2, 0xa5, 0xa9, 0x98, 0x4f, 0x11, 0xc0, 0x54,
-	0xb7, 0xa9, 0x03, 0x98, 0xef, 0x87, 0x75, 0x00, 0x0b, 0xda, 0x54, 0x09, 0x60, 0xa2, 0x9e, 0xec,
-	0x67, 0xb2, 0xea, 0xa5, 0x9a, 0xc5, 0xac, 0x7a, 0xe9, 0x16, 0x29, 0xb1, 0x12, 0x0b, 0xb3, 0x2e,
-	0x46, 0xeb, 0x67, 0x74, 0x31, 0x7a, 0x1d, 0xb7, 0x4a, 0xec, 0x0c, 0xf1, 0x4f, 0x8a, 0x8a, 0x8e,
-	0x7f, 0xae, 0xb8, 0xea, 0xf8, 0xe7, 0x6b, 0x91, 0x32, 0xf1, 0x07, 0x38, 0x6a, 0xcd, 0x64, 0x56,
-	0x66, 0xe5, 0x53, 0x40, 0xb6, 0xce, 0xb4, 0xb7, 0xe7, 0xf2, 0xc4, 0x67, 0x5c, 0x9a, 0xea, 0xef,
-	0xe3, 0x2f, 0xff, 0x27, 0x00, 0x00, 0xff, 0xff, 0x97, 0x87, 0xcf, 0x92, 0x68, 0x1e, 0x00, 0x00,
+func init() { proto.RegisterFile("operations.proto", fileDescriptor_operations_3e6454468a1f158c) }
+
+var fileDescriptor_operations_3e6454468a1f158c = []byte{
+	// 1881 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x23, 0x59,
+	0x11, 0x77, 0xdb, 0x4e, 0xc7, 0xae, 0x38, 0x89, 0xf3, 0xf6, 0xcb, 0xeb, 0x99, 0x30, 0xd9, 0xce,
+	0x2e, 0xcc, 0xae, 0x58, 0xcf, 0x6a, 0x40, 0x20, 0x21, 0x2d, 0x68, 0x92, 0x38, 0xcc, 0x2e, 0xcc,
+	0x4e, 0xe8, 0x64, 0x16, 0x84, 0x90, 0x9a, 0x8e, 0xfd, 0x62, 0xb7, 0xb0, 0xdd, 0xbd, 0xaf, 0xdb,
+	0x61, 0x82, 0x10, 0x17, 0x24, 0xae, 0xdc, 0x00, 0x89, 0x33, 0x12, 0x5f, 0xff, 0x00, 0x17, 0x0e,
+	0x1c, 0x10, 0x5c, 0xe1, 0xc0, 0x81, 0x33, 0x57, 0x0e, 0x48, 0x70, 0x46, 0xef, 0x55, 0xf5, 0xc7,
+	0xeb, 0x6e, 0x5b, 0x93, 0x21, 0xd1, 0x8c, 0xd0, 0xde, 0xdc, 0xf5, 0xea, 0xd5, 0xab, 0xfa, 0x55,
+	0xbd, 0xaa, 0x7a, 0x65, 0x68, 0xfb, 0x01, 0x17, 0x6e, 0xe4, 0xf9, 0xb3, 0xb0, 0x17, 0x08, 0x3f,
+	0xf2, 0x99, 0x39, 0xf2, 0x22, 0x77, 0x72, 0xd1, 0x6d, 0x85, 0x63, 0x57, 0xf0, 0x21, 0x52, 0xad,
+	0xdf, 0x19, 0xf0, 0xca, 0xa3, 0x90, 0x8b, 0x7d, 0xc1, 0xdd, 0x88, 0xef, 0x09, 0x77, 0x36, 0x18,
+	0xdb, 0xfc, 0xa3, 0x39, 0x0f, 0x23, 0x76, 0x17, 0x40, 0xf0, 0xc0, 0x0f, 0xbd, 0xc8, 0x17, 0x17,
+	0x1d, 0x63, 0xc7, 0xb8, 0xbd, 0x76, 0x97, 0xf5, 0x50, 0x4c, 0xcf, 0x4e, 0x56, 0xec, 0x0c, 0x17,
+	0xbb, 0x05, 0x6b, 0xa7, 0x4a, 0x88, 0x33, 0x73, 0xa7, 0xbc, 0x53, 0xdd, 0x31, 0x6e, 0xb7, 0x6c,
+	0x40, 0xd2, 0x07, 0xee, 0x94, 0xb3, 0x1d, 0xa8, 0xcf, 0x43, 0x2e, 0x3a, 0x35, 0x25, 0xae, 0x15,
+	0x8b, 0x93, 0x3a, 0xd8, 0x6a, 0x45, 0x8a, 0x08, 0x23, 0x57, 0x44, 0x4e, 0xe0, 0x7b, 0xb3, 0xa8,
+	0x53, 0x47, 0x11, 0x8a, 0x74, 0x24, 0x29, 0x5f, 0x30, 0xff, 0xf5, 0xd3, 0xdb, 0xd5, 0x86, 0x61,
+	0xcd, 0xa0, 0x53, 0x54, 0x3d, 0x0c, 0xfc, 0x59, 0xc8, 0xd9, 0x27, 0xc1, 0xc4, 0x43, 0x49, 0xef,
+	0x8d, 0xf8, 0x20, 0xe2, 0xa3, 0x55, 0xf6, 0x16, 0x6c, 0x05, 0x82, 0x3b, 0x82, 0x0f, 0xb8, 0x77,
+	0xce, 0x1d, 0x2e, 0x84, 0x2f, 0x94, 0xd6, 0x4d, 0x7b, 0x33, 0x10, 0xdc, 0x46, 0x7a, 0x5f, 0x92,
+	0xad, 0x3f, 0x11, 0x56, 0x8f, 0x82, 0xe1, 0xf3, 0x82, 0xd5, 0xcb, 0x60, 0xce, 0xf8, 0x77, 0x05,
+	0x3f, 0x27, 0x98, 0xe8, 0x4b, 0xd2, 0xfd, 0xc9, 0x50, 0xd2, 0x57, 0x90, 0x8e, 0x5f, 0x09, 0x74,
+	0x87, 0x08, 0x9d, 0x6e, 0x09, 0x41, 0x57, 0x0a, 0x89, 0x51, 0x0e, 0xc9, 0xcf, 0x08, 0x92, 0x03,
+	0x3e, 0xe1, 0xcf, 0x07, 0x24, 0x79, 0x13, 0x75, 0xcd, 0x9e, 0xc2, 0xc4, 0x1f, 0x1b, 0xf0, 0x62,
+	0x2a, 0xe8, 0xc4, 0x1d, 0xfd, 0x2f, 0xf6, 0xbd, 0x0a, 0x8d, 0xc8, 0x1d, 0x65, 0x8d, 0x5b, 0x8d,
+	0xdc, 0xd1, 0x25, 0x2d, 0xdb, 0x87, 0x97, 0x72, 0x0a, 0x3d, 0x85, 0x59, 0x7f, 0x21, 0xb3, 0xf0,
+	0xf6, 0x3c, 0x43, 0xb3, 0xd8, 0xa7, 0x60, 0x33, 0x72, 0xc5, 0x88, 0x47, 0x8e, 0xe0, 0xe7, 0x5e,
+	0xe8, 0xf9, 0x33, 0x0a, 0xe6, 0x0d, 0x24, 0xdb, 0x44, 0x65, 0x1d, 0x58, 0x9d, 0xf2, 0x30, 0x74,
+	0x47, 0x9c, 0xa2, 0x3a, 0xfe, 0x4c, 0x90, 0xf9, 0x1e, 0x22, 0x93, 0xb1, 0x89, 0x90, 0xd9, 0x86,
+	0x5a, 0xe4, 0x8e, 0xc8, 0x9a, 0xb5, 0x58, 0x09, 0xc9, 0x21, 0xe9, 0xf2, 0xba, 0xf0, 0xc7, 0x5e,
+	0x18, 0x85, 0x4a, 0xfb, 0x86, 0x4d, 0x5f, 0xe5, 0x80, 0xd6, 0xca, 0x01, 0xfd, 0xbb, 0x01, 0x2f,
+	0xcb, 0xc3, 0x1f, 0x70, 0x31, 0xba, 0x82, 0x9b, 0x10, 0xe3, 0x56, 0x5d, 0x88, 0xdb, 0x0d, 0x68,
+	0x0e, 0xfc, 0xe9, 0xd4, 0x8b, 0x1c, 0x6f, 0x48, 0x4a, 0x35, 0x90, 0xf0, 0xde, 0x50, 0x5a, 0x44,
+	0xf9, 0x8f, 0x12, 0x03, 0xe5, 0xbb, 0x85, 0x18, 0xb2, 0x17, 0x61, 0xc5, 0x0d, 0x82, 0xc9, 0x45,
+	0xc7, 0x54, 0x10, 0xe0, 0x47, 0x82, 0xec, 0x6f, 0xe9, 0xa2, 0x6b, 0xd6, 0x11, 0xb8, 0x9a, 0x22,
+	0x46, 0x4e, 0x91, 0x3d, 0x58, 0xa7, 0x1b, 0x3d, 0x57, 0xc9, 0x86, 0x02, 0x61, 0x3b, 0x36, 0xe8,
+	0x61, 0x5c, 0xa7, 0x50, 0x28, 0x66, 0x24, 0xbb, 0x75, 0x9a, 0xf9, 0x2a, 0x77, 0x43, 0xbd, 0xd4,
+	0x0d, 0xef, 0xd7, 0x1b, 0xd5, 0x76, 0xcd, 0xfa, 0x87, 0x81, 0x91, 0xa0, 0xd4, 0x3d, 0xf1, 0x6d,
+	0x7e, 0x76, 0xbd, 0xbe, 0xd8, 0x06, 0x08, 0xfd, 0xb9, 0x18, 0x70, 0x27, 0x1c, 0xbb, 0xe4, 0x8c,
+	0x26, 0x52, 0x8e, 0xc7, 0xee, 0x42, 0x6f, 0x6c, 0x03, 0x24, 0xa1, 0x7f, 0x46, 0x0e, 0x69, 0xc6,
+	0x51, 0x7f, 0x96, 0x75, 0x96, 0x59, 0x1e, 0xf0, 0x6e, 0x26, 0xe6, 0xc8, 0xcc, 0x27, 0x71, 0xca,
+	0x65, 0xaa, 0xde, 0x0f, 0xe0, 0xa5, 0x52, 0x1f, 0x2d, 0x3f, 0xe1, 0x35, 0x68, 0x49, 0x00, 0x9d,
+	0x81, 0xba, 0x8a, 0x43, 0xba, 0x57, 0x6b, 0x92, 0x86, 0xb7, 0x73, 0xc8, 0xde, 0x80, 0x0d, 0x8a,
+	0x8c, 0x98, 0xa9, 0xa6, 0x98, 0x28, 0x5e, 0x88, 0xcd, 0xfa, 0xa5, 0x01, 0x2f, 0x48, 0x1b, 0x0f,
+	0x0f, 0x9f, 0xd7, 0x4b, 0x95, 0x78, 0xe3, 0x47, 0x94, 0x53, 0x53, 0x55, 0xc9, 0x19, 0x85, 0x4b,
+	0x60, 0x5c, 0xd1, 0x25, 0x58, 0xe0, 0xb3, 0x3f, 0x56, 0x29, 0x11, 0x8e, 0xb9, 0x10, 0x17, 0x47,
+	0xde, 0xe0, 0x3b, 0xd7, 0x8b, 0xda, 0x9b, 0x60, 0x22, 0x48, 0x74, 0xbb, 0xb7, 0x62, 0x9e, 0x2f,
+	0x7b, 0xd1, 0xbe, 0x5a, 0xb0, 0x89, 0x21, 0x5f, 0xe1, 0xeb, 0x85, 0x0a, 0xbf, 0x38, 0x43, 0xbd,
+	0x05, 0x5b, 0xd8, 0x18, 0x66, 0x05, 0xe0, 0xc5, 0xd8, 0x54, 0x0b, 0x7b, 0xa9, 0x94, 0x77, 0xa1,
+	0x8d, 0xbc, 0x19, 0x6b, 0x57, 0x17, 0x5a, 0x8b, 0xdb, 0x53, 0x42, 0xe2, 0xd1, 0xbf, 0x51, 0x52,
+	0xcf, 0x02, 0x79, 0xb5, 0x3e, 0xc5, 0xd8, 0x77, 0x22, 0xc1, 0x73, 0x3e, 0xc5, 0x85, 0x13, 0xc1,
+	0xd1, 0xa7, 0xf2, 0x46, 0x51, 0x64, 0x66, 0xcb, 0xd0, 0x1a, 0xd2, 0x90, 0xe5, 0x12, 0x79, 0xd2,
+	0xfa, 0x43, 0x15, 0xb6, 0x94, 0x07, 0xf9, 0x39, 0x97, 0xa6, 0x7f, 0x1c, 0x1e, 0x4f, 0x11, 0x1e,
+	0x7f, 0x35, 0x80, 0x65, 0x41, 0xfc, 0xff, 0x08, 0x8d, 0x7f, 0x57, 0xe1, 0x86, 0x0a, 0x7a, 0xb5,
+	0xff, 0xd0, 0x9b, 0xf0, 0xf0, 0xde, 0x40, 0xaa, 0x7b, 0x9f, 0xbb, 0x43, 0x2e, 0xd8, 0x21, 0x98,
+	0xae, 0xfa, 0x56, 0x76, 0x6d, 0xdc, 0xed, 0x65, 0x5d, 0xbe, 0x60, 0x53, 0x0f, 0x3f, 0x4e, 0x2e,
+	0x02, 0x6e, 0xd3, 0x6e, 0x99, 0x6b, 0xcf, 0xbc, 0x09, 0x77, 0x02, 0x37, 0x1a, 0x53, 0xdb, 0xd8,
+	0x90, 0x84, 0x23, 0x37, 0x1a, 0xb3, 0x5d, 0x58, 0x0f, 0x64, 0x3f, 0xe8, 0xcf, 0x43, 0x64, 0xa8,
+	0x29, 0x86, 0x56, 0x4c, 0x54, 0x4c, 0xb2, 0x84, 0xb8, 0x21, 0xff, 0xdc, 0x67, 0x9d, 0x81, 0x3f,
+	0x8b, 0x38, 0xbd, 0x16, 0x65, 0x09, 0x51, 0xd4, 0x7d, 0x24, 0xb2, 0x37, 0xa1, 0xcd, 0x1f, 0xf3,
+	0xc1, 0x3c, 0xe2, 0x8e, 0x94, 0x3f, 0xf5, 0x87, 0x18, 0x3c, 0x0d, 0x7b, 0x93, 0xe8, 0x87, 0x44,
+	0x96, 0xc7, 0x7a, 0xb3, 0x33, 0x2e, 0x12, 0x81, 0xd8, 0x0d, 0xb5, 0x14, 0x91, 0xe4, 0x59, 0x8f,
+	0x00, 0x52, 0x73, 0x18, 0x80, 0xb9, 0x6f, 0xf7, 0xef, 0x9d, 0xf4, 0xdb, 0x15, 0xb6, 0x01, 0x80,
+	0xbf, 0x9d, 0x83, 0xf7, 0xec, 0xb6, 0x21, 0xd7, 0x1e, 0x1d, 0x1d, 0xc8, 0xb5, 0x2a, 0x6b, 0x40,
+	0xfd, 0xc1, 0xc3, 0x0f, 0xfb, 0xed, 0x9a, 0xa4, 0x1e, 0xf4, 0xbf, 0xda, 0x3f, 0xe9, 0xb7, 0xeb,
+	0xac, 0x09, 0x2b, 0xfb, 0xf7, 0x1f, 0x3c, 0x3c, 0x68, 0xaf, 0x58, 0x3f, 0xa1, 0xa6, 0xa5, 0x00,
+	0x21, 0x7b, 0x17, 0xcc, 0xb1, 0x82, 0x91, 0x22, 0x69, 0xf7, 0x09, 0x10, 0xbf, 0x5f, 0xb1, 0x69,
+	0x13, 0xeb, 0xc2, 0x6a, 0x6c, 0x8e, 0x82, 0xf9, 0x7e, 0xc5, 0x8e, 0x09, 0x7b, 0x16, 0xec, 0xc8,
+	0x3b, 0xea, 0x50, 0x00, 0x49, 0x7c, 0x42, 0x07, 0x1d, 0xe4, 0x04, 0xee, 0xc5, 0xc4, 0x77, 0x87,
+	0xd6, 0xcf, 0x6b, 0x70, 0x33, 0x77, 0x12, 0x25, 0x0c, 0x8a, 0x88, 0xeb, 0x49, 0x1b, 0xb9, 0x5c,
+	0x50, 0x2b, 0xe4, 0x82, 0x37, 0x60, 0x83, 0xd4, 0x8e, 0x53, 0x02, 0xe6, 0x8b, 0x75, 0xa4, 0x3e,
+	0xa0, 0xc4, 0xf0, 0x69, 0x60, 0xc4, 0xe6, 0xce, 0xa3, 0xb1, 0x2f, 0x50, 0x1c, 0x66, 0x8f, 0x36,
+	0xae, 0xdc, 0x53, 0x0b, 0x4a, 0x68, 0x0f, 0x5e, 0xd0, 0xb9, 0xf9, 0xd4, 0xf5, 0x26, 0x94, 0x48,
+	0xb6, 0xb2, 0xec, 0x7d, 0xb9, 0x50, 0x9e, 0x76, 0x56, 0x9f, 0x3c, 0xed, 0x34, 0x9e, 0x38, 0xed,
+	0xc8, 0x16, 0xfd, 0xcc, 0x17, 0x03, 0xde, 0x69, 0x62, 0x8b, 0xae, 0x3e, 0xac, 0xdf, 0xc7, 0x35,
+	0xaa, 0xe0, 0x1d, 0xf6, 0xc5, 0x5c, 0xdc, 0xbc, 0xbe, 0x20, 0x6e, 0x34, 0x6f, 0x66, 0x02, 0xe7,
+	0xf3, 0xc9, 0x4d, 0xaf, 0xea, 0x19, 0xac, 0x3c, 0xee, 0x2a, 0xf1, 0xd5, 0x8e, 0x13, 0xe4, 0xde,
+	0x2e, 0xbc, 0x56, 0x8c, 0x2e, 0x81, 0xa7, 0x25, 0xe1, 0xf5, 0xeb, 0x78, 0x06, 0x95, 0x55, 0xe8,
+	0x0a, 0x53, 0xe9, 0x2d, 0x58, 0xf3, 0x66, 0x43, 0xfe, 0x58, 0x4b, 0xa2, 0xa0, 0x48, 0x4b, 0x92,
+	0xe3, 0x82, 0x67, 0xde, 0x6f, 0x92, 0xba, 0x29, 0x73, 0xcc, 0xb5, 0x37, 0xa3, 0x42, 0x1d, 0x93,
+	0x69, 0x46, 0x91, 0xb0, 0xe4, 0x85, 0xb7, 0x0d, 0x74, 0x45, 0xd4, 0x53, 0x64, 0x05, 0x9f, 0x22,
+	0x48, 0x91, 0x4f, 0x91, 0x2f, 0xc1, 0x96, 0xe0, 0x53, 0x3f, 0xe2, 0xd9, 0x18, 0x34, 0x17, 0x2a,
+	0xdc, 0x46, 0xe6, 0x4c, 0x10, 0xee, 0xc2, 0x3a, 0x09, 0xa0, 0xe3, 0x31, 0xd6, 0x5b, 0x48, 0xdc,
+	0xd3, 0x3b, 0xe2, 0xef, 0xc7, 0xf5, 0x11, 0xc1, 0x4a, 0x5e, 0xe3, 0x40, 0x76, 0x49, 0x15, 0xf1,
+	0xe9, 0x40, 0x96, 0x4a, 0x15, 0x2f, 0xd1, 0xe9, 0x4a, 0x88, 0x46, 0xb9, 0xba, 0xd7, 0x18, 0x51,
+	0xd1, 0xb3, 0x7e, 0x45, 0xbe, 0x3a, 0xfe, 0x68, 0xee, 0x86, 0xd7, 0xff, 0x70, 0x08, 0xd5, 0x31,
+	0x19, 0x5f, 0x21, 0x61, 0x89, 0xaf, 0xe4, 0x26, 0x95, 0x0f, 0x52, 0x57, 0x35, 0x14, 0x41, 0xc2,
+	0xf0, 0x0a, 0xac, 0xf2, 0xd9, 0x50, 0x2d, 0x99, 0x6a, 0xc9, 0xe4, 0xb3, 0xa1, 0x5c, 0x78, 0x1d,
+	0x4c, 0x4c, 0x4d, 0xd4, 0xb2, 0xe8, 0xea, 0xd0, 0x5a, 0x49, 0x72, 0x6c, 0x94, 0x24, 0xc7, 0xc4,
+	0x53, 0x1e, 0x7a, 0x2a, 0x86, 0x2a, 0xf5, 0x14, 0x59, 0x95, 0xf1, 0x14, 0x52, 0xa4, 0x26, 0xcb,
+	0xd0, 0xc7, 0x97, 0xb8, 0x5d, 0x74, 0xa5, 0xf5, 0x0b, 0x7a, 0x9d, 0xdc, 0x0b, 0x82, 0xc9, 0xc5,
+	0x91, 0x1b, 0xa5, 0x6f, 0xba, 0xa5, 0xf9, 0xaa, 0xc0, 0xde, 0x2b, 0x2b, 0x74, 0x81, 0x64, 0xe0,
+	0x61, 0x5a, 0xe8, 0x88, 0xd0, 0xfd, 0xa1, 0x01, 0xe6, 0xb5, 0x96, 0xab, 0x5d, 0x58, 0xa7, 0xc7,
+	0x3c, 0xf9, 0x9a, 0x3a, 0x16, 0x24, 0xea, 0x17, 0x23, 0x29, 0xbb, 0x6a, 0xca, 0xe2, 0x28, 0x1d,
+	0x0b, 0x79, 0xf1, 0x5b, 0x98, 0xd7, 0xb3, 0x76, 0x5f, 0x5d, 0x56, 0xb4, 0xfe, 0x63, 0x40, 0x37,
+	0x9d, 0x01, 0x1f, 0xcf, 0x4f, 0xa7, 0xfe, 0x70, 0x3e, 0xe1, 0xd7, 0x3e, 0x27, 0xa1, 0xa0, 0xcc,
+	0xcc, 0x49, 0x90, 0xb2, 0x6c, 0x4e, 0x72, 0x13, 0x9a, 0x61, 0xac, 0x60, 0x3c, 0x26, 0x49, 0x08,
+	0x25, 0x91, 0x6e, 0x2e, 0x8b, 0xf4, 0x3f, 0x1b, 0xd8, 0xde, 0x16, 0x0c, 0x7f, 0x36, 0x8f, 0xf5,
+	0x42, 0xf7, 0x5e, 0x2f, 0x74, 0xef, 0xef, 0xd7, 0x1b, 0xb5, 0x76, 0xdd, 0x2e, 0x3e, 0x08, 0xee,
+	0xfe, 0xb3, 0x09, 0xed, 0x44, 0x9f, 0x63, 0x2e, 0xce, 0xbd, 0x01, 0x67, 0x5f, 0x87, 0x76, 0xfe,
+	0x7f, 0x11, 0x76, 0x4b, 0xab, 0xdc, 0xc5, 0x3f, 0x7b, 0xba, 0x3b, 0x8b, 0x19, 0x10, 0x17, 0xab,
+	0x12, 0x0b, 0xce, 0xfe, 0x6b, 0xa0, 0x0b, 0x2e, 0xf9, 0x67, 0x44, 0x17, 0x5c, 0xf6, 0x87, 0x43,
+	0x2a, 0x38, 0x3b, 0xab, 0xd7, 0x05, 0x97, 0xfc, 0xbf, 0xa0, 0x0b, 0x2e, 0x1b, 0xf3, 0x5b, 0x15,
+	0xf6, 0x01, 0xac, 0x6b, 0x03, 0x61, 0x76, 0xb3, 0x68, 0x66, 0x3a, 0xfb, 0xee, 0x6e, 0x2f, 0x58,
+	0xcd, 0xcb, 0x4b, 0x46, 0xef, 0xba, 0xbc, 0xfc, 0x5f, 0x04, 0xba, 0xbc, 0xc2, 0xbc, 0xde, 0xaa,
+	0xb0, 0xaf, 0xc1, 0x86, 0x3e, 0xbf, 0x63, 0xda, 0x96, 0xc2, 0xf8, 0xb2, 0xfb, 0x89, 0x45, 0xcb,
+	0x89, 0xc8, 0x6f, 0xc0, 0x66, 0x6e, 0x50, 0xcb, 0x8a, 0x9b, 0x74, 0x24, 0x6f, 0x2d, 0x5c, 0x8f,
+	0xa5, 0xde, 0x36, 0xde, 0x31, 0xd8, 0x57, 0xa0, 0x95, 0x9d, 0x6e, 0xb1, 0x1b, 0xd9, 0x6d, 0xb9,
+	0xf1, 0x5c, 0xf7, 0x66, 0xf9, 0x62, 0xde, 0xf2, 0x74, 0xb0, 0xa2, 0x5b, 0x5e, 0x98, 0x5c, 0xe9,
+	0x96, 0x17, 0xe7, 0x31, 0x56, 0x85, 0xf5, 0x01, 0xd2, 0xc7, 0x38, 0x7b, 0x55, 0x4b, 0x3f, 0xd9,
+	0x29, 0x47, 0xb7, 0x5b, 0xb6, 0x94, 0x88, 0xf9, 0x10, 0x01, 0xcc, 0x74, 0xa3, 0x3a, 0x80, 0xc5,
+	0xbe, 0x59, 0x07, 0xb0, 0xa4, 0x8d, 0x95, 0x00, 0xa6, 0xea, 0xc9, 0x3e, 0x27, 0xaf, 0x5e, 0xa6,
+	0x99, 0xcc, 0xab, 0x97, 0x6d, 0x9d, 0x52, 0x2b, 0xb1, 0x50, 0xeb, 0x62, 0xb4, 0x3e, 0x47, 0x17,
+	0xa3, 0xd7, 0x75, 0xab, 0xc2, 0x8e, 0x11, 0xff, 0xb4, 0xb8, 0xe8, 0xf8, 0x17, 0x8a, 0xad, 0x8e,
+	0x7f, 0xb1, 0x26, 0x29, 0x13, 0xbf, 0x8d, 0xa3, 0xda, 0x5c, 0x66, 0x65, 0x56, 0x31, 0x05, 0xe4,
+	0xeb, 0x4d, 0x77, 0x77, 0x29, 0x4f, 0x7c, 0xc6, 0xde, 0x3b, 0xdf, 0x94, 0x7c, 0x13, 0xf7, 0xb4,
+	0x37, 0xf0, 0xa7, 0x77, 0xf0, 0xe7, 0xdb, 0xbe, 0x18, 0xdd, 0xc1, 0xdd, 0x6f, 0xab, 0x7f, 0xb5,
+	0xef, 0x8c, 0x7c, 0xfa, 0x0e, 0x4e, 0x4f, 0x4d, 0x45, 0xfa, 0xcc, 0x7f, 0x03, 0x00, 0x00, 0xff,
+	0xff, 0xcd, 0x80, 0x54, 0x9c, 0x12, 0x1f, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ref.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ref.pb.go
index 465b675e9c7603a350cf2546666d3dd901ce6bad..d5e8be7cf60d38fe8469b6516aaeda7c2bccbfe7 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ref.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ref.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: ref.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -47,7 +47,7 @@ func (x FindLocalBranchesRequest_SortBy) String() string {
 	return proto.EnumName(FindLocalBranchesRequest_SortBy_name, int32(x))
 }
 func (FindLocalBranchesRequest_SortBy) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{10, 0}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{10, 0}
 }
 
 type CreateBranchResponse_Status int32
@@ -76,7 +76,7 @@ func (x CreateBranchResponse_Status) String() string {
 	return proto.EnumName(CreateBranchResponse_Status_name, int32(x))
 }
 func (CreateBranchResponse_Status) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{21, 0}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{21, 0}
 }
 
 type ListNewBlobsRequest struct {
@@ -94,7 +94,7 @@ func (m *ListNewBlobsRequest) Reset()         { *m = ListNewBlobsRequest{} }
 func (m *ListNewBlobsRequest) String() string { return proto.CompactTextString(m) }
 func (*ListNewBlobsRequest) ProtoMessage()    {}
 func (*ListNewBlobsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{0}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{0}
 }
 func (m *ListNewBlobsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListNewBlobsRequest.Unmarshal(m, b)
@@ -146,7 +146,7 @@ func (m *ListNewBlobsResponse) Reset()         { *m = ListNewBlobsResponse{} }
 func (m *ListNewBlobsResponse) String() string { return proto.CompactTextString(m) }
 func (*ListNewBlobsResponse) ProtoMessage()    {}
 func (*ListNewBlobsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{1}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{1}
 }
 func (m *ListNewBlobsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListNewBlobsResponse.Unmarshal(m, b)
@@ -184,7 +184,7 @@ func (m *FindDefaultBranchNameRequest) Reset()         { *m = FindDefaultBranchN
 func (m *FindDefaultBranchNameRequest) String() string { return proto.CompactTextString(m) }
 func (*FindDefaultBranchNameRequest) ProtoMessage()    {}
 func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{2}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{2}
 }
 func (m *FindDefaultBranchNameRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindDefaultBranchNameRequest.Unmarshal(m, b)
@@ -222,7 +222,7 @@ func (m *FindDefaultBranchNameResponse) Reset()         { *m = FindDefaultBranch
 func (m *FindDefaultBranchNameResponse) String() string { return proto.CompactTextString(m) }
 func (*FindDefaultBranchNameResponse) ProtoMessage()    {}
 func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{3}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{3}
 }
 func (m *FindDefaultBranchNameResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindDefaultBranchNameResponse.Unmarshal(m, b)
@@ -260,7 +260,7 @@ func (m *FindAllBranchNamesRequest) Reset()         { *m = FindAllBranchNamesReq
 func (m *FindAllBranchNamesRequest) String() string { return proto.CompactTextString(m) }
 func (*FindAllBranchNamesRequest) ProtoMessage()    {}
 func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{4}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{4}
 }
 func (m *FindAllBranchNamesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllBranchNamesRequest.Unmarshal(m, b)
@@ -298,7 +298,7 @@ func (m *FindAllBranchNamesResponse) Reset()         { *m = FindAllBranchNamesRe
 func (m *FindAllBranchNamesResponse) String() string { return proto.CompactTextString(m) }
 func (*FindAllBranchNamesResponse) ProtoMessage()    {}
 func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{5}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{5}
 }
 func (m *FindAllBranchNamesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllBranchNamesResponse.Unmarshal(m, b)
@@ -336,7 +336,7 @@ func (m *FindAllTagNamesRequest) Reset()         { *m = FindAllTagNamesRequest{}
 func (m *FindAllTagNamesRequest) String() string { return proto.CompactTextString(m) }
 func (*FindAllTagNamesRequest) ProtoMessage()    {}
 func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{6}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{6}
 }
 func (m *FindAllTagNamesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllTagNamesRequest.Unmarshal(m, b)
@@ -374,7 +374,7 @@ func (m *FindAllTagNamesResponse) Reset()         { *m = FindAllTagNamesResponse
 func (m *FindAllTagNamesResponse) String() string { return proto.CompactTextString(m) }
 func (*FindAllTagNamesResponse) ProtoMessage()    {}
 func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{7}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{7}
 }
 func (m *FindAllTagNamesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllTagNamesResponse.Unmarshal(m, b)
@@ -416,7 +416,7 @@ func (m *FindRefNameRequest) Reset()         { *m = FindRefNameRequest{} }
 func (m *FindRefNameRequest) String() string { return proto.CompactTextString(m) }
 func (*FindRefNameRequest) ProtoMessage()    {}
 func (*FindRefNameRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{8}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{8}
 }
 func (m *FindRefNameRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindRefNameRequest.Unmarshal(m, b)
@@ -469,7 +469,7 @@ func (m *FindRefNameResponse) Reset()         { *m = FindRefNameResponse{} }
 func (m *FindRefNameResponse) String() string { return proto.CompactTextString(m) }
 func (*FindRefNameResponse) ProtoMessage()    {}
 func (*FindRefNameResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{9}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{9}
 }
 func (m *FindRefNameResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindRefNameResponse.Unmarshal(m, b)
@@ -508,7 +508,7 @@ func (m *FindLocalBranchesRequest) Reset()         { *m = FindLocalBranchesReque
 func (m *FindLocalBranchesRequest) String() string { return proto.CompactTextString(m) }
 func (*FindLocalBranchesRequest) ProtoMessage()    {}
 func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{10}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{10}
 }
 func (m *FindLocalBranchesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindLocalBranchesRequest.Unmarshal(m, b)
@@ -553,7 +553,7 @@ func (m *FindLocalBranchesResponse) Reset()         { *m = FindLocalBranchesResp
 func (m *FindLocalBranchesResponse) String() string { return proto.CompactTextString(m) }
 func (*FindLocalBranchesResponse) ProtoMessage()    {}
 func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{11}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{11}
 }
 func (m *FindLocalBranchesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindLocalBranchesResponse.Unmarshal(m, b)
@@ -595,7 +595,7 @@ func (m *FindLocalBranchResponse) Reset()         { *m = FindLocalBranchResponse
 func (m *FindLocalBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*FindLocalBranchResponse) ProtoMessage()    {}
 func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{12}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{12}
 }
 func (m *FindLocalBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindLocalBranchResponse.Unmarshal(m, b)
@@ -663,7 +663,7 @@ func (m *FindLocalBranchCommitAuthor) Reset()         { *m = FindLocalBranchComm
 func (m *FindLocalBranchCommitAuthor) String() string { return proto.CompactTextString(m) }
 func (*FindLocalBranchCommitAuthor) ProtoMessage()    {}
 func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{13}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{13}
 }
 func (m *FindLocalBranchCommitAuthor) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindLocalBranchCommitAuthor.Unmarshal(m, b)
@@ -720,7 +720,7 @@ func (m *FindAllBranchesRequest) Reset()         { *m = FindAllBranchesRequest{}
 func (m *FindAllBranchesRequest) String() string { return proto.CompactTextString(m) }
 func (*FindAllBranchesRequest) ProtoMessage()    {}
 func (*FindAllBranchesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{14}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{14}
 }
 func (m *FindAllBranchesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllBranchesRequest.Unmarshal(m, b)
@@ -772,7 +772,7 @@ func (m *FindAllBranchesResponse) Reset()         { *m = FindAllBranchesResponse
 func (m *FindAllBranchesResponse) String() string { return proto.CompactTextString(m) }
 func (*FindAllBranchesResponse) ProtoMessage()    {}
 func (*FindAllBranchesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{15}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{15}
 }
 func (m *FindAllBranchesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllBranchesResponse.Unmarshal(m, b)
@@ -811,7 +811,7 @@ func (m *FindAllBranchesResponse_Branch) Reset()         { *m = FindAllBranchesR
 func (m *FindAllBranchesResponse_Branch) String() string { return proto.CompactTextString(m) }
 func (*FindAllBranchesResponse_Branch) ProtoMessage()    {}
 func (*FindAllBranchesResponse_Branch) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{15, 0}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{15, 0}
 }
 func (m *FindAllBranchesResponse_Branch) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllBranchesResponse_Branch.Unmarshal(m, b)
@@ -856,7 +856,7 @@ func (m *FindAllTagsRequest) Reset()         { *m = FindAllTagsRequest{} }
 func (m *FindAllTagsRequest) String() string { return proto.CompactTextString(m) }
 func (*FindAllTagsRequest) ProtoMessage()    {}
 func (*FindAllTagsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{16}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{16}
 }
 func (m *FindAllTagsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllTagsRequest.Unmarshal(m, b)
@@ -894,7 +894,7 @@ func (m *FindAllTagsResponse) Reset()         { *m = FindAllTagsResponse{} }
 func (m *FindAllTagsResponse) String() string { return proto.CompactTextString(m) }
 func (*FindAllTagsResponse) ProtoMessage()    {}
 func (*FindAllTagsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{17}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{17}
 }
 func (m *FindAllTagsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllTagsResponse.Unmarshal(m, b)
@@ -934,7 +934,7 @@ func (m *RefExistsRequest) Reset()         { *m = RefExistsRequest{} }
 func (m *RefExistsRequest) String() string { return proto.CompactTextString(m) }
 func (*RefExistsRequest) ProtoMessage()    {}
 func (*RefExistsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{18}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{18}
 }
 func (m *RefExistsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RefExistsRequest.Unmarshal(m, b)
@@ -979,7 +979,7 @@ func (m *RefExistsResponse) Reset()         { *m = RefExistsResponse{} }
 func (m *RefExistsResponse) String() string { return proto.CompactTextString(m) }
 func (*RefExistsResponse) ProtoMessage()    {}
 func (*RefExistsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{19}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{19}
 }
 func (m *RefExistsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RefExistsResponse.Unmarshal(m, b)
@@ -1019,7 +1019,7 @@ func (m *CreateBranchRequest) Reset()         { *m = CreateBranchRequest{} }
 func (m *CreateBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateBranchRequest) ProtoMessage()    {}
 func (*CreateBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{20}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{20}
 }
 func (m *CreateBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateBranchRequest.Unmarshal(m, b)
@@ -1072,7 +1072,7 @@ func (m *CreateBranchResponse) Reset()         { *m = CreateBranchResponse{} }
 func (m *CreateBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateBranchResponse) ProtoMessage()    {}
 func (*CreateBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{21}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{21}
 }
 func (m *CreateBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateBranchResponse.Unmarshal(m, b)
@@ -1118,7 +1118,7 @@ func (m *DeleteBranchRequest) Reset()         { *m = DeleteBranchRequest{} }
 func (m *DeleteBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*DeleteBranchRequest) ProtoMessage()    {}
 func (*DeleteBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{22}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{22}
 }
 func (m *DeleteBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteBranchRequest.Unmarshal(m, b)
@@ -1163,7 +1163,7 @@ func (m *DeleteBranchResponse) Reset()         { *m = DeleteBranchResponse{} }
 func (m *DeleteBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*DeleteBranchResponse) ProtoMessage()    {}
 func (*DeleteBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{23}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{23}
 }
 func (m *DeleteBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteBranchResponse.Unmarshal(m, b)
@@ -1196,7 +1196,7 @@ func (m *FindBranchRequest) Reset()         { *m = FindBranchRequest{} }
 func (m *FindBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*FindBranchRequest) ProtoMessage()    {}
 func (*FindBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{24}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{24}
 }
 func (m *FindBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindBranchRequest.Unmarshal(m, b)
@@ -1241,7 +1241,7 @@ func (m *FindBranchResponse) Reset()         { *m = FindBranchResponse{} }
 func (m *FindBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*FindBranchResponse) ProtoMessage()    {}
 func (*FindBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{25}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{25}
 }
 func (m *FindBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindBranchResponse.Unmarshal(m, b)
@@ -1282,7 +1282,7 @@ func (m *DeleteRefsRequest) Reset()         { *m = DeleteRefsRequest{} }
 func (m *DeleteRefsRequest) String() string { return proto.CompactTextString(m) }
 func (*DeleteRefsRequest) ProtoMessage()    {}
 func (*DeleteRefsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{26}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{26}
 }
 func (m *DeleteRefsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteRefsRequest.Unmarshal(m, b)
@@ -1334,7 +1334,7 @@ func (m *DeleteRefsResponse) Reset()         { *m = DeleteRefsResponse{} }
 func (m *DeleteRefsResponse) String() string { return proto.CompactTextString(m) }
 func (*DeleteRefsResponse) ProtoMessage()    {}
 func (*DeleteRefsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{27}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{27}
 }
 func (m *DeleteRefsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteRefsResponse.Unmarshal(m, b)
@@ -1378,7 +1378,7 @@ func (m *ListBranchNamesContainingCommitRequest) Reset() {
 func (m *ListBranchNamesContainingCommitRequest) String() string { return proto.CompactTextString(m) }
 func (*ListBranchNamesContainingCommitRequest) ProtoMessage()    {}
 func (*ListBranchNamesContainingCommitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{28}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{28}
 }
 func (m *ListBranchNamesContainingCommitRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListBranchNamesContainingCommitRequest.Unmarshal(m, b)
@@ -1432,7 +1432,7 @@ func (m *ListBranchNamesContainingCommitResponse) Reset() {
 func (m *ListBranchNamesContainingCommitResponse) String() string { return proto.CompactTextString(m) }
 func (*ListBranchNamesContainingCommitResponse) ProtoMessage()    {}
 func (*ListBranchNamesContainingCommitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{29}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{29}
 }
 func (m *ListBranchNamesContainingCommitResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListBranchNamesContainingCommitResponse.Unmarshal(m, b)
@@ -1474,7 +1474,7 @@ func (m *ListTagNamesContainingCommitRequest) Reset()         { *m = ListTagName
 func (m *ListTagNamesContainingCommitRequest) String() string { return proto.CompactTextString(m) }
 func (*ListTagNamesContainingCommitRequest) ProtoMessage()    {}
 func (*ListTagNamesContainingCommitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{30}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{30}
 }
 func (m *ListTagNamesContainingCommitRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListTagNamesContainingCommitRequest.Unmarshal(m, b)
@@ -1526,7 +1526,7 @@ func (m *ListTagNamesContainingCommitResponse) Reset()         { *m = ListTagNam
 func (m *ListTagNamesContainingCommitResponse) String() string { return proto.CompactTextString(m) }
 func (*ListTagNamesContainingCommitResponse) ProtoMessage()    {}
 func (*ListTagNamesContainingCommitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{31}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{31}
 }
 func (m *ListTagNamesContainingCommitResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListTagNamesContainingCommitResponse.Unmarshal(m, b)
@@ -1565,7 +1565,7 @@ func (m *GetTagMessagesRequest) Reset()         { *m = GetTagMessagesRequest{} }
 func (m *GetTagMessagesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetTagMessagesRequest) ProtoMessage()    {}
 func (*GetTagMessagesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{32}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{32}
 }
 func (m *GetTagMessagesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetTagMessagesRequest.Unmarshal(m, b)
@@ -1612,7 +1612,7 @@ func (m *GetTagMessagesResponse) Reset()         { *m = GetTagMessagesResponse{}
 func (m *GetTagMessagesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetTagMessagesResponse) ProtoMessage()    {}
 func (*GetTagMessagesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{33}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{33}
 }
 func (m *GetTagMessagesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetTagMessagesResponse.Unmarshal(m, b)
@@ -1658,7 +1658,7 @@ func (m *ListNewCommitsRequest) Reset()         { *m = ListNewCommitsRequest{} }
 func (m *ListNewCommitsRequest) String() string { return proto.CompactTextString(m) }
 func (*ListNewCommitsRequest) ProtoMessage()    {}
 func (*ListNewCommitsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{34}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{34}
 }
 func (m *ListNewCommitsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListNewCommitsRequest.Unmarshal(m, b)
@@ -1703,7 +1703,7 @@ func (m *ListNewCommitsResponse) Reset()         { *m = ListNewCommitsResponse{}
 func (m *ListNewCommitsResponse) String() string { return proto.CompactTextString(m) }
 func (*ListNewCommitsResponse) ProtoMessage()    {}
 func (*ListNewCommitsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{35}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{35}
 }
 func (m *ListNewCommitsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListNewCommitsResponse.Unmarshal(m, b)
@@ -1742,7 +1742,7 @@ func (m *FindAllRemoteBranchesRequest) Reset()         { *m = FindAllRemoteBranc
 func (m *FindAllRemoteBranchesRequest) String() string { return proto.CompactTextString(m) }
 func (*FindAllRemoteBranchesRequest) ProtoMessage()    {}
 func (*FindAllRemoteBranchesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{36}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{36}
 }
 func (m *FindAllRemoteBranchesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllRemoteBranchesRequest.Unmarshal(m, b)
@@ -1787,7 +1787,7 @@ func (m *FindAllRemoteBranchesResponse) Reset()         { *m = FindAllRemoteBran
 func (m *FindAllRemoteBranchesResponse) String() string { return proto.CompactTextString(m) }
 func (*FindAllRemoteBranchesResponse) ProtoMessage()    {}
 func (*FindAllRemoteBranchesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ref_15e26c5c2600d751, []int{37}
+	return fileDescriptor_ref_a3b568a6c89846e1, []int{37}
 }
 func (m *FindAllRemoteBranchesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllRemoteBranchesResponse.Unmarshal(m, b)
@@ -2795,105 +2795,108 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ref.proto",
 }
 
-func init() { proto.RegisterFile("ref.proto", fileDescriptor_ref_15e26c5c2600d751) }
-
-var fileDescriptor_ref_15e26c5c2600d751 = []byte{
-	// 1539 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x5b, 0x6f, 0xdb, 0xc6,
-	0x12, 0x36, 0x65, 0x5b, 0x96, 0x46, 0x8a, 0x4c, 0xaf, 0x2f, 0x51, 0xe8, 0x24, 0x76, 0x36, 0x37,
-	0xe7, 0x24, 0x90, 0xcf, 0x51, 0x70, 0xfa, 0xd2, 0x02, 0xad, 0x6c, 0xab, 0x89, 0x13, 0xc7, 0x36,
-	0x56, 0x6a, 0x92, 0xa2, 0x2d, 0x08, 0xca, 0x5a, 0xd1, 0x2c, 0x28, 0x51, 0x25, 0x57, 0x71, 0x0c,
-	0x34, 0x7d, 0x2c, 0x50, 0xb4, 0x40, 0xdf, 0xfa, 0x13, 0xfa, 0x57, 0xfa, 0xd0, 0x97, 0xfe, 0xa4,
-	0x82, 0xbb, 0xcb, 0x9b, 0x44, 0xc9, 0x46, 0xd5, 0xb4, 0x4f, 0xd2, 0xce, 0xce, 0x7c, 0x73, 0xd9,
-	0xd9, 0x99, 0x59, 0x42, 0xde, 0xa5, 0x9d, 0x4a, 0xdf, 0x75, 0x98, 0x83, 0xb2, 0xa6, 0xc5, 0x0c,
-	0xfb, 0x5c, 0x83, 0x96, 0xed, 0xb4, 0x04, 0x4d, 0x2b, 0x7a, 0xa7, 0x86, 0x4b, 0xdb, 0x72, 0xb5,
-	0x61, 0x3a, 0x8e, 0x69, 0xd3, 0x6d, 0xbe, 0x6a, 0x0d, 0x3a, 0xdb, 0xcc, 0xea, 0x52, 0x8f, 0x19,
-	0xdd, 0xbe, 0x60, 0xc0, 0xdf, 0xc2, 0xf2, 0x81, 0xe5, 0xb1, 0x43, 0x7a, 0xb6, 0x63, 0x3b, 0x2d,
-	0x8f, 0xd0, 0x6f, 0x06, 0xd4, 0x63, 0xa8, 0x0a, 0xe0, 0xd2, 0xbe, 0xe3, 0x59, 0xcc, 0x71, 0xcf,
-	0xcb, 0xca, 0xa6, 0xb2, 0x55, 0xa8, 0xa2, 0x8a, 0x50, 0x57, 0x21, 0xe1, 0x0e, 0x89, 0x71, 0xa1,
-	0x75, 0xc8, 0x9f, 0x38, 0xdd, 0xae, 0xc5, 0x74, 0xab, 0x5d, 0xce, 0x6c, 0x2a, 0x5b, 0x79, 0x92,
-	0x13, 0x84, 0xfd, 0x36, 0x5a, 0x81, 0x79, 0xdb, 0xea, 0x5a, 0xac, 0x3c, 0xbb, 0xa9, 0x6c, 0x5d,
-	0x21, 0x62, 0x81, 0x5f, 0xc1, 0x4a, 0x52, 0xbb, 0xd7, 0x77, 0x7a, 0x1e, 0x45, 0x1f, 0x83, 0xda,
-	0xa3, 0x67, 0xba, 0xef, 0x96, 0xee, 0xb4, 0xbe, 0xa6, 0x27, 0xcc, 0x2b, 0x2b, 0x9b, 0xb3, 0x5b,
-	0x85, 0xea, 0x6a, 0x60, 0x84, 0x94, 0x39, 0xe2, 0xbb, 0xa4, 0xd4, 0x8b, 0x2f, 0x3d, 0x4c, 0xe0,
-	0xfa, 0xa7, 0x56, 0xaf, 0xbd, 0x47, 0x3b, 0xc6, 0xc0, 0x66, 0x3b, 0xae, 0xd1, 0x3b, 0x39, 0x3d,
-	0x34, 0xba, 0x74, 0x0a, 0xff, 0xf0, 0x63, 0xb8, 0x31, 0x06, 0x53, 0x5a, 0x8d, 0x60, 0xae, 0x67,
-	0x74, 0x29, 0x87, 0x2b, 0x12, 0xfe, 0x1f, 0x1f, 0xc1, 0x35, 0x5f, 0xa8, 0x66, 0xdb, 0x91, 0xc0,
-	0x34, 0x51, 0xc6, 0x55, 0xd0, 0xd2, 0x00, 0xa5, 0x09, 0x2b, 0x30, 0xef, 0xab, 0x15, 0xd1, 0x2a,
-	0x12, 0xb1, 0xc0, 0x07, 0xb0, 0x26, 0x65, 0x9a, 0x86, 0x39, 0xb5, 0x05, 0xdb, 0x70, 0x75, 0x04,
-	0x6d, 0xa2, 0xfa, 0x77, 0x80, 0x7c, 0x01, 0x42, 0x3b, 0x53, 0x1e, 0xc1, 0xe4, 0x14, 0x5b, 0x83,
-	0x6c, 0xdf, 0xa5, 0x1d, 0xeb, 0x2d, 0xcf, 0xb1, 0x22, 0x91, 0x2b, 0xfc, 0x00, 0x96, 0x13, 0xea,
-	0x27, 0x9c, 0xd6, 0x6f, 0x0a, 0x94, 0x7d, 0xde, 0x03, 0xe7, 0xc4, 0x90, 0xf1, 0x9d, 0x2a, 0x56,
-	0xe8, 0x13, 0x58, 0xf0, 0x1c, 0x97, 0xe9, 0xad, 0x73, 0x6e, 0x6e, 0xa9, 0x7a, 0x3f, 0x10, 0x18,
-	0xa7, 0xa6, 0xd2, 0x70, 0x5c, 0xb6, 0x73, 0x4e, 0xb2, 0x1e, 0xff, 0xc5, 0xff, 0x87, 0xac, 0xa0,
-	0xa0, 0x1c, 0xcc, 0x1d, 0xd6, 0x5e, 0xd4, 0xd5, 0x19, 0xb4, 0x08, 0x85, 0xcf, 0x8e, 0xf7, 0x6a,
-	0xcd, 0xfa, 0x9e, 0x5e, 0x6b, 0xec, 0xaa, 0x0a, 0x52, 0xa1, 0x18, 0x10, 0xf6, 0xea, 0x8d, 0x5d,
-	0x35, 0x83, 0x5f, 0x8b, 0xbc, 0x1b, 0xd2, 0x20, 0x5d, 0xff, 0x10, 0x72, 0x2d, 0x49, 0x93, 0xd7,
-	0x6a, 0x63, 0x8c, 0x59, 0x81, 0x08, 0x09, 0x05, 0xf0, 0x8f, 0x19, 0x71, 0xfe, 0x29, 0x5c, 0x69,
-	0x31, 0x9d, 0x7c, 0x66, 0x77, 0xa1, 0x24, 0x37, 0xbd, 0x01, 0xbf, 0xba, 0xf2, 0xec, 0xae, 0x08,
-	0x6a, 0x43, 0x10, 0xd1, 0x53, 0x90, 0x04, 0xdd, 0x18, 0xb0, 0x53, 0xc7, 0x2d, 0xcf, 0xf1, 0xe8,
-	0xdf, 0x1e, 0x63, 0xf5, 0x2e, 0xe7, 0xad, 0x71, 0x56, 0x52, 0x3c, 0x89, 0xad, 0xd0, 0x21, 0xa8,
-	0x12, 0x49, 0xfc, 0x30, 0xea, 0x96, 0xe7, 0x2f, 0x0f, 0xb6, 0x28, 0xa4, 0x76, 0x03, 0x59, 0x7c,
-	0x06, 0xeb, 0x13, 0xf8, 0x53, 0x03, 0xb2, 0x02, 0xf3, 0xb4, 0x6b, 0x58, 0x36, 0x0f, 0x46, 0x91,
-	0x88, 0x05, 0xaa, 0xc0, 0x5c, 0xdb, 0x60, 0x94, 0xfb, 0x5f, 0xa8, 0x6a, 0x15, 0x51, 0xb8, 0x2b,
-	0x41, 0xe1, 0xae, 0x34, 0x83, 0xc2, 0x4d, 0x38, 0x1f, 0xfe, 0x45, 0x09, 0x2f, 0xf5, 0xdf, 0x91,
-	0xa8, 0x1b, 0x50, 0xe8, 0x52, 0xd7, 0xa4, 0x6d, 0xdd, 0xe9, 0xd9, 0x22, 0x59, 0x73, 0x04, 0x04,
-	0xe9, 0xa8, 0x67, 0x9f, 0xa3, 0xfb, 0xb0, 0x28, 0x19, 0xc2, 0xd4, 0x99, 0xe5, 0x97, 0xbc, 0x24,
-	0xc8, 0x81, 0x11, 0xf8, 0x57, 0x25, 0xac, 0x0f, 0x23, 0x89, 0xb7, 0x33, 0x92, 0x78, 0xf7, 0xe2,
-	0x51, 0x4f, 0x11, 0xa9, 0xc8, 0x0c, 0x0b, 0xe5, 0xb4, 0x27, 0x90, 0x15, 0xb4, 0xd4, 0xe0, 0x3e,
-	0x80, 0x2c, 0x33, 0x5c, 0x93, 0x32, 0xee, 0x42, 0xa1, 0xba, 0x14, 0xe0, 0x3f, 0x09, 0x4e, 0x8d,
-	0x48, 0x06, 0xfc, 0x54, 0x94, 0x25, 0x51, 0xc7, 0xa6, 0xaa, 0x88, 0x1f, 0x88, 0x0a, 0x13, 0x22,
-	0x49, 0x6f, 0x37, 0x60, 0x8e, 0x19, 0x66, 0xe0, 0x69, 0x21, 0x00, 0x69, 0x1a, 0x26, 0xe1, 0x1b,
-	0xf8, 0x35, 0xa8, 0x84, 0x76, 0xea, 0x6f, 0x2d, 0x8f, 0x4d, 0x75, 0x78, 0x2a, 0xcc, 0xba, 0xb4,
-	0x23, 0xf3, 0xc9, 0xff, 0x8b, 0x1f, 0xc0, 0x52, 0x0c, 0x39, 0xaa, 0xce, 0x6f, 0x0c, 0x7b, 0x20,
-	0x02, 0x96, 0x23, 0x62, 0x81, 0xbf, 0x83, 0xe5, 0x5d, 0x97, 0x1a, 0x8c, 0x06, 0x77, 0xf9, 0xaf,
-	0xdb, 0x11, 0x1c, 0x48, 0x26, 0x76, 0x20, 0x1b, 0x50, 0xf0, 0x98, 0xe1, 0x32, 0xbd, 0xef, 0x58,
-	0xbd, 0xe0, 0x7a, 0x03, 0x27, 0x1d, 0xfb, 0x14, 0xfc, 0xbb, 0x02, 0x2b, 0x49, 0x03, 0xc2, 0x2a,
-	0x95, 0xf5, 0x98, 0xc1, 0x06, 0x1e, 0xd7, 0x5e, 0x8a, 0x2e, 0x68, 0x1a, 0x77, 0xa5, 0xc1, 0x59,
-	0x89, 0x14, 0x41, 0xf7, 0x20, 0x2b, 0x32, 0x46, 0xe6, 0x41, 0x29, 0x10, 0x96, 0x62, 0x72, 0x17,
-	0x1f, 0x42, 0x56, 0x48, 0xa2, 0x2c, 0x64, 0x8e, 0x9e, 0xab, 0x33, 0xa8, 0x04, 0x50, 0x27, 0x44,
-	0xaf, 0xbf, 0xde, 0x6f, 0x34, 0x1b, 0xaa, 0xe2, 0x17, 0x5b, 0x7f, 0xbd, 0x7f, 0xf8, 0xb2, 0x76,
-	0xb0, 0xbf, 0xa7, 0x66, 0xd0, 0x3a, 0x5c, 0x8d, 0x11, 0xf4, 0x46, 0xb3, 0x46, 0x9a, 0xfa, 0xf1,
-	0xd1, 0xfe, 0x61, 0x53, 0x9d, 0xc5, 0x5f, 0xc1, 0xf2, 0x1e, 0xb5, 0xe9, 0x7b, 0x8a, 0x26, 0x5e,
-	0x83, 0x95, 0x24, 0xbc, 0xf0, 0x1e, 0x7f, 0x01, 0x4b, 0x7e, 0x06, 0xbe, 0x1f, 0xa5, 0x1f, 0x89,
-	0x8b, 0x32, 0x74, 0x3c, 0x51, 0x84, 0x95, 0x89, 0x11, 0xfe, 0x41, 0x81, 0x25, 0x61, 0x33, 0xa1,
-	0x9d, 0xa9, 0xd2, 0xfc, 0x11, 0x20, 0xfa, 0xf6, 0x84, 0xf6, 0x99, 0x7e, 0x66, 0xb1, 0x53, 0x5d,
-	0x36, 0xfb, 0x0c, 0xaf, 0x42, 0xaa, 0xd8, 0x79, 0x65, 0xb1, 0xd3, 0x63, 0x4e, 0xf7, 0x3d, 0x71,
-	0x69, 0x27, 0xa8, 0x52, 0xfc, 0x3f, 0xfe, 0x1f, 0xa0, 0xb8, 0x29, 0xd2, 0x93, 0x75, 0xc8, 0x9b,
-	0x16, 0xd3, 0xa9, 0xeb, 0x3a, 0x2e, 0x37, 0x25, 0x4f, 0x72, 0xa6, 0xc5, 0xea, 0xfe, 0x1a, 0xff,
-	0xac, 0xc0, 0x3d, 0x7f, 0x46, 0x8d, 0x4d, 0x5b, 0xbb, 0x4e, 0x8f, 0x19, 0x56, 0xcf, 0xea, 0x99,
-	0xb2, 0xa2, 0xfc, 0xb3, 0x43, 0x33, 0x81, 0xfb, 0x17, 0x1a, 0x24, 0x3d, 0xbb, 0x05, 0x45, 0x71,
-	0x0a, 0xba, 0x18, 0xcb, 0x44, 0xac, 0x0a, 0xad, 0x48, 0xf4, 0xd9, 0x5c, 0x4e, 0x51, 0x33, 0xf8,
-	0x27, 0x05, 0x6e, 0xfb, 0xa0, 0xc1, 0x44, 0xf7, 0x2f, 0xbb, 0xb8, 0x0f, 0x77, 0x26, 0x5b, 0x13,
-	0x9d, 0x1c, 0x33, 0xcc, 0x84, 0x73, 0x39, 0x26, 0x85, 0xa4, 0x67, 0x03, 0x58, 0x7d, 0x42, 0x7d,
-	0xa4, 0x17, 0xd4, 0xf3, 0x0c, 0x73, 0xba, 0x2e, 0x79, 0x15, 0x16, 0x7c, 0x7d, 0x56, 0x5b, 0xa4,
-	0x55, 0xde, 0xef, 0x25, 0xe6, 0x7e, 0xdb, 0xd7, 0x95, 0x51, 0x67, 0x49, 0x64, 0x0c, 0xfe, 0x1c,
-	0xd6, 0x86, 0xd5, 0x4a, 0x9b, 0xcb, 0xb0, 0xd0, 0x15, 0x34, 0x79, 0xc9, 0x82, 0x25, 0x5a, 0xf5,
-	0x7b, 0x97, 0x8f, 0xce, 0x83, 0x91, 0x27, 0xf3, 0x1c, 0x5c, 0xf8, 0xc1, 0xfd, 0xe2, 0xd8, 0xf8,
-	0x14, 0x56, 0xe5, 0xa3, 0x49, 0x44, 0xe3, 0xbd, 0x3d, 0xda, 0x70, 0x1d, 0xd6, 0x86, 0x35, 0x49,
-	0x27, 0x1e, 0xc2, 0x82, 0xe0, 0x0a, 0xba, 0x5b, 0x4a, 0x9f, 0x0d, 0x38, 0xb0, 0x27, 0x1e, 0x63,
-	0x35, 0xdb, 0x26, 0xb4, 0xeb, 0x04, 0xb5, 0x6b, 0xea, 0x79, 0xc5, 0xe5, 0x60, 0x7a, 0x58, 0xae,
-	0xf2, 0x3e, 0x83, 0x4f, 0xf2, 0x8f, 0x1f, 0x3f, 0x17, 0xaf, 0xb5, 0x14, 0xa5, 0xd2, 0x85, 0xff,
-	0x8c, 0xcc, 0x22, 0xc3, 0x15, 0x2c, 0xdc, 0xaf, 0xfe, 0x51, 0x04, 0x20, 0xb4, 0xd3, 0xa0, 0xee,
-	0x1b, 0xeb, 0x84, 0xa2, 0x0e, 0xac, 0xa6, 0xbe, 0x04, 0xd1, 0x9d, 0xf8, 0x34, 0x33, 0xee, 0xf1,
-	0xa9, 0xdd, 0xbd, 0x80, 0x4b, 0xd6, 0xf4, 0x19, 0xa4, 0x87, 0x13, 0x4a, 0xec, 0xb2, 0xa3, 0x5b,
-	0xa9, 0x23, 0x53, 0xfc, 0x59, 0xa7, 0xe1, 0x49, 0x2c, 0x01, 0xfc, 0x7f, 0x15, 0xf4, 0x12, 0x16,
-	0x87, 0x9e, 0x72, 0xe8, 0xe6, 0x90, 0xe8, 0xd0, 0x8b, 0x51, 0xdb, 0x18, 0xbb, 0x1f, 0xc3, 0x7d,
-	0x0a, 0x85, 0xd8, 0x93, 0x0b, 0x69, 0x71, 0x99, 0xe4, 0x33, 0x50, 0x5b, 0x4f, 0xdd, 0x0b, 0x43,
-	0xf0, 0xa5, 0x68, 0x6c, 0x89, 0x77, 0x0c, 0xda, 0xbc, 0xe8, 0x11, 0xa5, 0xdd, 0x9a, 0xc0, 0x91,
-	0xea, 0x7f, 0x88, 0x7d, 0x73, 0xec, 0x40, 0x9a, 0xee, 0x7f, 0x2a, 0xee, 0x33, 0xe1, 0xbf, 0x1c,
-	0x08, 0x93, 0xfe, 0x27, 0xe7, 0xcd, 0xa4, 0xff, 0x43, 0x13, 0x24, 0xc7, 0x3a, 0x15, 0xc9, 0x36,
-	0x92, 0xc8, 0xc9, 0x64, 0x1b, 0x77, 0xb9, 0x92, 0xc9, 0x36, 0xf6, 0x36, 0x70, 0x4d, 0x3b, 0x90,
-	0x0f, 0x87, 0x46, 0x54, 0x8e, 0x2e, 0x60, 0x72, 0x42, 0xd5, 0xae, 0xa5, 0xec, 0x84, 0xe7, 0xf5,
-	0x1c, 0x8a, 0xf1, 0xf1, 0x0c, 0xad, 0xa7, 0x0f, 0x6d, 0x02, 0xe9, 0xfa, 0xa4, 0x89, 0x4e, 0x80,
-	0xc5, 0xa7, 0x9d, 0x08, 0x2c, 0x65, 0xc4, 0x8a, 0xc0, 0x52, 0x07, 0xa4, 0x19, 0x54, 0x07, 0x88,
-	0xa6, 0x18, 0x74, 0x2d, 0x1e, 0x96, 0x24, 0x90, 0x96, 0xb6, 0x15, 0x87, 0x89, 0x46, 0x88, 0x08,
-	0x66, 0x64, 0xc2, 0x89, 0x60, 0x46, 0x27, 0x0e, 0x3c, 0x83, 0xbe, 0x57, 0x60, 0xe3, 0x82, 0x2e,
-	0x8e, 0x2a, 0x01, 0xc2, 0xe5, 0xe6, 0x0f, 0x6d, 0xfb, 0xd2, 0xfc, 0xb1, 0x43, 0x7f, 0x07, 0xd7,
-	0x27, 0xb5, 0x5a, 0xf4, 0x30, 0x0e, 0x7a, 0xc1, 0x78, 0xa0, 0x3d, 0xba, 0x1c, 0x73, 0x4c, 0x7d,
-	0x03, 0x4a, 0xc9, 0x3e, 0x89, 0x6e, 0x84, 0x9d, 0x24, 0xad, 0x6d, 0x6b, 0x37, 0xc7, 0x6d, 0x27,
-	0x41, 0x93, 0x7d, 0x2b, 0x02, 0x4d, 0xed, 0x9c, 0x11, 0x68, 0x7a, 0xbb, 0xe3, 0xa0, 0x2f, 0xa0,
-	0x18, 0xff, 0x56, 0x19, 0x25, 0x63, 0xca, 0xf7, 0xd3, 0x28, 0x19, 0xd3, 0x3e, 0x6f, 0xfa, 0x70,
-	0xad, 0x2c, 0x7f, 0xd9, 0x3f, 0xfe, 0x33, 0x00, 0x00, 0xff, 0xff, 0x8e, 0x95, 0x40, 0x62, 0xcf,
-	0x15, 0x00, 0x00,
+func init() { proto.RegisterFile("ref.proto", fileDescriptor_ref_a3b568a6c89846e1) }
+
+var fileDescriptor_ref_a3b568a6c89846e1 = []byte{
+	// 1598 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x5b, 0x6f, 0x1b, 0x45,
+	0x14, 0xce, 0x3a, 0x89, 0x63, 0x1f, 0xbb, 0xce, 0x66, 0x72, 0xa9, 0xbb, 0x69, 0x9b, 0x74, 0x7b,
+	0x4b, 0x69, 0xeb, 0x14, 0x57, 0xf0, 0x00, 0x48, 0xe0, 0x24, 0xa6, 0x4d, 0x2f, 0x4e, 0x34, 0x36,
+	0x6d, 0xa9, 0x90, 0x96, 0xb5, 0x3d, 0xde, 0x2c, 0x5a, 0x7b, 0xcd, 0xee, 0xa4, 0x69, 0x84, 0xfa,
+	0x06, 0x7d, 0xe1, 0x09, 0x09, 0xa9, 0x6f, 0x3c, 0xf2, 0x67, 0x78, 0x80, 0xdf, 0xc2, 0x2f, 0x40,
+	0x3b, 0x33, 0x7b, 0xb3, 0xd7, 0x4e, 0x84, 0x53, 0xc1, 0x93, 0x3d, 0x67, 0xce, 0xf9, 0xe6, 0xdc,
+	0xe6, 0x9c, 0x33, 0x0b, 0x59, 0x87, 0x74, 0x4a, 0x7d, 0xc7, 0xa6, 0x36, 0x4a, 0x1b, 0x26, 0xd5,
+	0xad, 0x63, 0x05, 0x9a, 0x96, 0xdd, 0xe4, 0x34, 0x25, 0xef, 0x1e, 0xe8, 0x0e, 0x69, 0x8b, 0xd5,
+	0x9a, 0x61, 0xdb, 0x86, 0x45, 0x36, 0xd9, 0xaa, 0x79, 0xd8, 0xd9, 0xa4, 0x66, 0x97, 0xb8, 0x54,
+	0xef, 0xf6, 0x39, 0x83, 0xfa, 0xa3, 0x04, 0x8b, 0x4f, 0x4c, 0x97, 0xd6, 0xc8, 0xd1, 0x96, 0x65,
+	0x37, 0x5d, 0x4c, 0xbe, 0x3f, 0x24, 0x2e, 0x45, 0x65, 0x00, 0x87, 0xf4, 0x6d, 0xd7, 0xa4, 0xb6,
+	0x73, 0x5c, 0x94, 0xd6, 0xa5, 0x8d, 0x5c, 0x19, 0x95, 0xf8, 0x79, 0x25, 0x1c, 0xec, 0xe0, 0x08,
+	0x17, 0x5a, 0x85, 0x6c, 0xcb, 0xee, 0x76, 0x4d, 0xaa, 0x99, 0xed, 0x62, 0x6a, 0x5d, 0xda, 0xc8,
+	0xe2, 0x0c, 0x27, 0xec, 0xb6, 0xd1, 0x12, 0xcc, 0x5a, 0x66, 0xd7, 0xa4, 0xc5, 0xe9, 0x75, 0x69,
+	0xe3, 0x1c, 0xe6, 0x8b, 0x4f, 0xd2, 0x7f, 0xbf, 0xdb, 0x48, 0x65, 0x52, 0xea, 0x73, 0x58, 0x8a,
+	0x6b, 0xe1, 0xf6, 0xed, 0x9e, 0x4b, 0xd0, 0xe7, 0x20, 0xf7, 0xc8, 0x91, 0xe6, 0xd9, 0xa7, 0xd9,
+	0xcd, 0xef, 0x48, 0x8b, 0xba, 0x45, 0x69, 0x7d, 0x7a, 0x23, 0x57, 0x5e, 0xf6, 0x95, 0x11, 0x32,
+	0x7b, 0x6c, 0x17, 0x17, 0x7a, 0xd1, 0xa5, 0xab, 0xbe, 0x84, 0x8b, 0x5f, 0x9a, 0xbd, 0xf6, 0x0e,
+	0xe9, 0xe8, 0x87, 0x16, 0xdd, 0x72, 0xf4, 0x5e, 0xeb, 0xa0, 0xa6, 0x77, 0xc9, 0x04, 0x76, 0x06,
+	0x4a, 0xdf, 0x87, 0x4b, 0x23, 0xb0, 0x85, 0xf6, 0x08, 0x66, 0x7a, 0x7a, 0x97, 0x30, 0xd8, 0x3c,
+	0x66, 0xff, 0xd5, 0xe7, 0x70, 0xc1, 0x13, 0xaa, 0x58, 0x56, 0x28, 0xe0, 0x9e, 0x85, 0x36, 0x65,
+	0x50, 0x92, 0x80, 0x85, 0x2a, 0x4b, 0x30, 0xeb, 0x1d, 0xcf, 0xbd, 0x97, 0xc7, 0x7c, 0xa1, 0x36,
+	0x60, 0x45, 0xc8, 0x34, 0x74, 0xe3, 0xcc, 0x34, 0xd9, 0x84, 0xf3, 0x43, 0xa8, 0x63, 0xd5, 0xf8,
+	0x49, 0x02, 0xe4, 0x49, 0x60, 0xd2, 0x99, 0x30, 0x36, 0xe3, 0x73, 0x70, 0x05, 0xd2, 0x7d, 0x87,
+	0x74, 0xcc, 0xd7, 0x2c, 0x09, 0xf3, 0x58, 0xac, 0x02, 0xc5, 0x6f, 0xc1, 0x62, 0x4c, 0x8d, 0x31,
+	0x61, 0xfc, 0x53, 0x82, 0xa2, 0xc7, 0xfb, 0xc4, 0x6e, 0xe9, 0xc2, 0xe1, 0x13, 0x39, 0x0f, 0x7d,
+	0x01, 0x73, 0xae, 0xed, 0x50, 0xad, 0x79, 0xcc, 0xd4, 0x2e, 0x94, 0x6f, 0xfa, 0x02, 0xa3, 0x8e,
+	0x29, 0xd5, 0x6d, 0x87, 0x6e, 0x1d, 0xe3, 0xb4, 0xcb, 0x7e, 0xd5, 0x8f, 0x20, 0xcd, 0x29, 0x28,
+	0x03, 0x33, 0xb5, 0xca, 0xd3, 0xaa, 0x3c, 0x85, 0xe6, 0x21, 0xf7, 0xd5, 0xfe, 0x4e, 0xa5, 0x51,
+	0xdd, 0xd1, 0x2a, 0xf5, 0x6d, 0x59, 0x42, 0x32, 0xe4, 0x7d, 0xc2, 0x4e, 0xb5, 0xbe, 0x2d, 0xa7,
+	0x02, 0xe3, 0x5f, 0xf0, 0xc4, 0x1c, 0x38, 0x49, 0xb8, 0xe0, 0x53, 0xc8, 0x34, 0x05, 0x4d, 0xdc,
+	0xbf, 0xb5, 0x11, 0xea, 0xf9, 0x22, 0x38, 0x10, 0x50, 0x7f, 0x4e, 0xf1, 0x84, 0x48, 0xe0, 0x4a,
+	0xf2, 0xed, 0xf8, 0x18, 0x5e, 0x87, 0x82, 0xd8, 0x74, 0x0f, 0xd9, 0x1d, 0x17, 0xb1, 0x3c, 0xc7,
+	0xa9, 0x75, 0x4e, 0x44, 0x0f, 0x41, 0x10, 0x34, 0xfd, 0x90, 0x1e, 0xd8, 0x4e, 0x71, 0x86, 0x45,
+	0xe1, 0xea, 0x08, 0xad, 0xb7, 0x19, 0x6f, 0x85, 0xb1, 0xe2, 0x7c, 0x2b, 0xb2, 0x42, 0x35, 0x90,
+	0x05, 0x12, 0xff, 0xa1, 0xc4, 0x29, 0xce, 0x9e, 0x1e, 0x6c, 0x9e, 0x4b, 0x6d, 0xfb, 0xb2, 0xea,
+	0x11, 0xac, 0x8e, 0xe1, 0x4f, 0x74, 0xc8, 0x12, 0xcc, 0x92, 0xae, 0x6e, 0x5a, 0xcc, 0x19, 0x79,
+	0xcc, 0x17, 0xa8, 0x04, 0x33, 0x6d, 0x9d, 0x12, 0x66, 0x7f, 0xae, 0xac, 0x94, 0x78, 0xa9, 0x2f,
+	0xf9, 0xa5, 0xbe, 0xd4, 0xf0, 0x4b, 0x3d, 0x66, 0x7c, 0xea, 0x6f, 0x52, 0x70, 0xdb, 0xcf, 0x22,
+	0x61, 0xd7, 0x20, 0xd7, 0x25, 0x8e, 0x41, 0xda, 0x9a, 0xdd, 0xb3, 0x78, 0xd2, 0x66, 0x30, 0x70,
+	0xd2, 0x5e, 0xcf, 0x3a, 0x46, 0x37, 0x61, 0x5e, 0x30, 0x04, 0xa9, 0x33, 0xcd, 0x6e, 0x7d, 0x81,
+	0x93, 0x7d, 0x25, 0x82, 0x0c, 0xfc, 0x5d, 0x0a, 0x0a, 0xc7, 0x50, 0x02, 0x6e, 0x0d, 0x25, 0xe0,
+	0x8d, 0xa8, 0xf7, 0x13, 0x44, 0x4a, 0x22, 0xd3, 0x02, 0x39, 0xe5, 0x01, 0xa4, 0x39, 0x2d, 0xd1,
+	0xc9, 0xb7, 0x20, 0x4d, 0x75, 0xc7, 0x20, 0x94, 0x99, 0x92, 0x2b, 0x2f, 0xf8, 0xf8, 0x0f, 0xfc,
+	0xe8, 0x61, 0xc1, 0xa0, 0xee, 0xf3, 0x72, 0xc5, 0x0b, 0xdc, 0x99, 0x94, 0xcc, 0x8f, 0x79, 0xe5,
+	0x09, 0x10, 0x85, 0xd5, 0x6b, 0x30, 0x43, 0x75, 0xc3, 0xb7, 0x38, 0xe7, 0x83, 0x35, 0x74, 0x03,
+	0xb3, 0x0d, 0xf5, 0x5b, 0x90, 0x31, 0xe9, 0x54, 0x5f, 0x9b, 0x2e, 0x9d, 0x28, 0x98, 0x32, 0x4c,
+	0x3b, 0xa4, 0x23, 0xf2, 0xcb, 0xfb, 0x1b, 0xa9, 0x89, 0x0b, 0x91, 0x13, 0xc2, 0x32, 0xfe, 0x4a,
+	0xb7, 0x0e, 0xb9, 0x03, 0x33, 0x98, 0x2f, 0xd4, 0xb7, 0x12, 0x2c, 0x6e, 0x3b, 0x44, 0xa7, 0xc4,
+	0xbf, 0xe4, 0xff, 0x5e, 0x21, 0x3f, 0x42, 0xa9, 0x48, 0x84, 0xd6, 0x20, 0xe7, 0x52, 0xdd, 0xa1,
+	0x5a, 0xdf, 0x36, 0x7b, 0xfe, 0xbd, 0x07, 0x46, 0xda, 0xf7, 0x28, 0x81, 0xce, 0x7f, 0x48, 0xb0,
+	0x14, 0x57, 0x24, 0x28, 0x63, 0x69, 0x97, 0xea, 0xf4, 0xd0, 0x65, 0x5a, 0x14, 0xc2, 0x1b, 0x9c,
+	0xc4, 0x5d, 0xaa, 0x33, 0x56, 0x2c, 0x44, 0xd0, 0x0d, 0x48, 0xf3, 0x54, 0x12, 0x09, 0x52, 0xf0,
+	0x85, 0x85, 0x98, 0xd8, 0x55, 0x6b, 0x90, 0xe6, 0x92, 0x28, 0x0d, 0xa9, 0xbd, 0xc7, 0xf2, 0x14,
+	0x2a, 0x00, 0x54, 0x31, 0xd6, 0xaa, 0x2f, 0x76, 0xeb, 0x8d, 0xba, 0x2c, 0x79, 0x55, 0xd9, 0x5b,
+	0xef, 0xd6, 0x9e, 0x55, 0x9e, 0xec, 0xee, 0xc8, 0x29, 0xb4, 0x0a, 0xe7, 0x23, 0x04, 0xad, 0xde,
+	0xa8, 0xe0, 0x86, 0xb6, 0xbf, 0xb7, 0x5b, 0x6b, 0xc8, 0xd3, 0x2a, 0x81, 0xc5, 0x1d, 0x62, 0x91,
+	0xf7, 0xe4, 0xd5, 0xc0, 0x69, 0x2b, 0xb0, 0x14, 0x3f, 0x86, 0x7b, 0x41, 0x6d, 0xc1, 0x82, 0x97,
+	0x9a, 0xef, 0xf7, 0xf0, 0xcf, 0xf8, 0x8d, 0x1a, 0x08, 0x57, 0xe8, 0x71, 0x69, 0xac, 0xc7, 0x7f,
+	0x91, 0x60, 0x81, 0xeb, 0x8e, 0x49, 0x67, 0xa2, 0x7b, 0x70, 0x07, 0x10, 0x79, 0xdd, 0x22, 0x7d,
+	0xaa, 0x1d, 0x99, 0xf4, 0x40, 0x13, 0xd3, 0x42, 0x8a, 0x95, 0x2d, 0x99, 0xef, 0x3c, 0x37, 0xe9,
+	0xc1, 0x3e, 0xa3, 0x7b, 0x16, 0x39, 0xa4, 0xe3, 0x97, 0x35, 0xf6, 0x3f, 0xb0, 0xe8, 0x43, 0x40,
+	0x51, 0x95, 0x84, 0x45, 0xab, 0x90, 0x35, 0x4c, 0xaa, 0x11, 0xc7, 0xb1, 0x1d, 0xa6, 0x52, 0x16,
+	0x67, 0x0c, 0x93, 0x56, 0xbd, 0xb5, 0xfa, 0x4e, 0x82, 0x1b, 0xde, 0x14, 0x1c, 0x99, 0xdf, 0xb6,
+	0xed, 0x1e, 0xd5, 0xcd, 0x9e, 0xd9, 0x33, 0x44, 0x09, 0xfa, 0x6f, 0xc6, 0x73, 0x0c, 0x37, 0x4f,
+	0x54, 0x4c, 0x58, 0x78, 0x05, 0xf2, 0x3c, 0x2a, 0x1a, 0x1f, 0xf4, 0xb8, 0xef, 0x72, 0xcd, 0x50,
+	0xf4, 0xd1, 0x4c, 0x46, 0x92, 0x53, 0xea, 0xaf, 0x12, 0x5c, 0xf5, 0x40, 0xfd, 0x19, 0xf1, 0x7f,
+	0x62, 0xea, 0x2e, 0x5c, 0x1b, 0xaf, 0x55, 0x18, 0x49, 0xaa, 0x1b, 0x31, 0x23, 0x33, 0x54, 0x08,
+	0x09, 0x0b, 0xdf, 0xc0, 0xf2, 0x03, 0xe2, 0x21, 0x3d, 0x25, 0xae, 0xab, 0x1b, 0x93, 0xb5, 0xdb,
+	0xf3, 0x30, 0xe7, 0x9d, 0x67, 0xb6, 0x79, 0xba, 0x65, 0xbd, 0x66, 0x64, 0xec, 0xb6, 0x83, 0x84,
+	0x7b, 0x34, 0x93, 0x49, 0xc9, 0xd3, 0x38, 0x54, 0x4a, 0xfd, 0x1a, 0x56, 0x06, 0x8f, 0x17, 0xba,
+	0x17, 0x61, 0xae, 0xcb, 0x69, 0xe2, 0x32, 0xfa, 0x4b, 0xb4, 0xec, 0x35, 0x41, 0xef, 0x14, 0xe6,
+	0x9c, 0x2c, 0x9e, 0x65, 0x87, 0x70, 0x7b, 0x98, 0x7d, 0x0c, 0x5b, 0xed, 0xc3, 0xb2, 0x78, 0xae,
+	0x71, 0xaf, 0xbc, 0xb7, 0x67, 0x63, 0x10, 0x96, 0x2a, 0xac, 0x0c, 0x9e, 0x28, 0x8c, 0xb9, 0x0d,
+	0x73, 0x9c, 0xdb, 0x6f, 0x93, 0x09, 0x8d, 0xdb, 0xe7, 0x50, 0x7f, 0xe0, 0xcf, 0xc1, 0x8a, 0x65,
+	0x61, 0xd2, 0xb5, 0xfd, 0x5a, 0x37, 0xf1, 0x20, 0xe4, 0x30, 0x30, 0x2d, 0x28, 0x6f, 0x59, 0x8f,
+	0xc1, 0x23, 0xd5, 0xa2, 0x45, 0xee, 0x31, 0x7f, 0x2f, 0x26, 0x1c, 0x2e, 0x4c, 0xf9, 0x60, 0x68,
+	0xc8, 0x19, 0xac, 0x78, 0xc1, 0x7e, 0xf9, 0xaf, 0x3c, 0x00, 0x26, 0x9d, 0x3a, 0x71, 0x5e, 0x99,
+	0x2d, 0x82, 0x3a, 0xb0, 0x9c, 0xf8, 0x16, 0x45, 0xd7, 0xa2, 0x63, 0xd2, 0xa8, 0x67, 0xb0, 0x72,
+	0xfd, 0x04, 0x2e, 0xd1, 0x0b, 0xa6, 0x90, 0x16, 0x8c, 0x3e, 0x91, 0x62, 0x80, 0xae, 0x24, 0xce,
+	0x62, 0xd1, 0x07, 0xa5, 0xa2, 0x8e, 0x63, 0xf1, 0xe1, 0xef, 0x49, 0xe8, 0x19, 0xcc, 0x0f, 0x3c,
+	0x1e, 0xd1, 0xe5, 0x01, 0xd1, 0x81, 0xb7, 0xaa, 0xb2, 0x36, 0x72, 0x3f, 0x82, 0xfb, 0x10, 0x72,
+	0x91, 0xb7, 0x1d, 0x52, 0xa2, 0x32, 0xf1, 0x77, 0xa7, 0xb2, 0x9a, 0xb8, 0x17, 0xb8, 0xe0, 0x1b,
+	0xde, 0x10, 0x63, 0x0f, 0x25, 0xb4, 0x7e, 0xd2, 0x6b, 0x4d, 0xb9, 0x32, 0x86, 0x23, 0xd1, 0xfe,
+	0x00, 0xfb, 0xf2, 0xc8, 0x49, 0x37, 0xd9, 0xfe, 0x44, 0xdc, 0x47, 0xdc, 0x7e, 0x31, 0x61, 0xc6,
+	0xed, 0x8f, 0x0f, 0xb2, 0x71, 0xfb, 0x07, 0x46, 0x52, 0x86, 0x75, 0xc0, 0x93, 0x6d, 0x28, 0x91,
+	0xe3, 0xc9, 0x36, 0xea, 0x92, 0xc5, 0x93, 0x6d, 0xe4, 0x6d, 0x60, 0x27, 0x6d, 0x41, 0x36, 0x98,
+	0x3e, 0x51, 0x31, 0xbc, 0x88, 0xf1, 0x91, 0x57, 0xb9, 0x90, 0xb0, 0x13, 0xc4, 0xeb, 0x31, 0xe4,
+	0xa3, 0xe3, 0x1d, 0x5a, 0x4d, 0x1e, 0xfa, 0x38, 0xd2, 0xc5, 0x71, 0x13, 0x21, 0x07, 0x8b, 0x4e,
+	0x49, 0x21, 0x58, 0xc2, 0x88, 0x16, 0x82, 0x25, 0x0e, 0x56, 0x53, 0xa8, 0x0a, 0x10, 0x4e, 0x3d,
+	0xe8, 0x42, 0xd4, 0x2d, 0x71, 0x20, 0x25, 0x69, 0x2b, 0x0a, 0x13, 0x8e, 0x1a, 0x21, 0xcc, 0xd0,
+	0x44, 0x14, 0xc2, 0x0c, 0x4f, 0x26, 0xea, 0x14, 0x7a, 0x2b, 0xc1, 0xda, 0x09, 0x5d, 0x1e, 0x95,
+	0x7c, 0x84, 0xd3, 0xcd, 0x29, 0xca, 0xe6, 0xa9, 0xf9, 0x23, 0x41, 0x7f, 0x03, 0x17, 0xc7, 0xb5,
+	0x60, 0x74, 0x3b, 0x0a, 0x7a, 0xc2, 0xf8, 0xa0, 0xdc, 0x39, 0x1d, 0x73, 0xe4, 0xf8, 0x3a, 0x14,
+	0xe2, 0x7d, 0x13, 0x5d, 0x0a, 0x3a, 0x4a, 0x52, 0x3b, 0x57, 0x2e, 0x8f, 0xda, 0x8e, 0x83, 0xc6,
+	0xfb, 0x57, 0x08, 0x9a, 0xd8, 0x49, 0x43, 0xd0, 0xe4, 0xb6, 0xc7, 0x40, 0x9f, 0x42, 0x3e, 0xfa,
+	0xd5, 0x34, 0x4c, 0xc6, 0x84, 0x2f, 0xba, 0x61, 0x32, 0x26, 0x7d, 0x68, 0xf5, 0xe0, 0xb6, 0xee,
+	0xbd, 0xf4, 0x58, 0x2c, 0xbd, 0x59, 0x6a, 0xd9, 0xdd, 0x4d, 0xfe, 0xf7, 0xae, 0xed, 0x18, 0x9b,
+	0x5c, 0xf0, 0x2e, 0xfb, 0xb2, 0xb0, 0x69, 0xd8, 0x62, 0xdd, 0x6f, 0x36, 0xd3, 0x8c, 0x74, 0xff,
+	0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x86, 0x77, 0x8d, 0xcc, 0x94, 0x16, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go
index 3adf041bdc22cc9077919d07ebbdd96aacf90650..b32251cebade5839307f9ec5bb99a4ff2e2878ac 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: remote.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -38,7 +38,7 @@ func (m *AddRemoteRequest) Reset()         { *m = AddRemoteRequest{} }
 func (m *AddRemoteRequest) String() string { return proto.CompactTextString(m) }
 func (*AddRemoteRequest) ProtoMessage()    {}
 func (*AddRemoteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{0}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{0}
 }
 func (m *AddRemoteRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AddRemoteRequest.Unmarshal(m, b)
@@ -96,7 +96,7 @@ func (m *AddRemoteResponse) Reset()         { *m = AddRemoteResponse{} }
 func (m *AddRemoteResponse) String() string { return proto.CompactTextString(m) }
 func (*AddRemoteResponse) ProtoMessage()    {}
 func (*AddRemoteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{1}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{1}
 }
 func (m *AddRemoteResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AddRemoteResponse.Unmarshal(m, b)
@@ -128,7 +128,7 @@ func (m *RemoveRemoteRequest) Reset()         { *m = RemoveRemoteRequest{} }
 func (m *RemoveRemoteRequest) String() string { return proto.CompactTextString(m) }
 func (*RemoveRemoteRequest) ProtoMessage()    {}
 func (*RemoveRemoteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{2}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{2}
 }
 func (m *RemoveRemoteRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RemoveRemoteRequest.Unmarshal(m, b)
@@ -173,7 +173,7 @@ func (m *RemoveRemoteResponse) Reset()         { *m = RemoveRemoteResponse{} }
 func (m *RemoveRemoteResponse) String() string { return proto.CompactTextString(m) }
 func (*RemoveRemoteResponse) ProtoMessage()    {}
 func (*RemoveRemoteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{3}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{3}
 }
 func (m *RemoveRemoteResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RemoveRemoteResponse.Unmarshal(m, b)
@@ -212,7 +212,7 @@ func (m *FetchInternalRemoteRequest) Reset()         { *m = FetchInternalRemoteR
 func (m *FetchInternalRemoteRequest) String() string { return proto.CompactTextString(m) }
 func (*FetchInternalRemoteRequest) ProtoMessage()    {}
 func (*FetchInternalRemoteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{4}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{4}
 }
 func (m *FetchInternalRemoteRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FetchInternalRemoteRequest.Unmarshal(m, b)
@@ -257,7 +257,7 @@ func (m *FetchInternalRemoteResponse) Reset()         { *m = FetchInternalRemote
 func (m *FetchInternalRemoteResponse) String() string { return proto.CompactTextString(m) }
 func (*FetchInternalRemoteResponse) ProtoMessage()    {}
 func (*FetchInternalRemoteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{5}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{5}
 }
 func (m *FetchInternalRemoteResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FetchInternalRemoteResponse.Unmarshal(m, b)
@@ -299,7 +299,7 @@ func (m *UpdateRemoteMirrorRequest) Reset()         { *m = UpdateRemoteMirrorReq
 func (m *UpdateRemoteMirrorRequest) String() string { return proto.CompactTextString(m) }
 func (*UpdateRemoteMirrorRequest) ProtoMessage()    {}
 func (*UpdateRemoteMirrorRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{6}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{6}
 }
 func (m *UpdateRemoteMirrorRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UpdateRemoteMirrorRequest.Unmarshal(m, b)
@@ -364,7 +364,7 @@ func (m *UpdateRemoteMirrorResponse) Reset()         { *m = UpdateRemoteMirrorRe
 func (m *UpdateRemoteMirrorResponse) String() string { return proto.CompactTextString(m) }
 func (*UpdateRemoteMirrorResponse) ProtoMessage()    {}
 func (*UpdateRemoteMirrorResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{7}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{7}
 }
 func (m *UpdateRemoteMirrorResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UpdateRemoteMirrorResponse.Unmarshal(m, b)
@@ -395,7 +395,7 @@ func (m *FindRemoteRepositoryRequest) Reset()         { *m = FindRemoteRepositor
 func (m *FindRemoteRepositoryRequest) String() string { return proto.CompactTextString(m) }
 func (*FindRemoteRepositoryRequest) ProtoMessage()    {}
 func (*FindRemoteRepositoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{8}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{8}
 }
 func (m *FindRemoteRepositoryRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindRemoteRepositoryRequest.Unmarshal(m, b)
@@ -435,7 +435,7 @@ func (m *FindRemoteRepositoryResponse) Reset()         { *m = FindRemoteReposito
 func (m *FindRemoteRepositoryResponse) String() string { return proto.CompactTextString(m) }
 func (*FindRemoteRepositoryResponse) ProtoMessage()    {}
 func (*FindRemoteRepositoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{9}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{9}
 }
 func (m *FindRemoteRepositoryResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindRemoteRepositoryResponse.Unmarshal(m, b)
@@ -474,7 +474,7 @@ func (m *FindRemoteRootRefRequest) Reset()         { *m = FindRemoteRootRefReque
 func (m *FindRemoteRootRefRequest) String() string { return proto.CompactTextString(m) }
 func (*FindRemoteRootRefRequest) ProtoMessage()    {}
 func (*FindRemoteRootRefRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{10}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{10}
 }
 func (m *FindRemoteRootRefRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindRemoteRootRefRequest.Unmarshal(m, b)
@@ -519,7 +519,7 @@ func (m *FindRemoteRootRefResponse) Reset()         { *m = FindRemoteRootRefResp
 func (m *FindRemoteRootRefResponse) String() string { return proto.CompactTextString(m) }
 func (*FindRemoteRootRefResponse) ProtoMessage()    {}
 func (*FindRemoteRootRefResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{11}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{11}
 }
 func (m *FindRemoteRootRefResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindRemoteRootRefResponse.Unmarshal(m, b)
@@ -557,7 +557,7 @@ func (m *ListRemotesRequest) Reset()         { *m = ListRemotesRequest{} }
 func (m *ListRemotesRequest) String() string { return proto.CompactTextString(m) }
 func (*ListRemotesRequest) ProtoMessage()    {}
 func (*ListRemotesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{12}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{12}
 }
 func (m *ListRemotesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListRemotesRequest.Unmarshal(m, b)
@@ -595,7 +595,7 @@ func (m *ListRemotesResponse) Reset()         { *m = ListRemotesResponse{} }
 func (m *ListRemotesResponse) String() string { return proto.CompactTextString(m) }
 func (*ListRemotesResponse) ProtoMessage()    {}
 func (*ListRemotesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{13}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{13}
 }
 func (m *ListRemotesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListRemotesResponse.Unmarshal(m, b)
@@ -635,7 +635,7 @@ func (m *ListRemotesResponse_Remote) Reset()         { *m = ListRemotesResponse_
 func (m *ListRemotesResponse_Remote) String() string { return proto.CompactTextString(m) }
 func (*ListRemotesResponse_Remote) ProtoMessage()    {}
 func (*ListRemotesResponse_Remote) Descriptor() ([]byte, []int) {
-	return fileDescriptor_remote_51ab93dc1564c9c6, []int{13, 0}
+	return fileDescriptor_remote_8f251117f9f2149f, []int{13, 0}
 }
 func (m *ListRemotesResponse_Remote) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListRemotesResponse_Remote.Unmarshal(m, b)
@@ -1026,50 +1026,53 @@ var _RemoteService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "remote.proto",
 }
 
-func init() { proto.RegisterFile("remote.proto", fileDescriptor_remote_51ab93dc1564c9c6) }
-
-var fileDescriptor_remote_51ab93dc1564c9c6 = []byte{
-	// 672 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcb, 0x6e, 0xd3, 0x4c,
-	0x14, 0xae, 0xeb, 0x34, 0x97, 0x93, 0xf4, 0x57, 0x3a, 0xa9, 0xfa, 0x3b, 0x4e, 0x25, 0xd2, 0x01,
-	0xa4, 0x6c, 0x88, 0x50, 0xb8, 0xac, 0x90, 0x10, 0x5d, 0xa0, 0xd2, 0x52, 0x16, 0x86, 0x6e, 0x90,
-	0x90, 0x71, 0x93, 0x71, 0x6d, 0xd5, 0xf1, 0x98, 0x99, 0x49, 0x21, 0x8f, 0xc1, 0x5b, 0xc0, 0x2b,
-	0xf1, 0x14, 0x3c, 0x02, 0x1a, 0xcf, 0xd8, 0x71, 0xa8, 0x13, 0x24, 0x22, 0x76, 0x9e, 0x73, 0x9b,
-	0xef, 0x3b, 0xf3, 0x9d, 0x63, 0x68, 0x31, 0x32, 0xa5, 0x82, 0x0c, 0x13, 0x46, 0x05, 0x45, 0xd5,
-	0xab, 0x50, 0x78, 0xd1, 0xdc, 0x6e, 0xf1, 0xc0, 0x63, 0x64, 0xa2, 0xac, 0xf8, 0x9b, 0x01, 0xed,
-	0x17, 0x93, 0x89, 0x93, 0x46, 0x3a, 0xe4, 0xd3, 0x8c, 0x70, 0x81, 0x46, 0x00, 0x8c, 0x24, 0x94,
-	0x87, 0x82, 0xb2, 0xb9, 0x65, 0xf4, 0x8d, 0x41, 0x73, 0x84, 0x86, 0x2a, 0x7f, 0xe8, 0xe4, 0x1e,
-	0xa7, 0x10, 0x85, 0x10, 0x54, 0x62, 0x6f, 0x4a, 0xac, 0xed, 0xbe, 0x31, 0x68, 0x38, 0xe9, 0x37,
-	0x6a, 0x83, 0x39, 0x63, 0x91, 0x65, 0xa6, 0x26, 0xf9, 0x89, 0xee, 0xc3, 0x7f, 0xd3, 0x90, 0x31,
-	0xca, 0x5c, 0x46, 0xfc, 0xa9, 0x97, 0x70, 0x6b, 0xa7, 0x6f, 0x0e, 0x1a, 0xce, 0xae, 0xb2, 0x3a,
-	0xca, 0x78, 0x5a, 0xa9, 0x57, 0xda, 0x3b, 0x99, 0x51, 0x87, 0xe2, 0x0e, 0xec, 0x15, 0x90, 0xf2,
-	0x84, 0xc6, 0x9c, 0xe0, 0x0f, 0xd0, 0x91, 0x96, 0x1b, 0xf2, 0x4f, 0x18, 0xe0, 0x21, 0xec, 0x2f,
-	0x97, 0x57, 0xd7, 0xa2, 0x03, 0xa8, 0x32, 0xc2, 0x67, 0x91, 0x48, 0x6b, 0xd7, 0x1d, 0x7d, 0xc2,
-	0x5f, 0x0d, 0xb0, 0x5f, 0x12, 0x31, 0x0e, 0x5e, 0xc5, 0x82, 0xb0, 0xd8, 0x8b, 0x36, 0x87, 0xf5,
-	0x1c, 0xf6, 0xd4, 0x3b, 0xba, 0x85, 0xd4, 0xed, 0x95, 0xa9, 0x6d, 0xa6, 0x6f, 0xcc, 0x2c, 0xf8,
-	0x09, 0xf4, 0x4a, 0x21, 0xfd, 0x81, 0xca, 0x0f, 0x03, 0xba, 0x17, 0xc9, 0xc4, 0x13, 0x9a, 0xfb,
-	0xb9, 0x7e, 0xa1, 0xbf, 0x67, 0xd2, 0x85, 0x3a, 0x23, 0xbe, 0x5b, 0x68, 0x72, 0x8d, 0x11, 0xff,
-	0x8d, 0x54, 0xca, 0x63, 0x38, 0xa0, 0x71, 0x34, 0x77, 0x2f, 0x99, 0x17, 0x8f, 0x03, 0xc2, 0xdd,
-	0xa9, 0x27, 0xc6, 0x41, 0x18, 0x5f, 0x59, 0x66, 0xdf, 0x1c, 0xb4, 0x9c, 0x7d, 0xe9, 0x3d, 0xd6,
-	0xce, 0x73, 0xed, 0x43, 0xff, 0x43, 0x8d, 0xf3, 0xc0, 0xbd, 0x26, 0x73, 0xab, 0x92, 0xd6, 0xab,
-	0x72, 0x1e, 0x9c, 0x91, 0x39, 0xba, 0x03, 0xcd, 0xeb, 0x98, 0x7e, 0x8e, 0xdd, 0x80, 0x72, 0x21,
-	0x35, 0x26, 0x9d, 0x90, 0x9a, 0x4e, 0xa4, 0x05, 0x1f, 0x82, 0x5d, 0xc6, 0x4d, 0x8b, 0x4a, 0x76,
-	0x2c, 0x8c, 0x73, 0xa9, 0xe5, 0x64, 0x34, 0xf7, 0xb4, 0x63, 0xd2, 0x95, 0xf2, 0x6e, 0x38, 0xfa,
-	0x84, 0x9f, 0xc2, 0x61, 0x79, 0xda, 0xa2, 0xd3, 0xe4, 0x4b, 0x28, 0x01, 0xe9, 0x4e, 0xab, 0x13,
-	0xf6, 0xc1, 0x2a, 0xe4, 0x51, 0x2a, 0x1c, 0xe2, 0x6f, 0xd2, 0xe7, 0x05, 0xbe, 0xed, 0x25, 0x7c,
-	0x0f, 0xa0, 0x5b, 0x72, 0x8f, 0x06, 0xd7, 0x06, 0x93, 0x11, 0x5f, 0x33, 0x92, 0x9f, 0xf8, 0x04,
-	0xd0, 0xeb, 0x90, 0x0b, 0x15, 0xce, 0x37, 0x00, 0x84, 0xbf, 0x1b, 0xd0, 0x59, 0x2a, 0xa5, 0xef,
-	0x7c, 0x06, 0x35, 0x05, 0x4d, 0x76, 0xc4, 0x1c, 0x34, 0x47, 0x38, 0x2b, 0x54, 0x12, 0x3d, 0xd4,
-	0xb8, 0xb3, 0x14, 0xfb, 0x1d, 0x54, 0x95, 0x29, 0x9f, 0x5c, 0xa3, 0xb0, 0x7b, 0x7a, 0xd0, 0xf0,
-	0xa5, 0xea, 0x5d, 0xb9, 0x81, 0x54, 0x1f, 0xea, 0xa9, 0xe1, 0x82, 0x45, 0x52, 0x89, 0xc9, 0x8c,
-	0x2b, 0x9f, 0xda, 0x4e, 0x35, 0x79, 0xbe, 0x60, 0xd1, 0xe8, 0x67, 0x05, 0x76, 0x55, 0xd9, 0xb7,
-	0x84, 0xdd, 0x84, 0x63, 0x82, 0x8e, 0xa1, 0x91, 0xef, 0x1d, 0x64, 0x65, 0x08, 0x7f, 0x5f, 0x9a,
-	0x76, 0xb7, 0xc4, 0xa3, 0xf5, 0xb4, 0x85, 0x3e, 0x42, 0xa7, 0x64, 0x06, 0x51, 0xce, 0x77, 0xf5,
-	0xce, 0xb0, 0xef, 0xae, 0x8d, 0xc9, 0x6f, 0x38, 0x83, 0x56, 0x71, 0x53, 0xa1, 0xde, 0xe2, 0x4d,
-	0x6e, 0xad, 0x47, 0xfb, 0xb0, 0xdc, 0x99, 0x17, 0x73, 0x01, 0xdd, 0x1e, 0x0f, 0x74, 0x94, 0x65,
-	0xad, 0x5c, 0x0b, 0x36, 0x5e, 0x17, 0x92, 0x95, 0x1f, 0x18, 0x68, 0x0c, 0xfb, 0x65, 0xa3, 0x82,
-	0x16, 0x64, 0x57, 0xcf, 0x9f, 0x7d, 0x6f, 0x7d, 0x50, 0xce, 0xe2, 0x3d, 0xec, 0xdd, 0xd2, 0x3b,
-	0xea, 0x97, 0x24, 0x2f, 0x8d, 0x9c, 0x7d, 0xb4, 0x26, 0x22, 0xaf, 0x7d, 0x0a, 0xcd, 0x82, 0x46,
-	0x91, 0x5d, 0x2a, 0x5c, 0x55, 0xaf, 0xb7, 0x46, 0xd4, 0x78, 0xeb, 0xa1, 0x71, 0x59, 0x4d, 0x7f,
-	0xc5, 0x8f, 0x7e, 0x05, 0x00, 0x00, 0xff, 0xff, 0x4b, 0x62, 0xf6, 0x64, 0xb0, 0x07, 0x00, 0x00,
+func init() { proto.RegisterFile("remote.proto", fileDescriptor_remote_8f251117f9f2149f) }
+
+var fileDescriptor_remote_8f251117f9f2149f = []byte{
+	// 718 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcd, 0x6e, 0xd3, 0x40,
+	0x10, 0xae, 0x93, 0x34, 0x3f, 0x93, 0x14, 0xa5, 0x9b, 0xaa, 0x38, 0x4e, 0x25, 0x52, 0x03, 0x92,
+	0x2f, 0x4d, 0xab, 0xf0, 0x73, 0x40, 0x20, 0x44, 0x0f, 0x15, 0xb4, 0x14, 0x21, 0x43, 0x2f, 0xbd,
+	0x18, 0x27, 0xd9, 0xc4, 0x56, 0x1d, 0xaf, 0xd9, 0x75, 0x0a, 0x79, 0x12, 0xc4, 0x23, 0x70, 0xe3,
+	0x99, 0x78, 0x02, 0xc4, 0x13, 0xa0, 0xf5, 0xae, 0x37, 0x2e, 0x75, 0x82, 0x44, 0xc5, 0x6d, 0xe7,
+	0xff, 0xfb, 0xc6, 0x33, 0x63, 0x68, 0x50, 0x3c, 0x25, 0x31, 0xee, 0x45, 0x94, 0xc4, 0x04, 0x95,
+	0x27, 0x7e, 0xec, 0x06, 0x73, 0xa3, 0xc1, 0x3c, 0x97, 0xe2, 0x91, 0xd0, 0x9a, 0xdf, 0x35, 0x68,
+	0xbe, 0x18, 0x8d, 0xec, 0xc4, 0xd3, 0xc6, 0x1f, 0x67, 0x98, 0xc5, 0xa8, 0x0f, 0x40, 0x71, 0x44,
+	0x98, 0x1f, 0x13, 0x3a, 0xd7, 0xb5, 0xae, 0x66, 0xd5, 0xfb, 0xa8, 0x27, 0xe2, 0x7b, 0xb6, 0xb2,
+	0xd8, 0x19, 0x2f, 0x84, 0xa0, 0x14, 0xba, 0x53, 0xac, 0x17, 0xba, 0x9a, 0x55, 0xb3, 0x93, 0x37,
+	0x6a, 0x42, 0x71, 0x46, 0x03, 0xbd, 0x98, 0xa8, 0xf8, 0x13, 0xdd, 0x87, 0x5b, 0x53, 0x9f, 0x52,
+	0x42, 0x1d, 0x8a, 0xc7, 0x53, 0x37, 0x62, 0xfa, 0x7a, 0xb7, 0x68, 0xd5, 0xec, 0x0d, 0xa1, 0xb5,
+	0x85, 0xf2, 0x49, 0xf9, 0xd7, 0x17, 0xab, 0x50, 0xd5, 0x8e, 0x4b, 0xd5, 0x52, 0x73, 0x3d, 0x35,
+	0xca, 0x10, 0xb3, 0x05, 0x9b, 0x19, 0xc4, 0x2c, 0x22, 0x21, 0xc3, 0x26, 0x86, 0x16, 0xd7, 0x5c,
+	0xe2, 0xff, 0xc2, 0x24, 0x05, 0x64, 0xf6, 0x60, 0xeb, 0x6a, 0x19, 0x51, 0x1e, 0x6d, 0x43, 0x99,
+	0x62, 0x36, 0x0b, 0xe2, 0xa4, 0x46, 0xd5, 0x96, 0x92, 0xf9, 0x55, 0x03, 0xe3, 0x08, 0xc7, 0x43,
+	0xef, 0x55, 0x18, 0x63, 0x1a, 0xba, 0xc1, 0xcd, 0xe1, 0x3d, 0x87, 0x4d, 0xf1, 0x5d, 0x9d, 0x4c,
+	0x68, 0x61, 0x69, 0x68, 0x93, 0xca, 0x8a, 0xa9, 0x46, 0x71, 0x79, 0x04, 0x9d, 0x5c, 0x68, 0x7f,
+	0xa1, 0xf4, 0x43, 0x83, 0xf6, 0x59, 0x34, 0x72, 0x63, 0xd9, 0x83, 0x53, 0xf9, 0xe5, 0xfe, 0x9d,
+	0x51, 0x1b, 0xaa, 0x14, 0x8f, 0x9d, 0x4c, 0xd3, 0x2b, 0x14, 0x8f, 0xdf, 0xf0, 0x09, 0x7a, 0x08,
+	0xdb, 0x24, 0x0c, 0xe6, 0xce, 0x80, 0xba, 0xe1, 0xd0, 0xc3, 0xcc, 0x99, 0xba, 0xf1, 0xd0, 0xf3,
+	0xc3, 0x89, 0x5e, 0xec, 0x16, 0xad, 0x86, 0xbd, 0xc5, 0xad, 0x87, 0xd2, 0x78, 0x2a, 0x6d, 0xe8,
+	0x36, 0x54, 0x18, 0xf3, 0x9c, 0x0b, 0x3c, 0xd7, 0x4b, 0x49, 0xbe, 0x32, 0x63, 0xde, 0x09, 0x9e,
+	0xa3, 0x3b, 0x50, 0xbf, 0x08, 0xc9, 0xa7, 0xd0, 0xf1, 0x08, 0x8b, 0xf9, 0xec, 0x71, 0x23, 0x24,
+	0xaa, 0x97, 0x5c, 0xa3, 0x7a, 0xb3, 0x03, 0x46, 0x1e, 0x47, 0x39, 0x6c, 0xcf, 0xa0, 0x73, 0xe4,
+	0x87, 0x6a, 0x04, 0x15, 0x29, 0xd9, 0x83, 0xa4, 0x73, 0xdc, 0x94, 0xf0, 0xaf, 0xd9, 0x52, 0x92,
+	0xc9, 0x0b, 0xe6, 0x63, 0xd8, 0xc9, 0x0f, 0x5f, 0x74, 0x1e, 0x7f, 0xf6, 0x39, 0x40, 0xd9, 0x79,
+	0x21, 0x99, 0x21, 0xe8, 0x99, 0x38, 0x42, 0x62, 0x1b, 0x8f, 0x6f, 0xd2, 0xf7, 0x05, 0xce, 0x42,
+	0x2e, 0xce, 0x3d, 0x68, 0xe7, 0xd4, 0x93, 0x20, 0x9b, 0x50, 0xa4, 0x78, 0x2c, 0x19, 0xf2, 0xa7,
+	0xf9, 0x16, 0xd0, 0x6b, 0x9f, 0xc5, 0xc2, 0x9d, 0xdd, 0x00, 0x98, 0x02, 0xf0, 0x4d, 0x83, 0xd6,
+	0x95, 0x94, 0xb2, 0xf6, 0x53, 0xa8, 0x08, 0xa8, 0xbc, 0x43, 0x45, 0xab, 0xde, 0x37, 0xd3, 0x84,
+	0x39, 0xde, 0x3d, 0x89, 0x3f, 0x0d, 0x31, 0xde, 0x43, 0x59, 0xa8, 0xd4, 0xa6, 0x6b, 0x99, 0x9b,
+	0xd5, 0x81, 0xda, 0x98, 0x6f, 0x85, 0xc3, 0x2f, 0x97, 0xe8, 0x4b, 0x35, 0x51, 0x9c, 0xd1, 0x80,
+	0x4f, 0x6a, 0x34, 0x63, 0xc2, 0x26, 0xae, 0x5a, 0x85, 0xcb, 0x67, 0x34, 0xe8, 0xff, 0x2c, 0xc1,
+	0x86, 0x48, 0xfb, 0x0e, 0xd3, 0x4b, 0x7f, 0x88, 0xd1, 0x21, 0xd4, 0xd4, 0x9d, 0x42, 0x7a, 0x8a,
+	0xf0, 0xcf, 0x63, 0x6b, 0xb4, 0x73, 0x2c, 0x72, 0xce, 0xd6, 0xd0, 0x07, 0x68, 0xe5, 0xec, 0x28,
+	0x52, 0x7c, 0x97, 0xdf, 0x16, 0xe3, 0xee, 0x4a, 0x1f, 0x55, 0xe1, 0x04, 0x1a, 0xd9, 0x8b, 0x86,
+	0x3a, 0x8b, 0x6f, 0x73, 0xed, 0x9c, 0x1a, 0x3b, 0xf9, 0x46, 0x95, 0xcc, 0x01, 0x74, 0x7d, 0x6d,
+	0xd0, 0x6e, 0x1a, 0xb5, 0xf4, 0x6c, 0x18, 0xe6, 0x2a, 0x97, 0x34, 0xbd, 0xa5, 0xa1, 0x21, 0x6c,
+	0xe5, 0xad, 0x0e, 0x5a, 0x90, 0x5d, 0xbe, 0x97, 0xc6, 0xbd, 0xd5, 0x4e, 0x8a, 0xc5, 0x39, 0x6c,
+	0x5e, 0x9b, 0x7b, 0xd4, 0xcd, 0x09, 0xbe, 0xb2, 0x82, 0xc6, 0xee, 0x0a, 0x0f, 0x95, 0xfb, 0x18,
+	0xea, 0x99, 0x19, 0x45, 0x46, 0xee, 0xe0, 0x8a, 0x7c, 0x9d, 0x15, 0x43, 0x6d, 0xae, 0x1d, 0x68,
+	0x87, 0x07, 0xe7, 0xdc, 0x23, 0x70, 0x07, 0xbd, 0x21, 0x99, 0xee, 0x8b, 0xe7, 0x1e, 0xa1, 0x93,
+	0x7d, 0x11, 0xb7, 0x97, 0xfc, 0xe1, 0xf7, 0x27, 0x44, 0xca, 0xd1, 0x60, 0x50, 0x4e, 0x54, 0x0f,
+	0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, 0xcd, 0x9e, 0xcb, 0xe7, 0x1a, 0x08, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/repository-service.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/repository-service.pb.go
index 12f49f537859ed8cc4251ffc6f1c5c506319f190..143ce81a73220115868bec7af3db15147156b9cf 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/repository-service.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/repository-service.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: repository-service.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -49,7 +49,7 @@ func (x GetArchiveRequest_Format) String() string {
 	return proto.EnumName(GetArchiveRequest_Format_name, int32(x))
 }
 func (GetArchiveRequest_Format) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{18, 0}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{18, 0}
 }
 
 type GetRawChangesResponse_RawChange_Operation int32
@@ -87,7 +87,7 @@ func (x GetRawChangesResponse_RawChange_Operation) String() string {
 	return proto.EnumName(GetRawChangesResponse_RawChange_Operation_name, int32(x))
 }
 func (GetRawChangesResponse_RawChange_Operation) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{63, 0, 0}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{63, 0, 0}
 }
 
 type RepositoryExistsRequest struct {
@@ -101,7 +101,7 @@ func (m *RepositoryExistsRequest) Reset()         { *m = RepositoryExistsRequest
 func (m *RepositoryExistsRequest) String() string { return proto.CompactTextString(m) }
 func (*RepositoryExistsRequest) ProtoMessage()    {}
 func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{0}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{0}
 }
 func (m *RepositoryExistsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RepositoryExistsRequest.Unmarshal(m, b)
@@ -139,7 +139,7 @@ func (m *RepositoryExistsResponse) Reset()         { *m = RepositoryExistsRespon
 func (m *RepositoryExistsResponse) String() string { return proto.CompactTextString(m) }
 func (*RepositoryExistsResponse) ProtoMessage()    {}
 func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{1}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{1}
 }
 func (m *RepositoryExistsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RepositoryExistsResponse.Unmarshal(m, b)
@@ -177,7 +177,7 @@ func (m *RepackIncrementalRequest) Reset()         { *m = RepackIncrementalReque
 func (m *RepackIncrementalRequest) String() string { return proto.CompactTextString(m) }
 func (*RepackIncrementalRequest) ProtoMessage()    {}
 func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{2}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{2}
 }
 func (m *RepackIncrementalRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RepackIncrementalRequest.Unmarshal(m, b)
@@ -214,7 +214,7 @@ func (m *RepackIncrementalResponse) Reset()         { *m = RepackIncrementalResp
 func (m *RepackIncrementalResponse) String() string { return proto.CompactTextString(m) }
 func (*RepackIncrementalResponse) ProtoMessage()    {}
 func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{3}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{3}
 }
 func (m *RepackIncrementalResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RepackIncrementalResponse.Unmarshal(m, b)
@@ -246,7 +246,7 @@ func (m *RepackFullRequest) Reset()         { *m = RepackFullRequest{} }
 func (m *RepackFullRequest) String() string { return proto.CompactTextString(m) }
 func (*RepackFullRequest) ProtoMessage()    {}
 func (*RepackFullRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{4}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{4}
 }
 func (m *RepackFullRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RepackFullRequest.Unmarshal(m, b)
@@ -290,7 +290,7 @@ func (m *RepackFullResponse) Reset()         { *m = RepackFullResponse{} }
 func (m *RepackFullResponse) String() string { return proto.CompactTextString(m) }
 func (*RepackFullResponse) ProtoMessage()    {}
 func (*RepackFullResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{5}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{5}
 }
 func (m *RepackFullResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RepackFullResponse.Unmarshal(m, b)
@@ -322,7 +322,7 @@ func (m *GarbageCollectRequest) Reset()         { *m = GarbageCollectRequest{} }
 func (m *GarbageCollectRequest) String() string { return proto.CompactTextString(m) }
 func (*GarbageCollectRequest) ProtoMessage()    {}
 func (*GarbageCollectRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{6}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{6}
 }
 func (m *GarbageCollectRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GarbageCollectRequest.Unmarshal(m, b)
@@ -366,7 +366,7 @@ func (m *GarbageCollectResponse) Reset()         { *m = GarbageCollectResponse{}
 func (m *GarbageCollectResponse) String() string { return proto.CompactTextString(m) }
 func (*GarbageCollectResponse) ProtoMessage()    {}
 func (*GarbageCollectResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{7}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{7}
 }
 func (m *GarbageCollectResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GarbageCollectResponse.Unmarshal(m, b)
@@ -397,7 +397,7 @@ func (m *CleanupRequest) Reset()         { *m = CleanupRequest{} }
 func (m *CleanupRequest) String() string { return proto.CompactTextString(m) }
 func (*CleanupRequest) ProtoMessage()    {}
 func (*CleanupRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{8}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{8}
 }
 func (m *CleanupRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CleanupRequest.Unmarshal(m, b)
@@ -434,7 +434,7 @@ func (m *CleanupResponse) Reset()         { *m = CleanupResponse{} }
 func (m *CleanupResponse) String() string { return proto.CompactTextString(m) }
 func (*CleanupResponse) ProtoMessage()    {}
 func (*CleanupResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{9}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{9}
 }
 func (m *CleanupResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CleanupResponse.Unmarshal(m, b)
@@ -465,7 +465,7 @@ func (m *RepositorySizeRequest) Reset()         { *m = RepositorySizeRequest{} }
 func (m *RepositorySizeRequest) String() string { return proto.CompactTextString(m) }
 func (*RepositorySizeRequest) ProtoMessage()    {}
 func (*RepositorySizeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{10}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{10}
 }
 func (m *RepositorySizeRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RepositorySizeRequest.Unmarshal(m, b)
@@ -504,7 +504,7 @@ func (m *RepositorySizeResponse) Reset()         { *m = RepositorySizeResponse{}
 func (m *RepositorySizeResponse) String() string { return proto.CompactTextString(m) }
 func (*RepositorySizeResponse) ProtoMessage()    {}
 func (*RepositorySizeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{11}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{11}
 }
 func (m *RepositorySizeResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RepositorySizeResponse.Unmarshal(m, b)
@@ -543,7 +543,7 @@ func (m *ApplyGitattributesRequest) Reset()         { *m = ApplyGitattributesReq
 func (m *ApplyGitattributesRequest) String() string { return proto.CompactTextString(m) }
 func (*ApplyGitattributesRequest) ProtoMessage()    {}
 func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{12}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{12}
 }
 func (m *ApplyGitattributesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ApplyGitattributesRequest.Unmarshal(m, b)
@@ -587,7 +587,7 @@ func (m *ApplyGitattributesResponse) Reset()         { *m = ApplyGitattributesRe
 func (m *ApplyGitattributesResponse) String() string { return proto.CompactTextString(m) }
 func (*ApplyGitattributesResponse) ProtoMessage()    {}
 func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{13}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{13}
 }
 func (m *ApplyGitattributesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ApplyGitattributesResponse.Unmarshal(m, b)
@@ -625,7 +625,7 @@ func (m *FetchRemoteRequest) Reset()         { *m = FetchRemoteRequest{} }
 func (m *FetchRemoteRequest) String() string { return proto.CompactTextString(m) }
 func (*FetchRemoteRequest) ProtoMessage()    {}
 func (*FetchRemoteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{14}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{14}
 }
 func (m *FetchRemoteRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FetchRemoteRequest.Unmarshal(m, b)
@@ -711,7 +711,7 @@ func (m *FetchRemoteResponse) Reset()         { *m = FetchRemoteResponse{} }
 func (m *FetchRemoteResponse) String() string { return proto.CompactTextString(m) }
 func (*FetchRemoteResponse) ProtoMessage()    {}
 func (*FetchRemoteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{15}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{15}
 }
 func (m *FetchRemoteResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FetchRemoteResponse.Unmarshal(m, b)
@@ -742,7 +742,7 @@ func (m *CreateRepositoryRequest) Reset()         { *m = CreateRepositoryRequest
 func (m *CreateRepositoryRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryRequest) ProtoMessage()    {}
 func (*CreateRepositoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{16}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{16}
 }
 func (m *CreateRepositoryRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateRepositoryRequest.Unmarshal(m, b)
@@ -779,7 +779,7 @@ func (m *CreateRepositoryResponse) Reset()         { *m = CreateRepositoryRespon
 func (m *CreateRepositoryResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryResponse) ProtoMessage()    {}
 func (*CreateRepositoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{17}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{17}
 }
 func (m *CreateRepositoryResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateRepositoryResponse.Unmarshal(m, b)
@@ -813,7 +813,7 @@ func (m *GetArchiveRequest) Reset()         { *m = GetArchiveRequest{} }
 func (m *GetArchiveRequest) String() string { return proto.CompactTextString(m) }
 func (*GetArchiveRequest) ProtoMessage()    {}
 func (*GetArchiveRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{18}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{18}
 }
 func (m *GetArchiveRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetArchiveRequest.Unmarshal(m, b)
@@ -872,7 +872,7 @@ func (m *GetArchiveResponse) Reset()         { *m = GetArchiveResponse{} }
 func (m *GetArchiveResponse) String() string { return proto.CompactTextString(m) }
 func (*GetArchiveResponse) ProtoMessage()    {}
 func (*GetArchiveResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{19}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{19}
 }
 func (m *GetArchiveResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetArchiveResponse.Unmarshal(m, b)
@@ -910,7 +910,7 @@ func (m *HasLocalBranchesRequest) Reset()         { *m = HasLocalBranchesRequest
 func (m *HasLocalBranchesRequest) String() string { return proto.CompactTextString(m) }
 func (*HasLocalBranchesRequest) ProtoMessage()    {}
 func (*HasLocalBranchesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{20}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{20}
 }
 func (m *HasLocalBranchesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_HasLocalBranchesRequest.Unmarshal(m, b)
@@ -948,7 +948,7 @@ func (m *HasLocalBranchesResponse) Reset()         { *m = HasLocalBranchesRespon
 func (m *HasLocalBranchesResponse) String() string { return proto.CompactTextString(m) }
 func (*HasLocalBranchesResponse) ProtoMessage()    {}
 func (*HasLocalBranchesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{21}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{21}
 }
 func (m *HasLocalBranchesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_HasLocalBranchesResponse.Unmarshal(m, b)
@@ -989,7 +989,7 @@ func (m *FetchSourceBranchRequest) Reset()         { *m = FetchSourceBranchReque
 func (m *FetchSourceBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*FetchSourceBranchRequest) ProtoMessage()    {}
 func (*FetchSourceBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{22}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{22}
 }
 func (m *FetchSourceBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FetchSourceBranchRequest.Unmarshal(m, b)
@@ -1048,7 +1048,7 @@ func (m *FetchSourceBranchResponse) Reset()         { *m = FetchSourceBranchResp
 func (m *FetchSourceBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*FetchSourceBranchResponse) ProtoMessage()    {}
 func (*FetchSourceBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{23}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{23}
 }
 func (m *FetchSourceBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FetchSourceBranchResponse.Unmarshal(m, b)
@@ -1086,7 +1086,7 @@ func (m *FsckRequest) Reset()         { *m = FsckRequest{} }
 func (m *FsckRequest) String() string { return proto.CompactTextString(m) }
 func (*FsckRequest) ProtoMessage()    {}
 func (*FsckRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{24}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{24}
 }
 func (m *FsckRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FsckRequest.Unmarshal(m, b)
@@ -1124,7 +1124,7 @@ func (m *FsckResponse) Reset()         { *m = FsckResponse{} }
 func (m *FsckResponse) String() string { return proto.CompactTextString(m) }
 func (*FsckResponse) ProtoMessage()    {}
 func (*FsckResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{25}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{25}
 }
 func (m *FsckResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FsckResponse.Unmarshal(m, b)
@@ -1166,7 +1166,7 @@ func (m *WriteRefRequest) Reset()         { *m = WriteRefRequest{} }
 func (m *WriteRefRequest) String() string { return proto.CompactTextString(m) }
 func (*WriteRefRequest) ProtoMessage()    {}
 func (*WriteRefRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{26}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{26}
 }
 func (m *WriteRefRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WriteRefRequest.Unmarshal(m, b)
@@ -1231,7 +1231,7 @@ func (m *WriteRefResponse) Reset()         { *m = WriteRefResponse{} }
 func (m *WriteRefResponse) String() string { return proto.CompactTextString(m) }
 func (*WriteRefResponse) ProtoMessage()    {}
 func (*WriteRefResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{27}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{27}
 }
 func (m *WriteRefResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WriteRefResponse.Unmarshal(m, b)
@@ -1266,7 +1266,7 @@ func (m *FindMergeBaseRequest) Reset()         { *m = FindMergeBaseRequest{} }
 func (m *FindMergeBaseRequest) String() string { return proto.CompactTextString(m) }
 func (*FindMergeBaseRequest) ProtoMessage()    {}
 func (*FindMergeBaseRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{28}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{28}
 }
 func (m *FindMergeBaseRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindMergeBaseRequest.Unmarshal(m, b)
@@ -1311,7 +1311,7 @@ func (m *FindMergeBaseResponse) Reset()         { *m = FindMergeBaseResponse{} }
 func (m *FindMergeBaseResponse) String() string { return proto.CompactTextString(m) }
 func (*FindMergeBaseResponse) ProtoMessage()    {}
 func (*FindMergeBaseResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{29}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{29}
 }
 func (m *FindMergeBaseResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindMergeBaseResponse.Unmarshal(m, b)
@@ -1350,7 +1350,7 @@ func (m *CreateForkRequest) Reset()         { *m = CreateForkRequest{} }
 func (m *CreateForkRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateForkRequest) ProtoMessage()    {}
 func (*CreateForkRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{30}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{30}
 }
 func (m *CreateForkRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateForkRequest.Unmarshal(m, b)
@@ -1394,7 +1394,7 @@ func (m *CreateForkResponse) Reset()         { *m = CreateForkResponse{} }
 func (m *CreateForkResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateForkResponse) ProtoMessage()    {}
 func (*CreateForkResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{31}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{31}
 }
 func (m *CreateForkResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateForkResponse.Unmarshal(m, b)
@@ -1426,7 +1426,7 @@ func (m *IsRebaseInProgressRequest) Reset()         { *m = IsRebaseInProgressReq
 func (m *IsRebaseInProgressRequest) String() string { return proto.CompactTextString(m) }
 func (*IsRebaseInProgressRequest) ProtoMessage()    {}
 func (*IsRebaseInProgressRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{32}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{32}
 }
 func (m *IsRebaseInProgressRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_IsRebaseInProgressRequest.Unmarshal(m, b)
@@ -1471,7 +1471,7 @@ func (m *IsRebaseInProgressResponse) Reset()         { *m = IsRebaseInProgressRe
 func (m *IsRebaseInProgressResponse) String() string { return proto.CompactTextString(m) }
 func (*IsRebaseInProgressResponse) ProtoMessage()    {}
 func (*IsRebaseInProgressResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{33}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{33}
 }
 func (m *IsRebaseInProgressResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_IsRebaseInProgressResponse.Unmarshal(m, b)
@@ -1510,7 +1510,7 @@ func (m *IsSquashInProgressRequest) Reset()         { *m = IsSquashInProgressReq
 func (m *IsSquashInProgressRequest) String() string { return proto.CompactTextString(m) }
 func (*IsSquashInProgressRequest) ProtoMessage()    {}
 func (*IsSquashInProgressRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{34}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{34}
 }
 func (m *IsSquashInProgressRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_IsSquashInProgressRequest.Unmarshal(m, b)
@@ -1555,7 +1555,7 @@ func (m *IsSquashInProgressResponse) Reset()         { *m = IsSquashInProgressRe
 func (m *IsSquashInProgressResponse) String() string { return proto.CompactTextString(m) }
 func (*IsSquashInProgressResponse) ProtoMessage()    {}
 func (*IsSquashInProgressResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{35}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{35}
 }
 func (m *IsSquashInProgressResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_IsSquashInProgressResponse.Unmarshal(m, b)
@@ -1594,7 +1594,7 @@ func (m *CreateRepositoryFromURLRequest) Reset()         { *m = CreateRepository
 func (m *CreateRepositoryFromURLRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromURLRequest) ProtoMessage()    {}
 func (*CreateRepositoryFromURLRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{36}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{36}
 }
 func (m *CreateRepositoryFromURLRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateRepositoryFromURLRequest.Unmarshal(m, b)
@@ -1638,7 +1638,7 @@ func (m *CreateRepositoryFromURLResponse) Reset()         { *m = CreateRepositor
 func (m *CreateRepositoryFromURLResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromURLResponse) ProtoMessage()    {}
 func (*CreateRepositoryFromURLResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{37}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{37}
 }
 func (m *CreateRepositoryFromURLResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateRepositoryFromURLResponse.Unmarshal(m, b)
@@ -1669,7 +1669,7 @@ func (m *CreateBundleRequest) Reset()         { *m = CreateBundleRequest{} }
 func (m *CreateBundleRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateBundleRequest) ProtoMessage()    {}
 func (*CreateBundleRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{38}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{38}
 }
 func (m *CreateBundleRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateBundleRequest.Unmarshal(m, b)
@@ -1707,7 +1707,7 @@ func (m *CreateBundleResponse) Reset()         { *m = CreateBundleResponse{} }
 func (m *CreateBundleResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateBundleResponse) ProtoMessage()    {}
 func (*CreateBundleResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{39}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{39}
 }
 func (m *CreateBundleResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateBundleResponse.Unmarshal(m, b)
@@ -1746,7 +1746,7 @@ func (m *WriteConfigRequest) Reset()         { *m = WriteConfigRequest{} }
 func (m *WriteConfigRequest) String() string { return proto.CompactTextString(m) }
 func (*WriteConfigRequest) ProtoMessage()    {}
 func (*WriteConfigRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{40}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{40}
 }
 func (m *WriteConfigRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WriteConfigRequest.Unmarshal(m, b)
@@ -1791,7 +1791,7 @@ func (m *WriteConfigResponse) Reset()         { *m = WriteConfigResponse{} }
 func (m *WriteConfigResponse) String() string { return proto.CompactTextString(m) }
 func (*WriteConfigResponse) ProtoMessage()    {}
 func (*WriteConfigResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{41}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{41}
 }
 func (m *WriteConfigResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WriteConfigResponse.Unmarshal(m, b)
@@ -1830,7 +1830,7 @@ func (m *SetConfigRequest) Reset()         { *m = SetConfigRequest{} }
 func (m *SetConfigRequest) String() string { return proto.CompactTextString(m) }
 func (*SetConfigRequest) ProtoMessage()    {}
 func (*SetConfigRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{42}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{42}
 }
 func (m *SetConfigRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetConfigRequest.Unmarshal(m, b)
@@ -1880,7 +1880,7 @@ func (m *SetConfigRequest_Entry) Reset()         { *m = SetConfigRequest_Entry{}
 func (m *SetConfigRequest_Entry) String() string { return proto.CompactTextString(m) }
 func (*SetConfigRequest_Entry) ProtoMessage()    {}
 func (*SetConfigRequest_Entry) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{42, 0}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{42, 0}
 }
 func (m *SetConfigRequest_Entry) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetConfigRequest_Entry.Unmarshal(m, b)
@@ -2050,7 +2050,7 @@ func (m *SetConfigResponse) Reset()         { *m = SetConfigResponse{} }
 func (m *SetConfigResponse) String() string { return proto.CompactTextString(m) }
 func (*SetConfigResponse) ProtoMessage()    {}
 func (*SetConfigResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{43}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{43}
 }
 func (m *SetConfigResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetConfigResponse.Unmarshal(m, b)
@@ -2082,7 +2082,7 @@ func (m *DeleteConfigRequest) Reset()         { *m = DeleteConfigRequest{} }
 func (m *DeleteConfigRequest) String() string { return proto.CompactTextString(m) }
 func (*DeleteConfigRequest) ProtoMessage()    {}
 func (*DeleteConfigRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{44}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{44}
 }
 func (m *DeleteConfigRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteConfigRequest.Unmarshal(m, b)
@@ -2126,7 +2126,7 @@ func (m *DeleteConfigResponse) Reset()         { *m = DeleteConfigResponse{} }
 func (m *DeleteConfigResponse) String() string { return proto.CompactTextString(m) }
 func (*DeleteConfigResponse) ProtoMessage()    {}
 func (*DeleteConfigResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{45}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{45}
 }
 func (m *DeleteConfigResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteConfigResponse.Unmarshal(m, b)
@@ -2158,7 +2158,7 @@ func (m *RestoreCustomHooksRequest) Reset()         { *m = RestoreCustomHooksReq
 func (m *RestoreCustomHooksRequest) String() string { return proto.CompactTextString(m) }
 func (*RestoreCustomHooksRequest) ProtoMessage()    {}
 func (*RestoreCustomHooksRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{46}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{46}
 }
 func (m *RestoreCustomHooksRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RestoreCustomHooksRequest.Unmarshal(m, b)
@@ -2202,7 +2202,7 @@ func (m *RestoreCustomHooksResponse) Reset()         { *m = RestoreCustomHooksRe
 func (m *RestoreCustomHooksResponse) String() string { return proto.CompactTextString(m) }
 func (*RestoreCustomHooksResponse) ProtoMessage()    {}
 func (*RestoreCustomHooksResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{47}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{47}
 }
 func (m *RestoreCustomHooksResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RestoreCustomHooksResponse.Unmarshal(m, b)
@@ -2233,7 +2233,7 @@ func (m *BackupCustomHooksRequest) Reset()         { *m = BackupCustomHooksReque
 func (m *BackupCustomHooksRequest) String() string { return proto.CompactTextString(m) }
 func (*BackupCustomHooksRequest) ProtoMessage()    {}
 func (*BackupCustomHooksRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{48}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{48}
 }
 func (m *BackupCustomHooksRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BackupCustomHooksRequest.Unmarshal(m, b)
@@ -2271,7 +2271,7 @@ func (m *BackupCustomHooksResponse) Reset()         { *m = BackupCustomHooksResp
 func (m *BackupCustomHooksResponse) String() string { return proto.CompactTextString(m) }
 func (*BackupCustomHooksResponse) ProtoMessage()    {}
 func (*BackupCustomHooksResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{49}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{49}
 }
 func (m *BackupCustomHooksResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BackupCustomHooksResponse.Unmarshal(m, b)
@@ -2311,7 +2311,7 @@ func (m *CreateRepositoryFromBundleRequest) Reset()         { *m = CreateReposit
 func (m *CreateRepositoryFromBundleRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromBundleRequest) ProtoMessage()    {}
 func (*CreateRepositoryFromBundleRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{50}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{50}
 }
 func (m *CreateRepositoryFromBundleRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateRepositoryFromBundleRequest.Unmarshal(m, b)
@@ -2355,7 +2355,7 @@ func (m *CreateRepositoryFromBundleResponse) Reset()         { *m = CreateReposi
 func (m *CreateRepositoryFromBundleResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromBundleResponse) ProtoMessage()    {}
 func (*CreateRepositoryFromBundleResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{51}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{51}
 }
 func (m *CreateRepositoryFromBundleResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateRepositoryFromBundleResponse.Unmarshal(m, b)
@@ -2386,7 +2386,7 @@ func (m *FindLicenseRequest) Reset()         { *m = FindLicenseRequest{} }
 func (m *FindLicenseRequest) String() string { return proto.CompactTextString(m) }
 func (*FindLicenseRequest) ProtoMessage()    {}
 func (*FindLicenseRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{52}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{52}
 }
 func (m *FindLicenseRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindLicenseRequest.Unmarshal(m, b)
@@ -2424,7 +2424,7 @@ func (m *FindLicenseResponse) Reset()         { *m = FindLicenseResponse{} }
 func (m *FindLicenseResponse) String() string { return proto.CompactTextString(m) }
 func (*FindLicenseResponse) ProtoMessage()    {}
 func (*FindLicenseResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{53}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{53}
 }
 func (m *FindLicenseResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindLicenseResponse.Unmarshal(m, b)
@@ -2462,7 +2462,7 @@ func (m *GetInfoAttributesRequest) Reset()         { *m = GetInfoAttributesReque
 func (m *GetInfoAttributesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetInfoAttributesRequest) ProtoMessage()    {}
 func (*GetInfoAttributesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{54}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{54}
 }
 func (m *GetInfoAttributesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetInfoAttributesRequest.Unmarshal(m, b)
@@ -2500,7 +2500,7 @@ func (m *GetInfoAttributesResponse) Reset()         { *m = GetInfoAttributesResp
 func (m *GetInfoAttributesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetInfoAttributesResponse) ProtoMessage()    {}
 func (*GetInfoAttributesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{55}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{55}
 }
 func (m *GetInfoAttributesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetInfoAttributesResponse.Unmarshal(m, b)
@@ -2538,7 +2538,7 @@ func (m *CalculateChecksumRequest) Reset()         { *m = CalculateChecksumReque
 func (m *CalculateChecksumRequest) String() string { return proto.CompactTextString(m) }
 func (*CalculateChecksumRequest) ProtoMessage()    {}
 func (*CalculateChecksumRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{56}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{56}
 }
 func (m *CalculateChecksumRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CalculateChecksumRequest.Unmarshal(m, b)
@@ -2576,7 +2576,7 @@ func (m *CalculateChecksumResponse) Reset()         { *m = CalculateChecksumResp
 func (m *CalculateChecksumResponse) String() string { return proto.CompactTextString(m) }
 func (*CalculateChecksumResponse) ProtoMessage()    {}
 func (*CalculateChecksumResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{57}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{57}
 }
 func (m *CalculateChecksumResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CalculateChecksumResponse.Unmarshal(m, b)
@@ -2614,7 +2614,7 @@ func (m *GetSnapshotRequest) Reset()         { *m = GetSnapshotRequest{} }
 func (m *GetSnapshotRequest) String() string { return proto.CompactTextString(m) }
 func (*GetSnapshotRequest) ProtoMessage()    {}
 func (*GetSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{58}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{58}
 }
 func (m *GetSnapshotRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetSnapshotRequest.Unmarshal(m, b)
@@ -2652,7 +2652,7 @@ func (m *GetSnapshotResponse) Reset()         { *m = GetSnapshotResponse{} }
 func (m *GetSnapshotResponse) String() string { return proto.CompactTextString(m) }
 func (*GetSnapshotResponse) ProtoMessage()    {}
 func (*GetSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{59}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{59}
 }
 func (m *GetSnapshotResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetSnapshotResponse.Unmarshal(m, b)
@@ -2692,7 +2692,7 @@ func (m *CreateRepositoryFromSnapshotRequest) Reset()         { *m = CreateRepos
 func (m *CreateRepositoryFromSnapshotRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromSnapshotRequest) ProtoMessage()    {}
 func (*CreateRepositoryFromSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{60}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{60}
 }
 func (m *CreateRepositoryFromSnapshotRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateRepositoryFromSnapshotRequest.Unmarshal(m, b)
@@ -2743,7 +2743,7 @@ func (m *CreateRepositoryFromSnapshotResponse) Reset()         { *m = CreateRepo
 func (m *CreateRepositoryFromSnapshotResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromSnapshotResponse) ProtoMessage()    {}
 func (*CreateRepositoryFromSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{61}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{61}
 }
 func (m *CreateRepositoryFromSnapshotResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateRepositoryFromSnapshotResponse.Unmarshal(m, b)
@@ -2776,7 +2776,7 @@ func (m *GetRawChangesRequest) Reset()         { *m = GetRawChangesRequest{} }
 func (m *GetRawChangesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetRawChangesRequest) ProtoMessage()    {}
 func (*GetRawChangesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{62}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{62}
 }
 func (m *GetRawChangesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetRawChangesRequest.Unmarshal(m, b)
@@ -2828,7 +2828,7 @@ func (m *GetRawChangesResponse) Reset()         { *m = GetRawChangesResponse{} }
 func (m *GetRawChangesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetRawChangesResponse) ProtoMessage()    {}
 func (*GetRawChangesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{63}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{63}
 }
 func (m *GetRawChangesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetRawChangesResponse.Unmarshal(m, b)
@@ -2873,7 +2873,7 @@ func (m *GetRawChangesResponse_RawChange) Reset()         { *m = GetRawChangesRe
 func (m *GetRawChangesResponse_RawChange) String() string { return proto.CompactTextString(m) }
 func (*GetRawChangesResponse_RawChange) ProtoMessage()    {}
 func (*GetRawChangesResponse_RawChange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{63, 0}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{63, 0}
 }
 func (m *GetRawChangesResponse_RawChange) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetRawChangesResponse_RawChange.Unmarshal(m, b)
@@ -2962,7 +2962,7 @@ func (m *SearchFilesByNameRequest) Reset()         { *m = SearchFilesByNameReque
 func (m *SearchFilesByNameRequest) String() string { return proto.CompactTextString(m) }
 func (*SearchFilesByNameRequest) ProtoMessage()    {}
 func (*SearchFilesByNameRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{64}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{64}
 }
 func (m *SearchFilesByNameRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SearchFilesByNameRequest.Unmarshal(m, b)
@@ -3014,7 +3014,7 @@ func (m *SearchFilesByNameResponse) Reset()         { *m = SearchFilesByNameResp
 func (m *SearchFilesByNameResponse) String() string { return proto.CompactTextString(m) }
 func (*SearchFilesByNameResponse) ProtoMessage()    {}
 func (*SearchFilesByNameResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{65}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{65}
 }
 func (m *SearchFilesByNameResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SearchFilesByNameResponse.Unmarshal(m, b)
@@ -3055,7 +3055,7 @@ func (m *SearchFilesByContentRequest) Reset()         { *m = SearchFilesByConten
 func (m *SearchFilesByContentRequest) String() string { return proto.CompactTextString(m) }
 func (*SearchFilesByContentRequest) ProtoMessage()    {}
 func (*SearchFilesByContentRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{66}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{66}
 }
 func (m *SearchFilesByContentRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SearchFilesByContentRequest.Unmarshal(m, b)
@@ -3116,7 +3116,7 @@ func (m *SearchFilesByContentResponse) Reset()         { *m = SearchFilesByConte
 func (m *SearchFilesByContentResponse) String() string { return proto.CompactTextString(m) }
 func (*SearchFilesByContentResponse) ProtoMessage()    {}
 func (*SearchFilesByContentResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{67}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{67}
 }
 func (m *SearchFilesByContentResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SearchFilesByContentResponse.Unmarshal(m, b)
@@ -3170,7 +3170,7 @@ func (m *PreFetchRequest) Reset()         { *m = PreFetchRequest{} }
 func (m *PreFetchRequest) String() string { return proto.CompactTextString(m) }
 func (*PreFetchRequest) ProtoMessage()    {}
 func (*PreFetchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{68}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{68}
 }
 func (m *PreFetchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PreFetchRequest.Unmarshal(m, b)
@@ -3221,7 +3221,7 @@ func (m *PreFetchResponse) Reset()         { *m = PreFetchResponse{} }
 func (m *PreFetchResponse) String() string { return proto.CompactTextString(m) }
 func (*PreFetchResponse) ProtoMessage()    {}
 func (*PreFetchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_repository_service_e78248130d6ea2d6, []int{69}
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{69}
 }
 func (m *PreFetchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PreFetchResponse.Unmarshal(m, b)
@@ -3241,6 +3241,236 @@ func (m *PreFetchResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_PreFetchResponse proto.InternalMessageInfo
 
+type Remote struct {
+	Url                     string   `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
+	Name                    string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	HttpAuthorizationHeader string   `protobuf:"bytes,3,opt,name=http_authorization_header,json=httpAuthorizationHeader,proto3" json:"http_authorization_header,omitempty"`
+	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
+	XXX_unrecognized        []byte   `json:"-"`
+	XXX_sizecache           int32    `json:"-"`
+}
+
+func (m *Remote) Reset()         { *m = Remote{} }
+func (m *Remote) String() string { return proto.CompactTextString(m) }
+func (*Remote) ProtoMessage()    {}
+func (*Remote) Descriptor() ([]byte, []int) {
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{70}
+}
+func (m *Remote) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Remote.Unmarshal(m, b)
+}
+func (m *Remote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Remote.Marshal(b, m, deterministic)
+}
+func (dst *Remote) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Remote.Merge(dst, src)
+}
+func (m *Remote) XXX_Size() int {
+	return xxx_messageInfo_Remote.Size(m)
+}
+func (m *Remote) XXX_DiscardUnknown() {
+	xxx_messageInfo_Remote.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Remote proto.InternalMessageInfo
+
+func (m *Remote) GetUrl() string {
+	if m != nil {
+		return m.Url
+	}
+	return ""
+}
+
+func (m *Remote) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *Remote) GetHttpAuthorizationHeader() string {
+	if m != nil {
+		return m.HttpAuthorizationHeader
+	}
+	return ""
+}
+
+type FetchHTTPRemoteRequest struct {
+	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	Remote               *Remote     `protobuf:"bytes,2,opt,name=remote,proto3" json:"remote,omitempty"`
+	Timeout              int32       `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *FetchHTTPRemoteRequest) Reset()         { *m = FetchHTTPRemoteRequest{} }
+func (m *FetchHTTPRemoteRequest) String() string { return proto.CompactTextString(m) }
+func (*FetchHTTPRemoteRequest) ProtoMessage()    {}
+func (*FetchHTTPRemoteRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{71}
+}
+func (m *FetchHTTPRemoteRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FetchHTTPRemoteRequest.Unmarshal(m, b)
+}
+func (m *FetchHTTPRemoteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FetchHTTPRemoteRequest.Marshal(b, m, deterministic)
+}
+func (dst *FetchHTTPRemoteRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FetchHTTPRemoteRequest.Merge(dst, src)
+}
+func (m *FetchHTTPRemoteRequest) XXX_Size() int {
+	return xxx_messageInfo_FetchHTTPRemoteRequest.Size(m)
+}
+func (m *FetchHTTPRemoteRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_FetchHTTPRemoteRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FetchHTTPRemoteRequest proto.InternalMessageInfo
+
+func (m *FetchHTTPRemoteRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *FetchHTTPRemoteRequest) GetRemote() *Remote {
+	if m != nil {
+		return m.Remote
+	}
+	return nil
+}
+
+func (m *FetchHTTPRemoteRequest) GetTimeout() int32 {
+	if m != nil {
+		return m.Timeout
+	}
+	return 0
+}
+
+type FetchHTTPRemoteResponse struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *FetchHTTPRemoteResponse) Reset()         { *m = FetchHTTPRemoteResponse{} }
+func (m *FetchHTTPRemoteResponse) String() string { return proto.CompactTextString(m) }
+func (*FetchHTTPRemoteResponse) ProtoMessage()    {}
+func (*FetchHTTPRemoteResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{72}
+}
+func (m *FetchHTTPRemoteResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FetchHTTPRemoteResponse.Unmarshal(m, b)
+}
+func (m *FetchHTTPRemoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FetchHTTPRemoteResponse.Marshal(b, m, deterministic)
+}
+func (dst *FetchHTTPRemoteResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FetchHTTPRemoteResponse.Merge(dst, src)
+}
+func (m *FetchHTTPRemoteResponse) XXX_Size() int {
+	return xxx_messageInfo_FetchHTTPRemoteResponse.Size(m)
+}
+func (m *FetchHTTPRemoteResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_FetchHTTPRemoteResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FetchHTTPRemoteResponse proto.InternalMessageInfo
+
+type GeoFastInitialFetchRequest struct {
+	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	ObjectPool           *ObjectPool `protobuf:"bytes,2,opt,name=object_pool,json=objectPool,proto3" json:"object_pool,omitempty"`
+	Remote               *Remote     `protobuf:"bytes,3,opt,name=remote,proto3" json:"remote,omitempty"`
+	Timeout              int32       `protobuf:"varint,4,opt,name=timeout,proto3" json:"timeout,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *GeoFastInitialFetchRequest) Reset()         { *m = GeoFastInitialFetchRequest{} }
+func (m *GeoFastInitialFetchRequest) String() string { return proto.CompactTextString(m) }
+func (*GeoFastInitialFetchRequest) ProtoMessage()    {}
+func (*GeoFastInitialFetchRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{73}
+}
+func (m *GeoFastInitialFetchRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GeoFastInitialFetchRequest.Unmarshal(m, b)
+}
+func (m *GeoFastInitialFetchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GeoFastInitialFetchRequest.Marshal(b, m, deterministic)
+}
+func (dst *GeoFastInitialFetchRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GeoFastInitialFetchRequest.Merge(dst, src)
+}
+func (m *GeoFastInitialFetchRequest) XXX_Size() int {
+	return xxx_messageInfo_GeoFastInitialFetchRequest.Size(m)
+}
+func (m *GeoFastInitialFetchRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_GeoFastInitialFetchRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GeoFastInitialFetchRequest proto.InternalMessageInfo
+
+func (m *GeoFastInitialFetchRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *GeoFastInitialFetchRequest) GetObjectPool() *ObjectPool {
+	if m != nil {
+		return m.ObjectPool
+	}
+	return nil
+}
+
+func (m *GeoFastInitialFetchRequest) GetRemote() *Remote {
+	if m != nil {
+		return m.Remote
+	}
+	return nil
+}
+
+func (m *GeoFastInitialFetchRequest) GetTimeout() int32 {
+	if m != nil {
+		return m.Timeout
+	}
+	return 0
+}
+
+type GeoFastInitialFetchResponse struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GeoFastInitialFetchResponse) Reset()         { *m = GeoFastInitialFetchResponse{} }
+func (m *GeoFastInitialFetchResponse) String() string { return proto.CompactTextString(m) }
+func (*GeoFastInitialFetchResponse) ProtoMessage()    {}
+func (*GeoFastInitialFetchResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_repository_service_9b779855a9618c84, []int{74}
+}
+func (m *GeoFastInitialFetchResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GeoFastInitialFetchResponse.Unmarshal(m, b)
+}
+func (m *GeoFastInitialFetchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GeoFastInitialFetchResponse.Marshal(b, m, deterministic)
+}
+func (dst *GeoFastInitialFetchResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GeoFastInitialFetchResponse.Merge(dst, src)
+}
+func (m *GeoFastInitialFetchResponse) XXX_Size() int {
+	return xxx_messageInfo_GeoFastInitialFetchResponse.Size(m)
+}
+func (m *GeoFastInitialFetchResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_GeoFastInitialFetchResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GeoFastInitialFetchResponse proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*RepositoryExistsRequest)(nil), "gitaly.RepositoryExistsRequest")
 	proto.RegisterType((*RepositoryExistsResponse)(nil), "gitaly.RepositoryExistsResponse")
@@ -3314,6 +3544,11 @@ func init() {
 	proto.RegisterType((*SearchFilesByContentResponse)(nil), "gitaly.SearchFilesByContentResponse")
 	proto.RegisterType((*PreFetchRequest)(nil), "gitaly.PreFetchRequest")
 	proto.RegisterType((*PreFetchResponse)(nil), "gitaly.PreFetchResponse")
+	proto.RegisterType((*Remote)(nil), "gitaly.Remote")
+	proto.RegisterType((*FetchHTTPRemoteRequest)(nil), "gitaly.FetchHTTPRemoteRequest")
+	proto.RegisterType((*FetchHTTPRemoteResponse)(nil), "gitaly.FetchHTTPRemoteResponse")
+	proto.RegisterType((*GeoFastInitialFetchRequest)(nil), "gitaly.GeoFastInitialFetchRequest")
+	proto.RegisterType((*GeoFastInitialFetchResponse)(nil), "gitaly.GeoFastInitialFetchResponse")
 	proto.RegisterEnum("gitaly.GetArchiveRequest_Format", GetArchiveRequest_Format_name, GetArchiveRequest_Format_value)
 	proto.RegisterEnum("gitaly.GetRawChangesResponse_RawChange_Operation", GetRawChangesResponse_RawChange_Operation_name, GetRawChangesResponse_RawChange_Operation_value)
 }
@@ -3364,7 +3599,8 @@ type RepositoryServiceClient interface {
 	SearchFilesByName(ctx context.Context, in *SearchFilesByNameRequest, opts ...grpc.CallOption) (RepositoryService_SearchFilesByNameClient, error)
 	RestoreCustomHooks(ctx context.Context, opts ...grpc.CallOption) (RepositoryService_RestoreCustomHooksClient, error)
 	BackupCustomHooks(ctx context.Context, in *BackupCustomHooksRequest, opts ...grpc.CallOption) (RepositoryService_BackupCustomHooksClient, error)
-	PreFetch(ctx context.Context, in *PreFetchRequest, opts ...grpc.CallOption) (*PreFetchResponse, error)
+	FetchHTTPRemote(ctx context.Context, in *FetchHTTPRemoteRequest, opts ...grpc.CallOption) (*FetchHTTPRemoteResponse, error)
+	GeoFastInitialFetch(ctx context.Context, in *GeoFastInitialFetchRequest, opts ...grpc.CallOption) (*GeoFastInitialFetchResponse, error)
 }
 
 type repositoryServiceClient struct {
@@ -3915,9 +4151,18 @@ func (x *repositoryServiceBackupCustomHooksClient) Recv() (*BackupCustomHooksRes
 	return m, nil
 }
 
-func (c *repositoryServiceClient) PreFetch(ctx context.Context, in *PreFetchRequest, opts ...grpc.CallOption) (*PreFetchResponse, error) {
-	out := new(PreFetchResponse)
-	err := c.cc.Invoke(ctx, "/gitaly.RepositoryService/PreFetch", in, out, opts...)
+func (c *repositoryServiceClient) FetchHTTPRemote(ctx context.Context, in *FetchHTTPRemoteRequest, opts ...grpc.CallOption) (*FetchHTTPRemoteResponse, error) {
+	out := new(FetchHTTPRemoteResponse)
+	err := c.cc.Invoke(ctx, "/gitaly.RepositoryService/FetchHTTPRemote", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *repositoryServiceClient) GeoFastInitialFetch(ctx context.Context, in *GeoFastInitialFetchRequest, opts ...grpc.CallOption) (*GeoFastInitialFetchResponse, error) {
+	out := new(GeoFastInitialFetchResponse)
+	err := c.cc.Invoke(ctx, "/gitaly.RepositoryService/GeoFastInitialFetch", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -3960,7 +4205,8 @@ type RepositoryServiceServer interface {
 	SearchFilesByName(*SearchFilesByNameRequest, RepositoryService_SearchFilesByNameServer) error
 	RestoreCustomHooks(RepositoryService_RestoreCustomHooksServer) error
 	BackupCustomHooks(*BackupCustomHooksRequest, RepositoryService_BackupCustomHooksServer) error
-	PreFetch(context.Context, *PreFetchRequest) (*PreFetchResponse, error)
+	FetchHTTPRemote(context.Context, *FetchHTTPRemoteRequest) (*FetchHTTPRemoteResponse, error)
+	GeoFastInitialFetch(context.Context, *GeoFastInitialFetchRequest) (*GeoFastInitialFetchResponse, error)
 }
 
 func RegisterRepositoryServiceServer(s *grpc.Server, srv RepositoryServiceServer) {
@@ -4619,20 +4865,38 @@ func (x *repositoryServiceBackupCustomHooksServer) Send(m *BackupCustomHooksResp
 	return x.ServerStream.SendMsg(m)
 }
 
-func _RepositoryService_PreFetch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(PreFetchRequest)
+func _RepositoryService_FetchHTTPRemote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(FetchHTTPRemoteRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(RepositoryServiceServer).PreFetch(ctx, in)
+		return srv.(RepositoryServiceServer).FetchHTTPRemote(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/gitaly.RepositoryService/PreFetch",
+		FullMethod: "/gitaly.RepositoryService/FetchHTTPRemote",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(RepositoryServiceServer).PreFetch(ctx, req.(*PreFetchRequest))
+		return srv.(RepositoryServiceServer).FetchHTTPRemote(ctx, req.(*FetchHTTPRemoteRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _RepositoryService_GeoFastInitialFetch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GeoFastInitialFetchRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RepositoryServiceServer).GeoFastInitialFetch(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.RepositoryService/GeoFastInitialFetch",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RepositoryServiceServer).GeoFastInitialFetch(ctx, req.(*GeoFastInitialFetchRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -4738,8 +5002,12 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 			Handler:    _RepositoryService_CreateRepositoryFromSnapshot_Handler,
 		},
 		{
-			MethodName: "PreFetch",
-			Handler:    _RepositoryService_PreFetch_Handler,
+			MethodName: "FetchHTTPRemote",
+			Handler:    _RepositoryService_FetchHTTPRemote_Handler,
+		},
+		{
+			MethodName: "GeoFastInitialFetch",
+			Handler:    _RepositoryService_GeoFastInitialFetch_Handler,
 		},
 	},
 	Streams: []grpc.StreamDesc{
@@ -4798,166 +5066,180 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 }
 
 func init() {
-	proto.RegisterFile("repository-service.proto", fileDescriptor_repository_service_e78248130d6ea2d6)
-}
-
-var fileDescriptor_repository_service_e78248130d6ea2d6 = []byte{
-	// 2500 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xef, 0x72, 0xdb, 0xb8,
-	0x11, 0x97, 0x2c, 0xcb, 0x92, 0x56, 0x4a, 0x22, 0xc3, 0x4e, 0x2c, 0x33, 0x4e, 0xec, 0x30, 0x99,
-	0xbb, 0xe4, 0x92, 0xba, 0x77, 0xf6, 0x87, 0xde, 0x4c, 0xdb, 0xc9, 0xd8, 0x92, 0x6c, 0x2b, 0x89,
-	0xff, 0x94, 0x4e, 0x26, 0xd3, 0xcc, 0x65, 0x38, 0x34, 0x05, 0x59, 0xac, 0x28, 0x42, 0x21, 0xa1,
-	0xf8, 0x7c, 0xfd, 0xda, 0x9b, 0xb9, 0x8f, 0xed, 0x3b, 0xf4, 0x05, 0xda, 0xa7, 0xe8, 0xf7, 0x3e,
-	0x45, 0xa7, 0x2f, 0xd1, 0x01, 0x40, 0x12, 0xa4, 0x48, 0xaa, 0xe9, 0x30, 0x6d, 0xbf, 0x11, 0xbb,
-	0xc0, 0xee, 0x62, 0x77, 0xb1, 0xc0, 0xfe, 0x24, 0x68, 0xb9, 0x78, 0x42, 0x3c, 0x8b, 0x12, 0xf7,
-	0xfa, 0x67, 0x1e, 0x76, 0x3f, 0x5a, 0x26, 0xde, 0x9e, 0xb8, 0x84, 0x12, 0xb4, 0x74, 0x69, 0x51,
-	0xc3, 0xbe, 0x56, 0x1a, 0xde, 0xd0, 0x70, 0x71, 0x5f, 0x50, 0xd5, 0x63, 0x58, 0xd3, 0xc2, 0x15,
-	0xdd, 0xef, 0x2d, 0x8f, 0x7a, 0x1a, 0xfe, 0x30, 0xc5, 0x1e, 0x45, 0x3b, 0x00, 0x52, 0x58, 0xab,
-	0xb8, 0x55, 0x7c, 0x5c, 0xdf, 0x41, 0xdb, 0x42, 0xca, 0xb6, 0x5c, 0xa4, 0x45, 0x66, 0xa9, 0x3b,
-	0xd0, 0x4a, 0x8a, 0xf3, 0x26, 0xc4, 0xf1, 0x30, 0xba, 0x03, 0x4b, 0x98, 0x53, 0xb8, 0xac, 0xaa,
-	0xe6, 0x8f, 0xd4, 0x13, 0xbe, 0xc6, 0x30, 0x47, 0x3d, 0xc7, 0x74, 0xf1, 0x18, 0x3b, 0xd4, 0xb0,
-	0xf3, 0xd8, 0x70, 0x17, 0xd6, 0x53, 0xe4, 0x09, 0x23, 0x54, 0x1b, 0x96, 0x05, 0xf3, 0x60, 0x6a,
-	0xe7, 0xd1, 0x82, 0x1e, 0xc2, 0x0d, 0xd3, 0xc5, 0x06, 0xc5, 0xfa, 0x85, 0x45, 0xc7, 0xc6, 0xa4,
-	0xb5, 0xc0, 0x37, 0xd5, 0x10, 0xc4, 0x7d, 0x4e, 0x53, 0x57, 0x01, 0x45, 0xb5, 0xf9, 0x36, 0x4c,
-	0xe0, 0xf6, 0xa1, 0xe1, 0x5e, 0x18, 0x97, 0xb8, 0x4d, 0x6c, 0x1b, 0x9b, 0xf4, 0xbf, 0x6e, 0x47,
-	0x0b, 0xee, 0xcc, 0x6a, 0xf4, 0x6d, 0xe9, 0xc0, 0xcd, 0xb6, 0x8d, 0x0d, 0x67, 0x3a, 0xc9, 0xe3,
-	0xf2, 0x65, 0xb8, 0x15, 0x4a, 0xf1, 0x05, 0xbf, 0x84, 0xdb, 0x72, 0xf2, 0xb9, 0xf5, 0x03, 0xce,
-	0x23, 0xff, 0x19, 0xdc, 0x99, 0x15, 0xe6, 0x27, 0x15, 0x82, 0x45, 0xcf, 0xfa, 0x01, 0x73, 0x39,
-	0x25, 0x8d, 0x7f, 0xab, 0x23, 0x58, 0xdf, 0x9b, 0x4c, 0xec, 0xeb, 0x43, 0x8b, 0x1a, 0x94, 0xba,
-	0xd6, 0xc5, 0x94, 0xe2, 0x3c, 0x59, 0x8d, 0x14, 0xa8, 0xba, 0xf8, 0xa3, 0xe5, 0x59, 0xc4, 0xe1,
-	0xee, 0x6d, 0x68, 0xe1, 0x58, 0xdd, 0x00, 0x25, 0x4d, 0x99, 0xef, 0x85, 0x3f, 0x2c, 0x00, 0x3a,
-	0xc0, 0xd4, 0x1c, 0x6a, 0x78, 0x4c, 0x68, 0x1e, 0x1f, 0xb0, 0xe3, 0xe3, 0x72, 0x21, 0xdc, 0x84,
-	0x9a, 0xe6, 0x8f, 0xd0, 0x2a, 0x94, 0x07, 0xc4, 0x35, 0x71, 0xab, 0xc4, 0x03, 0x2f, 0x06, 0x68,
-	0x0d, 0x2a, 0x0e, 0xd1, 0xa9, 0x71, 0xe9, 0xb5, 0x16, 0xc5, 0x69, 0x73, 0xc8, 0x6b, 0xe3, 0xd2,
-	0x43, 0x2d, 0xa8, 0x50, 0x6b, 0x8c, 0xc9, 0x94, 0xb6, 0xca, 0x5b, 0xc5, 0xc7, 0x65, 0x2d, 0x18,
-	0xb2, 0x25, 0x9e, 0x37, 0xd4, 0x47, 0xf8, 0xba, 0xb5, 0x24, 0x34, 0x78, 0xde, 0xf0, 0x25, 0xbe,
-	0x46, 0x9b, 0x50, 0x1f, 0x39, 0xe4, 0xca, 0xd1, 0x87, 0x84, 0x9d, 0xde, 0x0a, 0x67, 0x02, 0x27,
-	0x1d, 0x31, 0x0a, 0x5a, 0x87, 0xaa, 0x43, 0xf4, 0x89, 0x3b, 0x75, 0x70, 0xab, 0xc6, 0xb5, 0x55,
-	0x1c, 0x72, 0xc6, 0x86, 0x2f, 0x16, 0xab, 0xd5, 0x66, 0x4d, 0xbd, 0x0d, 0x2b, 0x31, 0x2f, 0xf8,
-	0xde, 0x39, 0x86, 0xb5, 0x36, 0x4f, 0xd3, 0xc8, 0x96, 0x73, 0x64, 0x89, 0x02, 0xad, 0xa4, 0x38,
-	0x5f, 0xd5, 0x3f, 0x8b, 0xb0, 0x7c, 0x88, 0xe9, 0x9e, 0x6b, 0x0e, 0xad, 0x8f, 0xb9, 0xe2, 0x70,
-	0x17, 0x6a, 0x26, 0x19, 0x8f, 0x2d, 0xaa, 0x5b, 0x7d, 0x3f, 0x14, 0x55, 0x41, 0xe8, 0xf5, 0x59,
-	0x90, 0x26, 0x2e, 0x1e, 0x58, 0xdf, 0xf3, 0x68, 0xd4, 0x34, 0x7f, 0x84, 0xbe, 0x85, 0xa5, 0x01,
-	0x71, 0xc7, 0x06, 0xe5, 0xd1, 0xb8, 0xb9, 0xb3, 0x15, 0x28, 0x49, 0xd8, 0xb4, 0x7d, 0xc0, 0xe7,
-	0x69, 0xfe, 0x7c, 0x75, 0x17, 0x96, 0x04, 0x05, 0x55, 0xa0, 0xf4, 0xae, 0x77, 0xd6, 0x2c, 0xb0,
-	0x8f, 0xd7, 0x7b, 0x5a, 0xb3, 0x88, 0x00, 0x96, 0x5e, 0xef, 0x69, 0xfa, 0xe1, 0xbb, 0xe6, 0x02,
-	0xaa, 0x43, 0x85, 0x7d, 0xef, 0xbf, 0xdb, 0x69, 0x96, 0xd4, 0xc7, 0x80, 0xa2, 0x82, 0xe5, 0x59,
-	0xe9, 0x1b, 0xd4, 0xe0, 0xfb, 0x6c, 0x68, 0xfc, 0x9b, 0x85, 0xe0, 0xc8, 0xf0, 0x5e, 0x11, 0xd3,
-	0xb0, 0xf7, 0x5d, 0xc3, 0x31, 0x87, 0xb9, 0x4e, 0x8a, 0xfa, 0x35, 0xb4, 0x92, 0xe2, 0x7c, 0xf5,
-	0xab, 0x50, 0xfe, 0x68, 0xd8, 0x53, 0xec, 0x97, 0x7f, 0x31, 0x50, 0xff, 0x5e, 0x84, 0x16, 0xcf,
-	0x8d, 0x73, 0x32, 0x75, 0x4d, 0x2c, 0x56, 0xe5, 0x89, 0xcf, 0x73, 0x58, 0xf6, 0xb8, 0x28, 0x3d,
-	0xb2, 0x74, 0x21, 0x73, 0x69, 0x53, 0x4c, 0xd6, 0x62, 0x15, 0xd5, 0x17, 0x70, 0xc1, 0x8d, 0xe1,
-	0xa1, 0x6c, 0x68, 0x0d, 0x2f, 0x62, 0x20, 0xba, 0x07, 0x40, 0x0d, 0xf7, 0x12, 0x53, 0xdd, 0xc5,
-	0x03, 0x1e, 0xd4, 0x86, 0x56, 0x13, 0x14, 0x0d, 0x0f, 0xd4, 0x5d, 0x58, 0x4f, 0xd9, 0x94, 0xbc,
-	0x08, 0x5d, 0xec, 0x4d, 0x6d, 0x1a, 0x5c, 0x84, 0x62, 0xa4, 0xee, 0x41, 0xfd, 0xc0, 0x33, 0x47,
-	0x79, 0xfc, 0xff, 0x08, 0x1a, 0x42, 0x84, 0xf4, 0x39, 0x76, 0x5d, 0xe2, 0xfa, 0x31, 0x17, 0x03,
-	0xf5, 0xaf, 0x45, 0xb8, 0xf5, 0xd6, 0xb5, 0xd8, 0x41, 0x19, 0xe4, 0x71, 0x75, 0x13, 0x4a, 0x6c,
-	0xf7, 0xa2, 0x24, 0xb2, 0xcf, 0x58, 0xa5, 0x2c, 0xc5, 0x2b, 0x25, 0x7a, 0x00, 0x0d, 0x62, 0xf7,
-	0xf5, 0x90, 0x2f, 0x9c, 0x56, 0x27, 0x76, 0x5f, 0x0b, 0xa6, 0x84, 0xb5, 0xac, 0x1c, 0xa9, 0x65,
-	0x2f, 0x16, 0xab, 0x4b, 0xcd, 0x8a, 0xda, 0x82, 0xa6, 0xb4, 0x59, 0x6c, 0xef, 0xc5, 0x62, 0xb5,
-	0xd8, 0x5c, 0x50, 0x87, 0xb0, 0x7a, 0x60, 0x39, 0xfd, 0x63, 0xec, 0x5e, 0xe2, 0x7d, 0xc3, 0xcb,
-	0x75, 0xba, 0x37, 0xa0, 0x16, 0x18, 0xe8, 0xb5, 0x16, 0xb6, 0x4a, 0x2c, 0xac, 0x21, 0x41, 0x7d,
-	0x0a, 0xb7, 0x67, 0x34, 0xc9, 0xa3, 0x75, 0x61, 0x78, 0x22, 0xb5, 0x6b, 0x1a, 0xff, 0x56, 0x7f,
-	0x2a, 0xc2, 0xb2, 0xa8, 0x47, 0x07, 0xc4, 0x1d, 0xfd, 0x3f, 0x53, 0x9a, 0xbd, 0x43, 0xa2, 0x96,
-	0x84, 0x6f, 0xa1, 0xf5, 0x9e, 0xa7, 0x61, 0x66, 0x6c, 0xcf, 0x39, 0x73, 0xc9, 0xa5, 0x8b, 0x3d,
-	0x2f, 0x67, 0x69, 0x74, 0xb9, 0xb8, 0x48, 0x69, 0x14, 0x84, 0x5e, 0x5f, 0xfd, 0x35, 0x28, 0x69,
-	0xda, 0x7c, 0x07, 0x6e, 0x42, 0xdd, 0x72, 0xf4, 0x89, 0x4f, 0xf6, 0x0f, 0x06, 0x58, 0xe1, 0x44,
-	0x61, 0xec, 0xf9, 0x87, 0xa9, 0xe1, 0x0d, 0x3f, 0x9b, 0xb1, 0x1e, 0x17, 0x17, 0x31, 0x56, 0x10,
-	0x02, 0x63, 0x93, 0xda, 0x3e, 0xd5, 0xd8, 0x01, 0xdc, 0x9f, 0xbd, 0x89, 0x0e, 0x5c, 0x32, 0x7e,
-	0xa3, 0xbd, 0xca, 0x79, 0xdc, 0xa6, 0xae, 0xed, 0xdb, 0xca, 0x3e, 0xd5, 0x07, 0xb0, 0x99, 0xa9,
-	0xc7, 0x0f, 0x72, 0x0f, 0x56, 0xc4, 0x94, 0xfd, 0xa9, 0xd3, 0xb7, 0x73, 0xbd, 0xc2, 0xbe, 0x82,
-	0xd5, 0xb8, 0xa8, 0x39, 0xf7, 0x0a, 0x06, 0xc4, 0x4f, 0x6b, 0x9b, 0x38, 0x03, 0xeb, 0x32, 0x67,
-	0x9c, 0x06, 0x53, 0xdb, 0xd6, 0x27, 0x06, 0x1d, 0x06, 0x71, 0x62, 0x84, 0x33, 0x83, 0x0e, 0xd5,
-	0xa7, 0xb0, 0x12, 0x53, 0x33, 0xb7, 0xec, 0xfd, 0xb4, 0x00, 0xcd, 0x73, 0x4c, 0xf3, 0x9b, 0xf4,
-	0x2d, 0x54, 0xb0, 0x43, 0x5d, 0x0b, 0x8b, 0x12, 0x51, 0xdf, 0xb9, 0x1f, 0x2c, 0x98, 0x15, 0xbf,
-	0xdd, 0x75, 0xa8, 0x7b, 0xad, 0x05, 0xd3, 0x95, 0x1f, 0x8b, 0x50, 0xe6, 0x24, 0x16, 0x4c, 0xf6,
-	0xd2, 0x12, 0x05, 0x83, 0x7d, 0xa2, 0x7b, 0x50, 0xe3, 0x57, 0xa2, 0xee, 0x51, 0x57, 0x6c, 0xf4,
-	0xa8, 0xa0, 0x55, 0x39, 0xe9, 0x9c, 0xba, 0xe8, 0x01, 0xd4, 0x05, 0xdb, 0x72, 0xe8, 0xee, 0x0e,
-	0xaf, 0xae, 0xe5, 0xa3, 0x82, 0x06, 0x9c, 0xd8, 0x63, 0x34, 0xb4, 0x09, 0x62, 0xa4, 0x5f, 0x10,
-	0x62, 0x8b, 0x77, 0xdf, 0x51, 0x41, 0x13, 0x52, 0xf7, 0x09, 0xb1, 0xf7, 0x2b, 0xfe, 0x15, 0xac,
-	0xae, 0xc0, 0x72, 0xc4, 0x54, 0x3f, 0x55, 0xde, 0xc3, 0x4a, 0x07, 0xdb, 0xf8, 0x73, 0x04, 0x0d,
-	0xc1, 0xe2, 0x08, 0x5f, 0x0b, 0xf7, 0xd4, 0x34, 0xfe, 0xad, 0xde, 0x81, 0xd5, 0xb8, 0x78, 0x5f,
-	0xad, 0xc9, 0xfa, 0x35, 0x8f, 0x12, 0x17, 0xb7, 0xa7, 0x1e, 0x25, 0xe3, 0x23, 0x42, 0x46, 0x5e,
-	0x4e, 0xe5, 0x3c, 0x1f, 0x17, 0x22, 0xf9, 0xb8, 0x01, 0x4a, 0x9a, 0x12, 0xdf, 0x84, 0x13, 0x68,
-	0xed, 0x1b, 0xe6, 0x68, 0x3a, 0xf9, 0x3c, 0x16, 0xa8, 0x3f, 0x87, 0xf5, 0x14, 0x79, 0x73, 0x8e,
-	0xcb, 0x08, 0x1e, 0xa4, 0x1d, 0xe4, 0xdc, 0x67, 0x36, 0xd5, 0x17, 0x8f, 0x40, 0x9d, 0xa7, 0xcc,
-	0xf7, 0xc9, 0x11, 0x20, 0x76, 0xd7, 0xbd, 0xb2, 0x4c, 0xec, 0xe4, 0xba, 0x53, 0xd5, 0x36, 0xac,
-	0xc4, 0x24, 0xf9, 0x7e, 0x78, 0x06, 0xc8, 0x16, 0x24, 0xdd, 0x1b, 0x12, 0x97, 0xea, 0x8e, 0x31,
-	0x0e, 0x6e, 0xd0, 0xa6, 0xcf, 0x39, 0x67, 0x8c, 0x13, 0x63, 0xcc, 0x43, 0x74, 0x88, 0x69, 0xcf,
-	0x19, 0x90, 0xbd, 0xcf, 0xd1, 0xd3, 0xa9, 0xbf, 0x84, 0xf5, 0x14, 0x79, 0xbe, 0x69, 0xf7, 0x01,
-	0x64, 0x33, 0xe7, 0x07, 0x2a, 0x42, 0x61, 0xc6, 0xb4, 0x0d, 0xdb, 0x9c, 0xda, 0x06, 0xc5, 0xed,
-	0x21, 0x36, 0x47, 0xde, 0x74, 0x9c, 0xc7, 0x98, 0x5f, 0xc0, 0x7a, 0x8a, 0x3c, 0xdf, 0x18, 0x05,
-	0xaa, 0xa6, 0x4f, 0xf3, 0xbd, 0x13, 0x8e, 0x59, 0x90, 0x0e, 0x31, 0x3d, 0x77, 0x8c, 0x89, 0x37,
-	0x24, 0x79, 0x70, 0x04, 0xf5, 0x09, 0xac, 0xc4, 0x24, 0xcd, 0x49, 0xd6, 0x3f, 0x15, 0xe1, 0x61,
-	0x5a, 0x02, 0x7d, 0x06, 0x33, 0x58, 0x2b, 0x39, 0xa4, 0x74, 0xa2, 0xcb, 0x8b, 0xae, 0xc2, 0xc6,
-	0x6f, 0x5c, 0x9b, 0x5d, 0x04, 0x9c, 0x65, 0x4c, 0xe9, 0xd0, 0x6f, 0xaf, 0xf8, 0xdc, 0xbd, 0x29,
-	0x1d, 0xaa, 0x5f, 0xc0, 0xa3, 0xf9, 0x26, 0xf9, 0x59, 0xfd, 0xc7, 0x22, 0xac, 0x1e, 0x62, 0xaa,
-	0x19, 0x57, 0xed, 0xa1, 0xe1, 0x5c, 0xe6, 0xc3, 0x05, 0x1e, 0xc2, 0x8d, 0x81, 0x4b, 0xc6, 0x7a,
-	0x0c, 0x1c, 0xa8, 0x69, 0x0d, 0x46, 0x0c, 0xdf, 0xb4, 0x9b, 0x50, 0xa7, 0x44, 0x8f, 0xbd, 0x8a,
-	0x6b, 0x1a, 0x50, 0x12, 0x4c, 0x50, 0xff, 0x51, 0x82, 0xdb, 0x33, 0x26, 0xf9, 0xce, 0x3f, 0x82,
-	0xba, 0x6b, 0x5c, 0xe9, 0xa6, 0x20, 0xb7, 0x8a, 0xfc, 0xae, 0xf9, 0x32, 0xd2, 0x3a, 0x26, 0xd7,
-	0x6c, 0x87, 0x24, 0x0d, 0xdc, 0x90, 0xab, 0xfc, 0x58, 0x82, 0x5a, 0xc8, 0x61, 0x9d, 0xfe, 0x85,
-	0x4d, 0x2e, 0xd8, 0xc3, 0x47, 0x24, 0xd4, 0x12, 0x1b, 0xf6, 0xfa, 0x21, 0x9a, 0xb2, 0x20, 0xd1,
-	0x14, 0xde, 0xdc, 0xe3, 0x2b, 0x71, 0xfd, 0x0a, 0xe3, 0x2b, 0x0e, 0xbe, 0x62, 0xb7, 0x2f, 0x63,
-	0xb1, 0x17, 0x3d, 0x67, 0x2d, 0x0a, 0x16, 0xb1, 0xfb, 0x9c, 0x75, 0x0a, 0x35, 0x32, 0xc1, 0xae,
-	0x41, 0xd9, 0x9e, 0xcb, 0xbc, 0xe7, 0xfd, 0xe6, 0x13, 0x0d, 0xdf, 0x3e, 0x0d, 0x16, 0x6a, 0x52,
-	0x06, 0xf3, 0x35, 0xf3, 0x85, 0x14, 0x2a, 0x30, 0x8a, 0x86, 0x6b, 0x5c, 0x85, 0xf3, 0x03, 0x83,
-	0xc6, 0xa4, 0x8f, 0x39, 0x4c, 0x51, 0xe6, 0x06, 0x1d, 0x93, 0x7e, 0xb8, 0x0d, 0xce, 0xaa, 0x0a,
-	0x96, 0x83, 0xaf, 0x18, 0x4b, 0xb5, 0xa0, 0x26, 0x45, 0xd4, 0xa1, 0xf2, 0xe6, 0xe4, 0xe5, 0xc9,
-	0xe9, 0xdb, 0x93, 0x66, 0x01, 0xd5, 0xa0, 0xbc, 0xd7, 0xe9, 0x74, 0x3b, 0xa2, 0xd7, 0x6e, 0x9f,
-	0x9e, 0xf5, 0xba, 0x1d, 0xd1, 0x6b, 0x77, 0xba, 0xaf, 0xba, 0xaf, 0xbb, 0x9d, 0x66, 0x09, 0x35,
-	0xa0, 0x7a, 0x7c, 0xda, 0xe9, 0x1d, 0x30, 0xd6, 0x22, 0x63, 0x69, 0xdd, 0x93, 0xbd, 0xe3, 0x6e,
-	0xa7, 0x59, 0x46, 0x4d, 0x68, 0xbc, 0xfe, 0xed, 0x59, 0x57, 0x6f, 0x1f, 0xed, 0x9d, 0x1c, 0x76,
-	0x3b, 0xcd, 0x25, 0xf5, 0x23, 0xb4, 0xce, 0xb1, 0xe1, 0x9a, 0xc3, 0x03, 0xcb, 0xc6, 0xde, 0xfe,
-	0x35, 0x2b, 0x6d, 0x79, 0x32, 0x70, 0x15, 0xca, 0x1f, 0xa6, 0xd8, 0xef, 0x06, 0x6a, 0x9a, 0x18,
-	0x04, 0x7d, 0x59, 0x29, 0xec, 0xcb, 0xd4, 0x6f, 0x60, 0x3d, 0x45, 0xaf, 0x7c, 0x2d, 0x0d, 0x18,
-	0x99, 0x27, 0x58, 0x43, 0x13, 0x03, 0xf5, 0xcf, 0x45, 0xb8, 0x1b, 0x5b, 0xd3, 0x26, 0x0e, 0xc5,
-	0x0e, 0xfd, 0x1f, 0x98, 0x8b, 0x9e, 0x40, 0xd3, 0x1c, 0x4e, 0x9d, 0x11, 0x66, 0xed, 0xa2, 0xb0,
-	0xd2, 0x87, 0xb1, 0x6e, 0xf9, 0xf4, 0xf0, 0x40, 0x5f, 0xc3, 0x46, 0xba, 0x95, 0xfe, 0xe6, 0x5a,
-	0x50, 0x19, 0x1b, 0xd4, 0x1c, 0x86, 0xdb, 0x0b, 0x86, 0xac, 0x85, 0xe7, 0x9f, 0x7a, 0xe4, 0x82,
-	0xac, 0x71, 0x4a, 0xc7, 0xa0, 0x06, 0xda, 0x82, 0x06, 0x76, 0xfa, 0x3a, 0x19, 0xe8, 0x9c, 0xe6,
-	0xc3, 0x6b, 0x80, 0x9d, 0xfe, 0xe9, 0xe0, 0x98, 0x51, 0xd4, 0xbf, 0x15, 0xe1, 0xd6, 0x99, 0x8b,
-	0x7d, 0x64, 0x4b, 0x78, 0x25, 0xb5, 0x55, 0x2b, 0xfe, 0x07, 0xe8, 0xc3, 0x73, 0x58, 0x0e, 0x81,
-	0x85, 0x4f, 0xe9, 0xf5, 0x02, 0xcc, 0x21, 0x14, 0xb0, 0x0b, 0x75, 0x72, 0xf1, 0x3b, 0x6c, 0x52,
-	0x7d, 0xc2, 0x5e, 0x81, 0xa5, 0xf8, 0xd2, 0x53, 0xce, 0x3a, 0x23, 0xc4, 0xd6, 0x80, 0x84, 0xdf,
-	0x2a, 0x82, 0xa6, 0xdc, 0x89, 0xf0, 0xdc, 0xce, 0x5f, 0xd6, 0x38, 0x56, 0x1e, 0xa0, 0xae, 0xe2,
-	0xc7, 0x04, 0xf4, 0x16, 0x9a, 0xb3, 0x08, 0x3f, 0xda, 0x4c, 0x1a, 0x16, 0xfb, 0x29, 0x41, 0xd9,
-	0xca, 0x9e, 0xe0, 0x87, 0xb1, 0x80, 0xde, 0x05, 0xc8, 0x7c, 0x04, 0xb6, 0x47, 0xd1, 0x85, 0xa9,
-	0xbf, 0x10, 0x28, 0x0f, 0xe6, 0xcc, 0x08, 0x65, 0x77, 0x01, 0x24, 0x0e, 0x8f, 0xd6, 0xe3, 0x4b,
-	0x22, 0xbf, 0x04, 0x28, 0x4a, 0x1a, 0x2b, 0x14, 0xf3, 0x1b, 0xb8, 0x19, 0x87, 0xd1, 0xd1, 0xbd,
-	0xb0, 0xa6, 0xa5, 0x01, 0xfa, 0xca, 0xfd, 0x2c, 0x76, 0x54, 0x64, 0x1c, 0xd9, 0x96, 0x22, 0x53,
-	0xe1, 0x73, 0x29, 0x32, 0x1d, 0x10, 0x57, 0x0b, 0xe8, 0x3d, 0xa0, 0x24, 0x22, 0x8d, 0x42, 0x3f,
-	0x65, 0x42, 0xe3, 0x8a, 0x3a, 0x6f, 0x4a, 0x28, 0xfe, 0x08, 0xea, 0x11, 0x2c, 0x17, 0x85, 0x1e,
-	0x4b, 0xc2, 0xdc, 0xca, 0xdd, 0x54, 0x5e, 0x28, 0xe9, 0x2d, 0x34, 0x67, 0xef, 0x6c, 0x99, 0x4a,
-	0x19, 0xc0, 0xb0, 0x4c, 0xa5, 0x4c, 0xa8, 0xb7, 0x80, 0x0e, 0x01, 0x24, 0xfc, 0x29, 0xc3, 0x9d,
-	0xc0, 0x5a, 0x65, 0xb8, 0x93, 0x68, 0xa9, 0x5a, 0xf8, 0xba, 0xc8, 0x2c, 0x9c, 0x85, 0x33, 0xa5,
-	0x85, 0x19, 0xb8, 0xa9, 0xb4, 0x30, 0x0b, 0x09, 0x15, 0xc9, 0x9e, 0xc0, 0x07, 0x65, 0xb2, 0x67,
-	0xe1, 0xa1, 0x32, 0xd9, 0x33, 0xc1, 0x45, 0xb5, 0x80, 0x76, 0x61, 0xf1, 0xc0, 0x33, 0x47, 0x68,
-	0x25, 0x9c, 0x2c, 0x41, 0x45, 0x65, 0x35, 0x4e, 0x0c, 0x17, 0x3d, 0x87, 0x6a, 0x80, 0xae, 0xa1,
-	0xb5, 0x60, 0xce, 0x0c, 0x46, 0xa8, 0xb4, 0x92, 0x8c, 0x50, 0xc0, 0x09, 0xdc, 0x88, 0x41, 0x63,
-	0x68, 0x23, 0xd4, 0x94, 0x82, 0xcd, 0x29, 0xf7, 0x32, 0xb8, 0xd1, 0x23, 0x2b, 0x21, 0x2b, 0x19,
-	0xc3, 0x04, 0xa0, 0x26, 0x63, 0x98, 0x82, 0x70, 0xf1, 0xc3, 0x90, 0x44, 0x9d, 0xe4, 0x61, 0xc8,
-	0xc4, 0xbf, 0xe4, 0x61, 0xc8, 0x06, 0xad, 0x02, 0xf1, 0xb3, 0x38, 0x51, 0x54, 0x7c, 0x06, 0x62,
-	0x15, 0x15, 0x9f, 0x05, 0x33, 0xa9, 0x05, 0x64, 0x27, 0x7f, 0x20, 0xf1, 0xf1, 0x1d, 0xf4, 0x45,
-	0xd6, 0x39, 0x88, 0x03, 0x4d, 0xca, 0x97, 0xff, 0x76, 0x5e, 0xa8, 0xed, 0x18, 0x1a, 0x51, 0x7c,
-	0x07, 0xdd, 0x8d, 0x2f, 0x8d, 0x35, 0xa3, 0xca, 0x46, 0x3a, 0x33, 0x72, 0x78, 0xae, 0x40, 0xc9,
-	0x6e, 0x33, 0xd1, 0x93, 0x79, 0x76, 0xc5, 0x55, 0x7d, 0xf5, 0x29, 0x53, 0x03, 0xc5, 0x8f, 0x8b,
-	0xac, 0x42, 0x45, 0x40, 0x21, 0x59, 0xa1, 0x92, 0x80, 0x94, 0xac, 0x50, 0x29, 0x28, 0x92, 0x5a,
-	0x40, 0xfb, 0x50, 0x0b, 0x61, 0x12, 0xd4, 0xca, 0x02, 0x79, 0x94, 0xf5, 0x14, 0x4e, 0x28, 0xe3,
-	0x25, 0x34, 0xa2, 0xb0, 0x87, 0xf4, 0x6a, 0x0a, 0xd6, 0x22, 0xbd, 0x9a, 0x8a, 0x94, 0x88, 0xe2,
-	0x2b, 0x5b, 0xe9, 0x48, 0xf1, 0x4d, 0x74, 0xea, 0x91, 0xe2, 0x9b, 0xec, 0xbd, 0xd5, 0x02, 0xfa,
-	0x8e, 0xff, 0x1e, 0x16, 0xef, 0x7f, 0x51, 0xf4, 0x67, 0xa9, 0xd4, 0x56, 0x5b, 0x56, 0xa0, 0xcc,
-	0xe6, 0x99, 0xc7, 0xfe, 0x1d, 0x2c, 0x27, 0x1a, 0x5a, 0x29, 0x3d, 0xab, 0x77, 0x96, 0xd2, 0x33,
-	0xbb, 0x61, 0xb5, 0x80, 0x7e, 0x05, 0x15, 0xff, 0xc7, 0x66, 0x74, 0x27, 0x9c, 0x1f, 0xfb, 0x0d,
-	0x5b, 0x59, 0x4b, 0xd0, 0xc3, 0xd5, 0x2f, 0xa0, 0x1e, 0xe9, 0x73, 0x51, 0xf4, 0x06, 0x98, 0xe9,
-	0x5f, 0xa5, 0x07, 0x53, 0x1a, 0x63, 0xbe, 0xcb, 0xdf, 0xc3, 0xc6, 0xbc, 0xa6, 0x13, 0x3d, 0x9d,
-	0x97, 0xb8, 0xb3, 0xda, 0x9e, 0x7d, 0xda, 0xe4, 0x70, 0x23, 0x67, 0x70, 0x23, 0xd6, 0x48, 0xc9,
-	0x82, 0x9b, 0xd6, 0xdf, 0xca, 0x82, 0x9b, 0xda, 0x7d, 0xf1, 0xed, 0x60, 0x58, 0x4d, 0x7b, 0x4a,
-	0xa3, 0x87, 0x32, 0xbd, 0x33, 0xdb, 0x01, 0xe5, 0xd1, 0xfc, 0x49, 0x11, 0x35, 0xdf, 0xc1, 0x72,
-	0xa2, 0x17, 0x91, 0xb9, 0x91, 0xd5, 0x1e, 0xc9, 0xdc, 0xc8, 0x6c, 0x64, 0xb8, 0xf4, 0xf7, 0x80,
-	0x92, 0x40, 0x1f, 0x8a, 0xbc, 0x12, 0x33, 0x90, 0x46, 0x59, 0x91, 0xb3, 0x71, 0xc2, 0xc7, 0xdc,
-	0xf8, 0x04, 0xb2, 0x27, 0x8d, 0xcf, 0x02, 0x11, 0xa5, 0xf1, 0x99, 0xb0, 0x20, 0x37, 0xfe, 0x39,
-	0x54, 0x83, 0x67, 0xb8, 0xbc, 0x85, 0x67, 0x5a, 0x0c, 0x79, 0x0b, 0xcf, 0xbe, 0xd8, 0xd5, 0xc2,
-	0xc5, 0x12, 0xff, 0x57, 0xcf, 0xee, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x6a, 0xfe, 0x83, 0x54,
-	0x07, 0x24, 0x00, 0x00,
+	proto.RegisterFile("repository-service.proto", fileDescriptor_repository_service_9b779855a9618c84)
+}
+
+var fileDescriptor_repository_service_9b779855a9618c84 = []byte{
+	// 2734 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xdd, 0x72, 0xdb, 0xc6,
+	0x15, 0xe6, 0x8f, 0x24, 0x92, 0x87, 0xb4, 0x4d, 0xad, 0x64, 0x8b, 0x84, 0x7f, 0x64, 0xc3, 0x9e,
+	0xc4, 0xf9, 0x93, 0x13, 0xf9, 0xa2, 0x99, 0xb4, 0x9d, 0x8c, 0xfe, 0xc5, 0xc4, 0x96, 0x14, 0x48,
+	0x8e, 0xa7, 0x9a, 0x74, 0x50, 0x08, 0x5c, 0x8a, 0x88, 0x40, 0x2c, 0x03, 0x2c, 0xad, 0x28, 0x9d,
+	0xe9, 0x5d, 0xee, 0x7a, 0x91, 0xab, 0xfe, 0xbc, 0x42, 0xa7, 0x4f, 0xd0, 0x97, 0x68, 0xef, 0xfb,
+	0x04, 0xbd, 0x6d, 0x5f, 0xa0, 0xb3, 0xbb, 0xc0, 0x2e, 0x40, 0x00, 0xac, 0x5a, 0x72, 0xd2, 0x3b,
+	0xec, 0x39, 0xbb, 0xe7, 0x9c, 0x3d, 0xe7, 0xec, 0xd9, 0xdd, 0x6f, 0x01, 0x2d, 0x1f, 0x0f, 0x49,
+	0xe0, 0x50, 0xe2, 0x5f, 0x7d, 0x10, 0x60, 0xff, 0x8d, 0x63, 0xe3, 0xb5, 0xa1, 0x4f, 0x28, 0x41,
+	0x0b, 0xe7, 0x0e, 0xb5, 0xdc, 0x2b, 0xad, 0x11, 0xf4, 0x2d, 0x1f, 0x77, 0x05, 0x55, 0x7f, 0x05,
+	0x2b, 0x86, 0x1c, 0xb1, 0xf3, 0xad, 0x13, 0xd0, 0xc0, 0xc0, 0xdf, 0x8c, 0x70, 0x40, 0xd1, 0x3a,
+	0x80, 0x12, 0xd6, 0x2a, 0x3e, 0x2c, 0x3e, 0xad, 0xaf, 0xa3, 0x35, 0x21, 0x65, 0x4d, 0x0d, 0x32,
+	0x62, 0xbd, 0x3e, 0x59, 0xf8, 0xe7, 0xef, 0x9f, 0x96, 0xaa, 0x25, 0x7d, 0x1d, 0x5a, 0x69, 0xb1,
+	0xc1, 0x90, 0x78, 0x01, 0x46, 0x77, 0x60, 0x01, 0x73, 0x0a, 0x97, 0x59, 0x35, 0xc2, 0x96, 0xfe,
+	0x25, 0x1f, 0x63, 0xd9, 0x17, 0x1d, 0xcf, 0xf6, 0xf1, 0x00, 0x7b, 0xd4, 0x72, 0xa7, 0xb7, 0xa5,
+	0xa8, 0xdf, 0x85, 0x76, 0x86, 0x5c, 0x61, 0x8c, 0x4e, 0x61, 0x51, 0x30, 0x77, 0x47, 0xee, 0x34,
+	0xda, 0xd0, 0x63, 0xb8, 0x61, 0xfb, 0xd8, 0xa2, 0xd8, 0x3c, 0x73, 0xe8, 0xc0, 0x1a, 0xb6, 0x4a,
+	0x7c, 0x72, 0x0d, 0x41, 0xdc, 0xe4, 0x34, 0x69, 0xd2, 0x32, 0xa0, 0xb8, 0xd6, 0xd0, 0x96, 0x6f,
+	0xe1, 0xf6, 0x9e, 0xe5, 0x9f, 0x59, 0xe7, 0x78, 0x8b, 0xb8, 0x2e, 0xb6, 0xe9, 0x8f, 0x66, 0x4f,
+	0x0b, 0xee, 0x8c, 0x6b, 0x0e, 0x6d, 0x7a, 0x01, 0x37, 0xb7, 0x5c, 0x6c, 0x79, 0xa3, 0xe1, 0x2c,
+	0x42, 0xb1, 0x08, 0xb7, 0xa4, 0xb4, 0x50, 0xc1, 0x31, 0xdc, 0x56, 0x83, 0x8e, 0x9d, 0xef, 0xf0,
+	0x2c, 0xd2, 0xef, 0x7d, 0xb8, 0x33, 0x2e, 0x34, 0x4c, 0x3e, 0x04, 0x73, 0x81, 0xf3, 0x1d, 0xe6,
+	0xf2, 0xca, 0x06, 0xff, 0xd6, 0x03, 0x68, 0x6f, 0x0c, 0x87, 0xee, 0xd5, 0x9e, 0x43, 0x2d, 0x4a,
+	0x7d, 0xe7, 0x6c, 0x44, 0xf1, 0x34, 0xab, 0x00, 0x69, 0x50, 0xf5, 0xf1, 0x1b, 0x27, 0x70, 0x88,
+	0xc7, 0xdd, 0xde, 0x30, 0x64, 0x5b, 0xba, 0xe2, 0x1e, 0x68, 0x59, 0x4a, 0x43, 0xaf, 0xfc, 0xb6,
+	0x04, 0x68, 0x17, 0x53, 0xbb, 0x6f, 0xe0, 0x01, 0xa1, 0xd3, 0xf8, 0x84, 0x2d, 0x37, 0x9f, 0x0b,
+	0xe1, 0xa6, 0xd4, 0x8c, 0xb0, 0x85, 0x96, 0x61, 0xbe, 0x47, 0x7c, 0x1b, 0xb7, 0xca, 0x3c, 0x31,
+	0x44, 0x03, 0xad, 0x40, 0xc5, 0x23, 0x26, 0xb5, 0xce, 0x83, 0xd6, 0x9c, 0x58, 0x9d, 0x1e, 0x39,
+	0xb1, 0xce, 0x03, 0xd4, 0x82, 0x0a, 0x75, 0x06, 0x98, 0x8c, 0x68, 0x6b, 0xfe, 0x61, 0xf1, 0xe9,
+	0xbc, 0x11, 0x35, 0xd9, 0x90, 0x20, 0xe8, 0x9b, 0x17, 0xf8, 0xaa, 0xb5, 0x20, 0x34, 0x04, 0x41,
+	0xff, 0x73, 0x7c, 0x85, 0x56, 0xa1, 0x7e, 0xe1, 0x91, 0x4b, 0xcf, 0xec, 0x13, 0xb6, 0xda, 0x2b,
+	0x9c, 0x09, 0x9c, 0xb4, 0xcf, 0x28, 0xa8, 0x0d, 0x55, 0x8f, 0x98, 0x43, 0x7f, 0xe4, 0xe1, 0x56,
+	0x8d, 0x6b, 0xab, 0x78, 0xe4, 0x88, 0x35, 0x23, 0x37, 0x7d, 0x36, 0x57, 0xad, 0x36, 0x6b, 0xfa,
+	0x6d, 0x58, 0x4a, 0x78, 0x23, 0xf4, 0xd2, 0x2b, 0x58, 0xd9, 0xe2, 0xe9, 0x1c, 0x9b, 0xfa, 0x0c,
+	0xb2, 0x54, 0x83, 0x56, 0x5a, 0x6c, 0xa8, 0xf2, 0x5f, 0x45, 0x58, 0xdc, 0xc3, 0x74, 0xc3, 0xb7,
+	0xfb, 0xce, 0x9b, 0xa9, 0xe2, 0x72, 0x17, 0x6a, 0x36, 0x19, 0x0c, 0x1c, 0x6a, 0x3a, 0xdd, 0x30,
+	0x34, 0x55, 0x41, 0xe8, 0x74, 0x59, 0xd0, 0x86, 0x3e, 0xee, 0x39, 0xdf, 0xf2, 0xe8, 0xd4, 0x8c,
+	0xb0, 0x85, 0x3e, 0x86, 0x85, 0x1e, 0xf1, 0x07, 0x16, 0xe5, 0xd1, 0xb9, 0xb9, 0xfe, 0x30, 0x52,
+	0x92, 0xb2, 0x69, 0x6d, 0x97, 0xf7, 0x33, 0xc2, 0xfe, 0xfa, 0x73, 0x58, 0x10, 0x14, 0x54, 0x81,
+	0xf2, 0x69, 0xe7, 0xa8, 0x59, 0x60, 0x1f, 0x27, 0x1b, 0x46, 0xb3, 0x88, 0x00, 0x16, 0x4e, 0x36,
+	0x0c, 0x73, 0xef, 0xb4, 0x59, 0x42, 0x75, 0xa8, 0xb0, 0xef, 0xcd, 0xd3, 0xf5, 0x66, 0x59, 0xae,
+	0xa7, 0xa7, 0x80, 0xe2, 0x0a, 0xd4, 0x5a, 0xea, 0x5a, 0xd4, 0xe2, 0xf3, 0x6d, 0x18, 0xfc, 0x9b,
+	0x85, 0x64, 0xdf, 0x0a, 0x5e, 0x10, 0xdb, 0x72, 0x37, 0x7d, 0xcb, 0xb3, 0xfb, 0x78, 0x26, 0xfb,
+	0xc9, 0x87, 0xd0, 0x4a, 0x8b, 0x0d, 0xcd, 0x58, 0x86, 0xf9, 0x37, 0x96, 0x3b, 0xc2, 0xe1, 0x76,
+	0x22, 0x1a, 0xfa, 0xdf, 0x8b, 0xd0, 0xe2, 0x39, 0x73, 0x4c, 0x46, 0xbe, 0x8d, 0xc5, 0xa8, 0x69,
+	0xe2, 0xf5, 0x29, 0x2c, 0x06, 0x5c, 0x94, 0x19, 0x1b, 0x5a, 0xca, 0x1d, 0xda, 0x14, 0x9d, 0x8d,
+	0x44, 0x45, 0x0e, 0x05, 0x9c, 0x71, 0x63, 0x78, 0x68, 0x1b, 0x46, 0x23, 0x88, 0x19, 0x88, 0xee,
+	0x03, 0x50, 0xcb, 0x3f, 0xc7, 0xd4, 0xf4, 0x71, 0x8f, 0x07, 0xb9, 0x61, 0xd4, 0x04, 0xc5, 0xc0,
+	0x3d, 0x99, 0xa2, 0xcf, 0xa1, 0x9d, 0x31, 0x39, 0xb5, 0xc1, 0xfa, 0x38, 0x18, 0xb9, 0x34, 0xda,
+	0x60, 0x45, 0x4b, 0xef, 0x40, 0x7d, 0x37, 0xb0, 0x2f, 0x66, 0xb1, 0x44, 0x9e, 0x40, 0x43, 0x88,
+	0x52, 0x31, 0xc0, 0xbe, 0x4f, 0xfc, 0x30, 0x17, 0x44, 0x43, 0xff, 0x4b, 0x11, 0x6e, 0xbd, 0xf6,
+	0x1d, 0xb6, 0x90, 0x7a, 0xd3, 0xb8, 0xbe, 0x09, 0x65, 0xe6, 0x0d, 0x51, 0x4a, 0xd9, 0x67, 0xa2,
+	0xc2, 0x96, 0x93, 0x15, 0x16, 0x3d, 0x82, 0x06, 0x71, 0xbb, 0xa6, 0xe4, 0x0b, 0x27, 0xd6, 0x89,
+	0xdb, 0x35, 0xa2, 0x2e, 0xb2, 0xf6, 0xcd, 0xc7, 0x6a, 0x5f, 0xac, 0xe6, 0x2c, 0x34, 0x2b, 0x7a,
+	0x0b, 0x9a, 0xca, 0x76, 0x31, 0xcd, 0xcf, 0xe6, 0xaa, 0xc5, 0x66, 0x49, 0x1f, 0xc2, 0xf2, 0xae,
+	0xe3, 0x75, 0x5f, 0x62, 0xff, 0x1c, 0x6f, 0x5a, 0xc1, 0x54, 0x55, 0xe0, 0x1e, 0xd4, 0x22, 0x43,
+	0x83, 0x56, 0xe9, 0x61, 0x99, 0x85, 0x5b, 0x12, 0x64, 0xfa, 0xbf, 0x07, 0xb7, 0xc7, 0x34, 0xaa,
+	0x25, 0x78, 0x66, 0x05, 0x22, 0xf5, 0x6b, 0x06, 0xff, 0xd6, 0x7f, 0x28, 0xc2, 0xa2, 0xa8, 0x5f,
+	0xbb, 0xc4, 0xbf, 0xf8, 0x7f, 0xa6, 0x7c, 0xfc, 0xbc, 0x13, 0xb7, 0x48, 0x9e, 0xbd, 0xda, 0x9d,
+	0xc0, 0xc0, 0xcc, 0xe8, 0x8e, 0x77, 0xe4, 0x93, 0x73, 0x1f, 0x07, 0xc1, 0x94, 0x25, 0xd5, 0xe7,
+	0xe2, 0x62, 0x25, 0x55, 0x10, 0x3a, 0x5d, 0xe9, 0xcb, 0x9f, 0x83, 0x96, 0xa5, 0x35, 0x74, 0xe8,
+	0x2a, 0xd4, 0x1d, 0xcf, 0x1c, 0x86, 0xe4, 0x70, 0x01, 0x81, 0x23, 0x3b, 0x0a, 0xa3, 0x8f, 0xbf,
+	0x19, 0x59, 0x41, 0x7f, 0x66, 0x46, 0x07, 0x5c, 0x5c, 0xcc, 0x68, 0x41, 0x18, 0x37, 0x3a, 0xad,
+	0xf5, 0xba, 0x46, 0x7b, 0xf0, 0x60, 0x7c, 0x47, 0xdb, 0xf5, 0xc9, 0xe0, 0x95, 0xf1, 0x62, 0xca,
+	0x65, 0x39, 0xf2, 0xdd, 0xd0, 0x66, 0xf6, 0x29, 0xe3, 0xfd, 0x08, 0x56, 0x73, 0xf5, 0x85, 0xc1,
+	0xff, 0x02, 0x96, 0x44, 0x97, 0xcd, 0x91, 0xd7, 0x75, 0x67, 0x72, 0xea, 0x7b, 0x17, 0x96, 0x93,
+	0x22, 0x27, 0xec, 0x53, 0x03, 0x40, 0x7c, 0x75, 0x6f, 0x11, 0xaf, 0xe7, 0x9c, 0x4f, 0x19, 0xbf,
+	0xde, 0xc8, 0x75, 0xcd, 0xa1, 0x45, 0xfb, 0x51, 0xfc, 0x18, 0xe1, 0xc8, 0xa2, 0x7d, 0xe9, 0x90,
+	0xf7, 0x60, 0x29, 0xa1, 0x6e, 0x62, 0xd9, 0xfc, 0xa1, 0x04, 0xcd, 0x63, 0x4c, 0xa7, 0x37, 0xed,
+	0x63, 0xa8, 0x60, 0x8f, 0xfa, 0x0e, 0x16, 0xa5, 0xa5, 0xbe, 0xfe, 0x20, 0x1a, 0x30, 0x2e, 0x7e,
+	0x6d, 0xc7, 0xa3, 0xfe, 0x95, 0x11, 0x75, 0xd7, 0xbe, 0x2f, 0xc2, 0x3c, 0x27, 0xb1, 0x20, 0xb3,
+	0x93, 0x9d, 0x28, 0x30, 0xec, 0x13, 0xdd, 0x87, 0x1a, 0xdf, 0x62, 0xcd, 0x80, 0xfa, 0x62, 0xc2,
+	0xfb, 0x05, 0xa3, 0xca, 0x49, 0xc7, 0xd4, 0x47, 0x8f, 0xa0, 0x2e, 0xd8, 0x8e, 0x47, 0x9f, 0xaf,
+	0xf3, 0xea, 0x3c, 0xbf, 0x5f, 0x30, 0x80, 0x13, 0x3b, 0x8c, 0x86, 0x56, 0x41, 0xb4, 0xcc, 0x33,
+	0x42, 0x5c, 0x71, 0xce, 0xdc, 0x2f, 0x18, 0x42, 0xea, 0x26, 0x21, 0xee, 0x66, 0x25, 0xdc, 0xd2,
+	0xa5, 0xff, 0x96, 0x60, 0x31, 0x66, 0x72, 0x98, 0x42, 0x18, 0x96, 0xb6, 0xb1, 0x8b, 0x67, 0x11,
+	0x44, 0x04, 0x73, 0x17, 0xf8, 0x4a, 0xb8, 0xa9, 0x66, 0xf0, 0x6f, 0xa9, 0xfb, 0x0e, 0x2c, 0x27,
+	0xd5, 0x84, 0xea, 0x2f, 0xd8, 0xbd, 0x32, 0xa0, 0xc4, 0xc7, 0x5b, 0xa3, 0x80, 0x92, 0xc1, 0x3e,
+	0x21, 0x17, 0xc1, 0x94, 0x46, 0xf0, 0x3c, 0x2d, 0xa9, 0x3c, 0x8d, 0x5f, 0x17, 0xb2, 0x94, 0x85,
+	0xa6, 0x7c, 0x09, 0xad, 0x4d, 0xcb, 0xbe, 0x18, 0x0d, 0x67, 0x63, 0x89, 0x5c, 0x51, 0xcf, 0xa0,
+	0x9d, 0x21, 0x77, 0xc2, 0xb2, 0x0a, 0xe0, 0x51, 0xd6, 0xc2, 0x9f, 0x7a, 0x8d, 0x4f, 0xf4, 0xcd,
+	0x13, 0xd0, 0x27, 0x29, 0x0d, 0x7d, 0x74, 0x04, 0x88, 0xed, 0xa1, 0x2f, 0x1c, 0x1b, 0x7b, 0xc1,
+	0x4c, 0xea, 0xcd, 0x16, 0x2c, 0x25, 0x24, 0x86, 0x7e, 0x79, 0x1f, 0x90, 0x2b, 0x48, 0x66, 0xd0,
+	0x27, 0x3e, 0x35, 0x3d, 0x6b, 0x10, 0xed, 0xd0, 0xcd, 0x90, 0x73, 0xcc, 0x18, 0x07, 0xd6, 0x80,
+	0x87, 0x6e, 0x0f, 0xd3, 0x8e, 0xd7, 0x23, 0x1b, 0xb3, 0xb8, 0x7b, 0x4a, 0xe3, 0x7e, 0x0a, 0xed,
+	0x0c, 0xb9, 0xa1, 0x89, 0x0f, 0x00, 0xd4, 0xa5, 0x33, 0x0c, 0x60, 0x8c, 0xc2, 0x8c, 0xda, 0xb2,
+	0x5c, 0x7b, 0xe4, 0x5a, 0x14, 0x6f, 0xf5, 0xb1, 0x7d, 0x11, 0x8c, 0x06, 0xb3, 0x30, 0xea, 0x27,
+	0xd0, 0xce, 0x90, 0x1b, 0x1a, 0xa5, 0x41, 0xd5, 0x0e, 0x69, 0xa1, 0xb7, 0x64, 0x9b, 0x05, 0x6f,
+	0x0f, 0xd3, 0x63, 0xcf, 0x1a, 0x06, 0x7d, 0x42, 0x67, 0x61, 0xca, 0x3b, 0xb0, 0x94, 0x90, 0x38,
+	0x21, 0xa9, 0xff, 0x58, 0x84, 0xc7, 0x59, 0x09, 0x36, 0x03, 0x73, 0xd8, 0x15, 0xb8, 0x4f, 0xe9,
+	0xd0, 0x54, 0x1b, 0x69, 0x85, 0xb5, 0x5f, 0xf9, 0x2e, 0xdb, 0x58, 0x38, 0xcb, 0x1a, 0xd1, 0x7e,
+	0x78, 0x0d, 0xe4, 0x7d, 0x37, 0x46, 0xb1, 0x8d, 0xe5, 0x2d, 0x78, 0x32, 0xd9, 0xb4, 0x30, 0xfb,
+	0xff, 0x50, 0x84, 0xe5, 0x3d, 0x4c, 0x0d, 0xeb, 0x72, 0xab, 0x6f, 0x79, 0xe7, 0xd3, 0xe1, 0x1b,
+	0x8f, 0xe1, 0x46, 0xcf, 0x27, 0x03, 0x33, 0x01, 0x72, 0xd4, 0x8c, 0x06, 0x23, 0xca, 0x33, 0xf6,
+	0x2a, 0xd4, 0x29, 0x31, 0x13, 0xa7, 0xf4, 0x9a, 0x01, 0x94, 0x18, 0x49, 0x24, 0xa4, 0xa4, 0xff,
+	0xa3, 0x0c, 0xb7, 0xc7, 0x4c, 0x0b, 0x83, 0xb1, 0x0f, 0x75, 0xdf, 0xba, 0x34, 0x6d, 0x41, 0x6e,
+	0x15, 0xf9, 0x1e, 0xf6, 0x76, 0xec, 0xca, 0x9b, 0x1e, 0xb3, 0x26, 0x49, 0x06, 0xf8, 0x92, 0xab,
+	0x7d, 0x5f, 0x86, 0x9a, 0xe4, 0xa0, 0x15, 0xa8, 0x9c, 0xb9, 0xe4, 0x8c, 0x1d, 0xb8, 0x44, 0xa2,
+	0x2d, 0xb0, 0x66, 0xa7, 0x2b, 0xd1, 0xa1, 0x92, 0x42, 0x87, 0x38, 0x48, 0x81, 0x2f, 0xc5, 0xf6,
+	0x2e, 0x26, 0x51, 0xf1, 0xf0, 0x25, 0xdb, 0xdd, 0x19, 0x8b, 0xdd, 0x34, 0x38, 0x6b, 0x4e, 0xb0,
+	0x88, 0xdb, 0xe5, 0xac, 0x43, 0xa8, 0x91, 0x21, 0xf6, 0x2d, 0xca, 0xe6, 0x3e, 0xcf, 0xef, 0xea,
+	0x1f, 0x5d, 0xd3, 0xf0, 0xb5, 0xc3, 0x68, 0xa0, 0xa1, 0x64, 0x30, 0x9f, 0x33, 0x5f, 0x28, 0xa1,
+	0x02, 0x6b, 0x69, 0xf8, 0xd6, 0xa5, 0xec, 0x1f, 0x19, 0x34, 0x20, 0x5d, 0xcc, 0xe1, 0x96, 0x79,
+	0x6e, 0xd0, 0x4b, 0xd2, 0x95, 0xd3, 0xe0, 0xac, 0xaa, 0x60, 0x79, 0xf8, 0x92, 0xb1, 0x74, 0x07,
+	0x6a, 0x4a, 0x44, 0x1d, 0x2a, 0xaf, 0x0e, 0x3e, 0x3f, 0x38, 0x7c, 0x7d, 0xd0, 0x2c, 0xa0, 0x1a,
+	0xcc, 0x6f, 0x6c, 0x6f, 0xef, 0x6c, 0x0b, 0x8c, 0x60, 0xeb, 0xf0, 0xa8, 0xb3, 0xb3, 0x2d, 0x30,
+	0x82, 0xed, 0x9d, 0x17, 0x3b, 0x27, 0x3b, 0xdb, 0xcd, 0x32, 0x6a, 0x40, 0xf5, 0xe5, 0xe1, 0x76,
+	0x67, 0x97, 0xb1, 0xe6, 0x18, 0xcb, 0xd8, 0x39, 0xd8, 0x78, 0xb9, 0xb3, 0xdd, 0x9c, 0x47, 0x4d,
+	0x68, 0x9c, 0xfc, 0xe2, 0x68, 0xc7, 0xdc, 0xda, 0xdf, 0x38, 0xd8, 0xdb, 0xd9, 0x6e, 0x2e, 0xe8,
+	0xbf, 0x81, 0xd6, 0x31, 0xb6, 0x7c, 0xbb, 0xbf, 0xeb, 0xb8, 0x38, 0xd8, 0xbc, 0x62, 0x25, 0x70,
+	0x9a, 0x4c, 0x5c, 0x86, 0xf9, 0x6f, 0x46, 0x38, 0xbc, 0x95, 0xd4, 0x0c, 0xd1, 0x88, 0xee, 0x8b,
+	0x65, 0x79, 0x5f, 0x94, 0xb9, 0xf6, 0x11, 0xb4, 0x33, 0xf4, 0xab, 0xd3, 0x58, 0x8f, 0x91, 0x79,
+	0xa2, 0x35, 0x0c, 0xd1, 0xd0, 0xff, 0x5c, 0x84, 0xbb, 0x89, 0x31, 0x5b, 0xc4, 0xa3, 0xd8, 0xa3,
+	0x3f, 0x82, 0xd9, 0xe8, 0x1d, 0x68, 0xda, 0xfd, 0x91, 0x77, 0x81, 0xd9, 0x75, 0x56, 0x58, 0x19,
+	0xc2, 0x72, 0xb7, 0x42, 0x7a, 0x64, 0xbc, 0x9c, 0xe1, 0x15, 0xdc, 0xcb, 0xb6, 0x36, 0x9c, 0x64,
+	0x0b, 0x2a, 0x03, 0x8b, 0xda, 0x7d, 0x39, 0xcd, 0xa8, 0x89, 0xee, 0x03, 0xf0, 0x4f, 0x33, 0xb6,
+	0xd1, 0xd6, 0x38, 0x65, 0xdb, 0xa2, 0x16, 0x7a, 0x08, 0x0d, 0xec, 0x75, 0x4d, 0xd2, 0x33, 0x39,
+	0x2d, 0x84, 0x0d, 0x01, 0x7b, 0xdd, 0xc3, 0xde, 0x4b, 0x46, 0xd1, 0xff, 0x56, 0x84, 0x5b, 0x47,
+	0x3e, 0x0e, 0x91, 0x3a, 0xe1, 0x9d, 0xcc, 0x2b, 0x64, 0xf1, 0xbf, 0x40, 0x4d, 0x3e, 0x85, 0x45,
+	0x09, 0x88, 0x5c, 0xe7, 0x0e, 0x1a, 0x61, 0x25, 0x52, 0xc0, 0x73, 0xa8, 0x93, 0xb3, 0xaf, 0xb1,
+	0x4d, 0xcd, 0x21, 0x3b, 0x6d, 0x96, 0x93, 0x43, 0x0f, 0x39, 0xeb, 0x88, 0x10, 0xd7, 0x00, 0x22,
+	0xbf, 0xa5, 0x37, 0x11, 0x34, 0xd5, 0x8c, 0xc2, 0x52, 0xfa, 0x35, 0x2c, 0x08, 0x1c, 0x32, 0xba,
+	0x00, 0x15, 0xe5, 0x05, 0x88, 0x15, 0x10, 0xbe, 0xdb, 0x8b, 0xb8, 0xf2, 0x6f, 0xf4, 0x09, 0xb4,
+	0x65, 0x1d, 0x27, 0xbe, 0xf3, 0x1d, 0x5f, 0x67, 0x66, 0x1f, 0x5b, 0x5d, 0xec, 0x87, 0x15, 0x65,
+	0x25, 0xaa, 0xeb, 0x92, 0xbf, 0xcf, 0xd9, 0xfa, 0xef, 0x8a, 0x70, 0x87, 0x6b, 0xdf, 0x3f, 0x39,
+	0x39, 0x9a, 0x1e, 0x0b, 0x7e, 0x2b, 0x81, 0x05, 0xd7, 0xd7, 0x6f, 0xaa, 0xfe, 0x5c, 0x74, 0x84,
+	0x0d, 0xc7, 0xc0, 0xde, 0x72, 0x02, 0xec, 0x95, 0x8e, 0x69, 0xc3, 0x4a, 0xca, 0xae, 0xd0, 0x3f,
+	0x7f, 0x2d, 0x82, 0xb6, 0x87, 0xc9, 0xae, 0x15, 0xd0, 0x8e, 0xe7, 0x50, 0xc7, 0x72, 0x13, 0x19,
+	0xf1, 0xbf, 0xd8, 0x3d, 0x16, 0xc3, 0xd2, 0x75, 0x62, 0x18, 0x9b, 0x6c, 0xf9, 0xba, 0x93, 0x9d,
+	0xcb, 0x9a, 0x6c, 0x51, 0xbf, 0x0f, 0x77, 0x33, 0x27, 0x24, 0x26, 0xbc, 0xfe, 0xa7, 0x16, 0x7f,
+	0x44, 0x8a, 0x9e, 0x1b, 0xc4, 0xab, 0x1b, 0x7a, 0x0d, 0xcd, 0xf1, 0x27, 0x30, 0xb4, 0x9a, 0x9e,
+	0x67, 0xe2, 0xcd, 0x4d, 0x7b, 0x98, 0xdf, 0x21, 0xf4, 0x6e, 0x01, 0x9d, 0x46, 0x4f, 0x56, 0xb1,
+	0xf7, 0x2c, 0x14, 0x1f, 0x98, 0xf9, 0x84, 0xa6, 0x3d, 0x9a, 0xd0, 0x43, 0xca, 0xde, 0x01, 0x50,
+	0x0f, 0x53, 0xa8, 0x9d, 0x1c, 0x12, 0x7b, 0x22, 0xd3, 0xb4, 0x2c, 0x96, 0x14, 0xf3, 0x05, 0xdc,
+	0x4c, 0xbe, 0x27, 0xa1, 0xfb, 0x72, 0xf3, 0xcb, 0x7a, 0xe1, 0xd2, 0x1e, 0xe4, 0xb1, 0xe3, 0x22,
+	0x93, 0x4f, 0x3a, 0x4a, 0x64, 0xe6, 0xfb, 0x91, 0x12, 0x99, 0xfd, 0x12, 0xa4, 0x17, 0xd0, 0x2f,
+	0x01, 0xa5, 0x9f, 0x60, 0x90, 0xf4, 0x53, 0xee, 0x9b, 0x90, 0xa6, 0x4f, 0xea, 0x22, 0xc5, 0xef,
+	0x43, 0x3d, 0xf6, 0x68, 0x81, 0xa4, 0xc7, 0xd2, 0xef, 0x3a, 0xda, 0xdd, 0x4c, 0x9e, 0x94, 0xf4,
+	0x1a, 0x9a, 0xe3, 0x87, 0x3c, 0x95, 0x4a, 0x39, 0x2f, 0x20, 0x2a, 0x95, 0x72, 0xdf, 0x32, 0x0a,
+	0x68, 0x0f, 0x40, 0xe1, 0xfa, 0x2a, 0xdc, 0xa9, 0xc7, 0x04, 0x15, 0xee, 0xf4, 0x33, 0x80, 0x5e,
+	0xf8, 0xb0, 0xc8, 0x2c, 0x1c, 0xc7, 0xe7, 0x95, 0x85, 0x39, 0x0f, 0x02, 0xca, 0xc2, 0x3c, 0x68,
+	0x5f, 0x24, 0x7b, 0x0a, 0xe8, 0x56, 0xc9, 0x9e, 0x07, 0xf0, 0xab, 0x64, 0xcf, 0x45, 0xc9, 0xf5,
+	0x02, 0x7a, 0x0e, 0x73, 0xbb, 0x81, 0x7d, 0x81, 0x96, 0x64, 0x67, 0x85, 0x8e, 0x6b, 0xcb, 0x49,
+	0xa2, 0x1c, 0xf4, 0x29, 0x54, 0x23, 0x58, 0x18, 0xad, 0x44, 0x7d, 0xc6, 0x40, 0x6e, 0xad, 0x95,
+	0x66, 0x48, 0x01, 0x07, 0x70, 0x23, 0x81, 0xe5, 0xa2, 0x7b, 0x52, 0x53, 0x06, 0xa8, 0xac, 0xdd,
+	0xcf, 0xe1, 0xc6, 0x97, 0xac, 0xc2, 0x56, 0x55, 0x0c, 0x53, 0x08, 0xb0, 0x8a, 0x61, 0x06, 0x14,
+	0xcb, 0x17, 0x43, 0x1a, 0x16, 0x55, 0x8b, 0x21, 0x17, 0xa8, 0x55, 0x8b, 0x21, 0x1f, 0x55, 0x8d,
+	0xc4, 0x8f, 0x03, 0x98, 0x71, 0xf1, 0x39, 0x90, 0x6a, 0x5c, 0x7c, 0x1e, 0xfe, 0xa9, 0x17, 0x90,
+	0x9b, 0x7e, 0x09, 0x0c, 0x01, 0x47, 0xf4, 0x56, 0xde, 0x3a, 0x48, 0x22, 0xa0, 0xda, 0xdb, 0xff,
+	0xb1, 0x9f, 0xd4, 0xf6, 0x12, 0x1a, 0x71, 0xa0, 0x11, 0xdd, 0x4d, 0x0e, 0x4d, 0xa0, 0x1d, 0xda,
+	0xbd, 0x6c, 0x66, 0x6c, 0xf1, 0x5c, 0x82, 0x96, 0x8f, 0x5f, 0xa0, 0x77, 0x26, 0xd9, 0x95, 0x54,
+	0xf5, 0xee, 0x75, 0xba, 0x46, 0x8a, 0x9f, 0x16, 0x59, 0x85, 0x8a, 0xa1, 0x92, 0xaa, 0x42, 0xa5,
+	0x91, 0x51, 0x55, 0xa1, 0x32, 0x60, 0x4c, 0xbd, 0x80, 0x36, 0xa1, 0x26, 0xf1, 0x39, 0xd4, 0xca,
+	0x43, 0x19, 0xb5, 0x76, 0x06, 0x47, 0xca, 0xf8, 0x1c, 0x1a, 0x71, 0x9c, 0x4d, 0x79, 0x35, 0x03,
+	0xe4, 0x53, 0x5e, 0xcd, 0x84, 0xe6, 0x44, 0xf1, 0x55, 0xd8, 0x4c, 0xac, 0xf8, 0xa6, 0x20, 0xa0,
+	0x58, 0xf1, 0x4d, 0x83, 0x39, 0x7a, 0x01, 0x7d, 0xc5, 0x1f, 0x7c, 0x93, 0x40, 0x0a, 0x8a, 0xbf,
+	0xbb, 0x66, 0x62, 0x37, 0xaa, 0x02, 0xe5, 0xa2, 0x30, 0x3c, 0xf6, 0xa7, 0xb0, 0x98, 0x42, 0x44,
+	0x94, 0xf4, 0x3c, 0x10, 0x46, 0x49, 0xcf, 0x85, 0x53, 0xf4, 0x02, 0xfa, 0x19, 0x54, 0xc2, 0xbf,
+	0x2d, 0xd0, 0x1d, 0xd9, 0x3f, 0xf1, 0x33, 0x87, 0xb6, 0x92, 0xa2, 0xcb, 0xd1, 0x9f, 0x41, 0x3d,
+	0x06, 0x90, 0xa0, 0xf8, 0x0e, 0x30, 0x06, 0x7c, 0x28, 0x0f, 0x66, 0x20, 0x2a, 0x7c, 0x96, 0xbf,
+	0x86, 0x7b, 0x93, 0x50, 0x0a, 0xf4, 0xde, 0xa4, 0xc4, 0x1d, 0xd7, 0xf6, 0xfe, 0xf5, 0x3a, 0xcb,
+	0x89, 0x1c, 0xc1, 0x8d, 0xc4, 0x8d, 0x5b, 0x15, 0xdc, 0x2c, 0x40, 0x44, 0x15, 0xdc, 0xcc, 0x6b,
+	0x3a, 0x9f, 0x0e, 0x86, 0xe5, 0xac, 0x3b, 0x16, 0x7a, 0xac, 0xd2, 0x3b, 0xf7, 0xbe, 0xa8, 0x3d,
+	0x99, 0xdc, 0x29, 0xa6, 0xe6, 0x2b, 0x58, 0x4c, 0x5d, 0x56, 0x55, 0x6e, 0xe4, 0xdd, 0xa3, 0x55,
+	0x6e, 0xe4, 0xde, 0x74, 0xb9, 0x74, 0x13, 0x50, 0x1a, 0x51, 0x46, 0xb1, 0x53, 0x62, 0x0e, 0xb4,
+	0xad, 0x2a, 0xf2, 0x04, 0x40, 0x9a, 0x55, 0x97, 0xaf, 0x60, 0x31, 0x05, 0x1e, 0x2b, 0xf3, 0xf3,
+	0xf0, 0x6a, 0x65, 0x7e, 0x2e, 0xf2, 0xcc, 0xcd, 0x3f, 0x81, 0x5b, 0x63, 0x17, 0x10, 0xf4, 0x20,
+	0xb1, 0xe9, 0xa7, 0x6e, 0x4c, 0xda, 0x6a, 0x2e, 0x5f, 0xe6, 0xca, 0xaf, 0x60, 0x29, 0xe3, 0xa4,
+	0x8f, 0x74, 0x95, 0x13, 0x79, 0xf7, 0x1a, 0xed, 0xf1, 0xc4, 0x3e, 0x91, 0x86, 0xcd, 0x0f, 0x4f,
+	0x59, 0x3f, 0xd7, 0x3a, 0x5b, 0xb3, 0xc9, 0xe0, 0x99, 0xf8, 0xfc, 0x80, 0xf8, 0xe7, 0xcf, 0xc4,
+	0xe8, 0x0f, 0xf8, 0x6f, 0x79, 0xcf, 0xce, 0x49, 0xd8, 0x1e, 0x9e, 0x9d, 0x2d, 0x70, 0xd2, 0xf3,
+	0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xbb, 0xc6, 0x4e, 0x61, 0xdb, 0x27, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/server.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/server.pb.go
index fb75e446e0222b4ab7b3c9056bfeba8bc78f5a64..6b4e020d722b63d5cea31505ff05b3e47e034cc2 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/server.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/server.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: server.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -33,7 +33,7 @@ func (m *ServerInfoRequest) Reset()         { *m = ServerInfoRequest{} }
 func (m *ServerInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*ServerInfoRequest) ProtoMessage()    {}
 func (*ServerInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_server_f514d4dfffd932d9, []int{0}
+	return fileDescriptor_server_9187386691afdaaf, []int{0}
 }
 func (m *ServerInfoRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ServerInfoRequest.Unmarshal(m, b)
@@ -66,7 +66,7 @@ func (m *ServerInfoResponse) Reset()         { *m = ServerInfoResponse{} }
 func (m *ServerInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*ServerInfoResponse) ProtoMessage()    {}
 func (*ServerInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_server_f514d4dfffd932d9, []int{1}
+	return fileDescriptor_server_9187386691afdaaf, []int{1}
 }
 func (m *ServerInfoResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ServerInfoResponse.Unmarshal(m, b)
@@ -120,7 +120,7 @@ func (m *ServerInfoResponse_StorageStatus) Reset()         { *m = ServerInfoResp
 func (m *ServerInfoResponse_StorageStatus) String() string { return proto.CompactTextString(m) }
 func (*ServerInfoResponse_StorageStatus) ProtoMessage()    {}
 func (*ServerInfoResponse_StorageStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_server_f514d4dfffd932d9, []int{1, 0}
+	return fileDescriptor_server_9187386691afdaaf, []int{1, 0}
 }
 func (m *ServerInfoResponse_StorageStatus) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ServerInfoResponse_StorageStatus.Unmarshal(m, b)
@@ -239,25 +239,27 @@ var _ServerService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "server.proto",
 }
 
-func init() { proto.RegisterFile("server.proto", fileDescriptor_server_f514d4dfffd932d9) }
-
-var fileDescriptor_server_f514d4dfffd932d9 = []byte{
-	// 258 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0xcf, 0x4a, 0xc3, 0x40,
-	0x10, 0xc6, 0x6d, 0x03, 0xa5, 0x9d, 0x34, 0xfe, 0x19, 0x2f, 0x35, 0x08, 0xd6, 0x80, 0x90, 0x53,
-	0x0e, 0xf5, 0x19, 0x3c, 0x78, 0xf1, 0x90, 0x40, 0xaf, 0x65, 0xab, 0x63, 0x58, 0x48, 0xb3, 0x75,
-	0x67, 0x5a, 0xf1, 0x69, 0x7c, 0x55, 0x71, 0xb6, 0x7f, 0x22, 0xea, 0x65, 0x61, 0x7e, 0xf3, 0xcd,
-	0xce, 0xf7, 0xed, 0xc2, 0x98, 0xc9, 0x6f, 0xc9, 0x17, 0x6b, 0xef, 0xc4, 0xe1, 0xa0, 0xb6, 0x62,
-	0x9a, 0x8f, 0xec, 0x12, 0x2e, 0x2a, 0xe5, 0x8f, 0xed, 0xab, 0x2b, 0xe9, 0x6d, 0x43, 0x2c, 0xd9,
-	0x67, 0x1f, 0xb0, 0x4b, 0x79, 0xed, 0x5a, 0x26, 0xbc, 0x83, 0xd3, 0x70, 0xc7, 0x62, 0x4b, 0x9e,
-	0xad, 0x6b, 0x27, 0xbd, 0x69, 0x2f, 0x1f, 0x95, 0x49, 0xa0, 0xf3, 0x00, 0xf1, 0x06, 0xe2, 0xda,
-	0xca, 0x41, 0xd3, 0x57, 0x0d, 0xd4, 0x56, 0xf6, 0x82, 0x0a, 0xce, 0x59, 0x9c, 0x37, 0x35, 0x2d,
-	0x58, 0x8c, 0x6c, 0x98, 0x78, 0x12, 0x4d, 0xa3, 0x3c, 0x9e, 0xe5, 0x45, 0xb0, 0x55, 0xfc, 0xde,
-	0x5e, 0x54, 0x61, 0xa4, 0xd2, 0x89, 0xf2, 0x8c, 0xbb, 0x25, 0x71, 0xda, 0x40, 0xf2, 0x43, 0x81,
-	0xb7, 0x30, 0xde, 0x6f, 0x69, 0xcd, 0x8a, 0x76, 0x5e, 0xe3, 0x1d, 0x7b, 0x32, 0x2b, 0xc2, 0x14,
-	0x86, 0x9e, 0xcc, 0x8b, 0x59, 0x36, 0xa4, 0x36, 0x87, 0xe5, 0xa1, 0xc6, 0x6b, 0x18, 0xbd, 0x7b,
-	0x2b, 0xa4, 0xcd, 0x48, 0x9b, 0x47, 0x30, 0x9b, 0x43, 0x12, 0x2c, 0x7e, 0x9f, 0xf6, 0x99, 0xf0,
-	0x01, 0xe0, 0xe8, 0x19, 0xaf, 0xfe, 0xca, 0xa1, 0x6f, 0x9b, 0xa6, 0xff, 0x47, 0xcc, 0x4e, 0x96,
-	0x03, 0xfd, 0x9d, 0xfb, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcc, 0xe4, 0x68, 0x27, 0xad, 0x01,
-	0x00, 0x00,
+func init() { proto.RegisterFile("server.proto", fileDescriptor_server_9187386691afdaaf) }
+
+var fileDescriptor_server_9187386691afdaaf = []byte{
+	// 304 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0xbf, 0x4e, 0xc3, 0x30,
+	0x10, 0xc6, 0x69, 0x2a, 0x55, 0xed, 0xb5, 0xe1, 0x8f, 0xa7, 0x12, 0x90, 0x28, 0x91, 0x90, 0xb2,
+	0x34, 0x41, 0x65, 0x63, 0x44, 0x62, 0x60, 0x61, 0x48, 0xa4, 0x0e, 0x2c, 0x95, 0xd3, 0x1e, 0xc6,
+	0x52, 0x12, 0x07, 0x9f, 0x5b, 0xc4, 0x93, 0x30, 0xf2, 0x8e, 0x3c, 0x01, 0xaa, 0x9d, 0xfe, 0x41,
+	0xc0, 0x12, 0xe5, 0x7e, 0xdf, 0x77, 0xbe, 0xef, 0x6c, 0x18, 0x10, 0xea, 0x15, 0xea, 0xb8, 0xd6,
+	0xca, 0x28, 0xd6, 0x11, 0xd2, 0xf0, 0xe2, 0x3d, 0x18, 0xd0, 0x0b, 0xd7, 0xb8, 0x70, 0x34, 0x3c,
+	0x83, 0x93, 0xcc, 0xba, 0x1e, 0xaa, 0x67, 0x95, 0xe2, 0xeb, 0x12, 0xc9, 0xdc, 0x76, 0xbe, 0x3e,
+	0x22, 0xaf, 0xeb, 0x85, 0x9f, 0x1e, 0xb0, 0x7d, 0x95, 0x6a, 0x55, 0x11, 0xb2, 0x2b, 0x38, 0x74,
+	0x27, 0xcf, 0x56, 0xa8, 0x49, 0xaa, 0x6a, 0xd8, 0x1a, 0xb5, 0xa2, 0x5e, 0xea, 0x3b, 0x3a, 0x75,
+	0x90, 0x5d, 0x40, 0x5f, 0x48, 0xb3, 0xf5, 0x78, 0xd6, 0x03, 0x42, 0x9a, 0x8d, 0x21, 0x83, 0x63,
+	0x32, 0x4a, 0x73, 0x81, 0x33, 0x32, 0xdc, 0x2c, 0x09, 0x69, 0xd8, 0x1e, 0xb5, 0xa3, 0xfe, 0x24,
+	0x8a, 0x5d, 0xd8, 0xf8, 0xf7, 0xf4, 0x38, 0x73, 0x2d, 0x99, 0xed, 0x48, 0x8f, 0x68, 0xbf, 0x44,
+	0x0a, 0x0a, 0xf0, 0x7f, 0x38, 0xd8, 0x25, 0x0c, 0x36, 0x53, 0x2a, 0x5e, 0x62, 0x93, 0xb5, 0xdf,
+	0xb0, 0x47, 0x5e, 0x22, 0x0b, 0xa0, 0xab, 0x91, 0x2f, 0x78, 0x5e, 0xa0, 0x8d, 0xd9, 0x4d, 0xb7,
+	0x35, 0x3b, 0x87, 0xde, 0x9b, 0x96, 0x06, 0xad, 0xd8, 0xb6, 0xe2, 0x0e, 0x4c, 0xa6, 0xe0, 0xbb,
+	0x88, 0xeb, 0xaf, 0x9c, 0x23, 0xbb, 0x07, 0xd8, 0x65, 0x66, 0xa7, 0x7f, 0xed, 0x61, 0xef, 0x38,
+	0x08, 0xfe, 0x5f, 0x31, 0x3c, 0xb8, 0xbb, 0x7e, 0x5a, 0xcb, 0x05, 0xcf, 0xe3, 0xb9, 0x2a, 0x13,
+	0xf7, 0x3b, 0x56, 0x5a, 0x24, 0xae, 0x69, 0x6c, 0x1f, 0x2f, 0x11, 0xaa, 0xa9, 0xeb, 0x3c, 0xef,
+	0x58, 0x74, 0xf3, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xb6, 0xe3, 0x42, 0xe4, 0xf5, 0x01, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/shared.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/shared.pb.go
index aa3a343a01f57a981158361cbcaee20471fb8f41..0f5ac7eaead5e6b14899e6c196bd64c088230b42 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/shared.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/shared.pb.go
@@ -1,11 +1,12 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: shared.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
+import descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
 import timestamp "github.com/golang/protobuf/ptypes/timestamp"
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -19,6 +20,70 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
+type OperationMsg_Operation int32
+
+const (
+	OperationMsg_UNKNOWN  OperationMsg_Operation = 0
+	OperationMsg_MUTATOR  OperationMsg_Operation = 1
+	OperationMsg_ACCESSOR OperationMsg_Operation = 2
+)
+
+var OperationMsg_Operation_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "MUTATOR",
+	2: "ACCESSOR",
+}
+var OperationMsg_Operation_value = map[string]int32{
+	"UNKNOWN":  0,
+	"MUTATOR":  1,
+	"ACCESSOR": 2,
+}
+
+func (x OperationMsg_Operation) String() string {
+	return proto.EnumName(OperationMsg_Operation_name, int32(x))
+}
+func (OperationMsg_Operation) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_shared_c632aa5c49ccb806, []int{0, 0}
+}
+
+type OperationMsg struct {
+	Op                   OperationMsg_Operation `protobuf:"varint,1,opt,name=op,proto3,enum=gitaly.OperationMsg_Operation" json:"op,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
+	XXX_unrecognized     []byte                 `json:"-"`
+	XXX_sizecache        int32                  `json:"-"`
+}
+
+func (m *OperationMsg) Reset()         { *m = OperationMsg{} }
+func (m *OperationMsg) String() string { return proto.CompactTextString(m) }
+func (*OperationMsg) ProtoMessage()    {}
+func (*OperationMsg) Descriptor() ([]byte, []int) {
+	return fileDescriptor_shared_c632aa5c49ccb806, []int{0}
+}
+func (m *OperationMsg) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_OperationMsg.Unmarshal(m, b)
+}
+func (m *OperationMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_OperationMsg.Marshal(b, m, deterministic)
+}
+func (dst *OperationMsg) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_OperationMsg.Merge(dst, src)
+}
+func (m *OperationMsg) XXX_Size() int {
+	return xxx_messageInfo_OperationMsg.Size(m)
+}
+func (m *OperationMsg) XXX_DiscardUnknown() {
+	xxx_messageInfo_OperationMsg.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_OperationMsg proto.InternalMessageInfo
+
+func (m *OperationMsg) GetOp() OperationMsg_Operation {
+	if m != nil {
+		return m.Op
+	}
+	return OperationMsg_UNKNOWN
+}
+
 type Repository struct {
 	StorageName  string `protobuf:"bytes,2,opt,name=storage_name,json=storageName,proto3" json:"storage_name,omitempty"`
 	RelativePath string `protobuf:"bytes,3,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
@@ -47,7 +112,7 @@ func (m *Repository) Reset()         { *m = Repository{} }
 func (m *Repository) String() string { return proto.CompactTextString(m) }
 func (*Repository) ProtoMessage()    {}
 func (*Repository) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_00e989e93ebea13d, []int{0}
+	return fileDescriptor_shared_c632aa5c49ccb806, []int{1}
 }
 func (m *Repository) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Repository.Unmarshal(m, b)
@@ -130,7 +195,7 @@ func (m *GitCommit) Reset()         { *m = GitCommit{} }
 func (m *GitCommit) String() string { return proto.CompactTextString(m) }
 func (*GitCommit) ProtoMessage()    {}
 func (*GitCommit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_00e989e93ebea13d, []int{1}
+	return fileDescriptor_shared_c632aa5c49ccb806, []int{2}
 }
 func (m *GitCommit) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GitCommit.Unmarshal(m, b)
@@ -212,7 +277,7 @@ func (m *CommitAuthor) Reset()         { *m = CommitAuthor{} }
 func (m *CommitAuthor) String() string { return proto.CompactTextString(m) }
 func (*CommitAuthor) ProtoMessage()    {}
 func (*CommitAuthor) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_00e989e93ebea13d, []int{2}
+	return fileDescriptor_shared_c632aa5c49ccb806, []int{3}
 }
 func (m *CommitAuthor) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitAuthor.Unmarshal(m, b)
@@ -264,7 +329,7 @@ func (m *ExitStatus) Reset()         { *m = ExitStatus{} }
 func (m *ExitStatus) String() string { return proto.CompactTextString(m) }
 func (*ExitStatus) ProtoMessage()    {}
 func (*ExitStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_00e989e93ebea13d, []int{3}
+	return fileDescriptor_shared_c632aa5c49ccb806, []int{4}
 }
 func (m *ExitStatus) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExitStatus.Unmarshal(m, b)
@@ -304,7 +369,7 @@ func (m *Branch) Reset()         { *m = Branch{} }
 func (m *Branch) String() string { return proto.CompactTextString(m) }
 func (*Branch) ProtoMessage()    {}
 func (*Branch) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_00e989e93ebea13d, []int{4}
+	return fileDescriptor_shared_c632aa5c49ccb806, []int{5}
 }
 func (m *Branch) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Branch.Unmarshal(m, b)
@@ -357,7 +422,7 @@ func (m *Tag) Reset()         { *m = Tag{} }
 func (m *Tag) String() string { return proto.CompactTextString(m) }
 func (*Tag) ProtoMessage()    {}
 func (*Tag) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_00e989e93ebea13d, []int{5}
+	return fileDescriptor_shared_c632aa5c49ccb806, []int{6}
 }
 func (m *Tag) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Tag.Unmarshal(m, b)
@@ -433,7 +498,7 @@ func (m *User) Reset()         { *m = User{} }
 func (m *User) String() string { return proto.CompactTextString(m) }
 func (*User) ProtoMessage()    {}
 func (*User) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_00e989e93ebea13d, []int{6}
+	return fileDescriptor_shared_c632aa5c49ccb806, []int{7}
 }
 func (m *User) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_User.Unmarshal(m, b)
@@ -492,7 +557,7 @@ func (m *ObjectPool) Reset()         { *m = ObjectPool{} }
 func (m *ObjectPool) String() string { return proto.CompactTextString(m) }
 func (*ObjectPool) ProtoMessage()    {}
 func (*ObjectPool) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_00e989e93ebea13d, []int{7}
+	return fileDescriptor_shared_c632aa5c49ccb806, []int{8}
 }
 func (m *ObjectPool) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ObjectPool.Unmarshal(m, b)
@@ -519,7 +584,17 @@ func (m *ObjectPool) GetRepository() *Repository {
 	return nil
 }
 
+var E_OpType = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.MessageOptions)(nil),
+	ExtensionType: (*OperationMsg)(nil),
+	Field:         82302,
+	Name:          "gitaly.op_type",
+	Tag:           "bytes,82302,opt,name=op_type,json=opType",
+	Filename:      "shared.proto",
+}
+
 func init() {
+	proto.RegisterType((*OperationMsg)(nil), "gitaly.OperationMsg")
 	proto.RegisterType((*Repository)(nil), "gitaly.Repository")
 	proto.RegisterType((*GitCommit)(nil), "gitaly.GitCommit")
 	proto.RegisterType((*CommitAuthor)(nil), "gitaly.CommitAuthor")
@@ -528,50 +603,61 @@ func init() {
 	proto.RegisterType((*Tag)(nil), "gitaly.Tag")
 	proto.RegisterType((*User)(nil), "gitaly.User")
 	proto.RegisterType((*ObjectPool)(nil), "gitaly.ObjectPool")
-}
-
-func init() { proto.RegisterFile("shared.proto", fileDescriptor_shared_00e989e93ebea13d) }
-
-var fileDescriptor_shared_00e989e93ebea13d = []byte{
-	// 629 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xd1, 0x6e, 0x13, 0x3b,
-	0x10, 0xd5, 0x26, 0x9b, 0x34, 0x99, 0x6c, 0xef, 0xed, 0xf5, 0xed, 0xc3, 0xaa, 0x57, 0x55, 0x73,
-	0x17, 0x09, 0xf5, 0x01, 0xa5, 0x28, 0x48, 0x3c, 0xd3, 0x02, 0xaa, 0xda, 0x07, 0xa8, 0xb6, 0xed,
-	0x0b, 0x2f, 0x2b, 0x27, 0x3b, 0x75, 0x8c, 0xbc, 0xf1, 0xca, 0x9e, 0x54, 0xb4, 0x1f, 0xc5, 0x97,
-	0xf0, 0x1f, 0xfc, 0x06, 0xb2, 0xbd, 0x9b, 0x06, 0x28, 0x88, 0x37, 0xcf, 0xf8, 0x78, 0x3c, 0x67,
-	0xce, 0x19, 0x48, 0xec, 0x82, 0x1b, 0x2c, 0x27, 0xb5, 0xd1, 0xa4, 0x59, 0x5f, 0x48, 0xe2, 0xea,
-	0x6e, 0xef, 0x40, 0x68, 0x2d, 0x14, 0x1e, 0xf9, 0xec, 0x6c, 0x75, 0x73, 0x44, 0xb2, 0x42, 0x4b,
-	0xbc, 0xaa, 0x03, 0x30, 0xfb, 0xdc, 0x01, 0xc8, 0xb1, 0xd6, 0x56, 0x92, 0x36, 0x77, 0xec, 0x7f,
-	0x48, 0x2c, 0x69, 0xc3, 0x05, 0x16, 0x4b, 0x5e, 0x61, 0xda, 0x19, 0x47, 0x87, 0xc3, 0x7c, 0xd4,
-	0xe4, 0xde, 0xf1, 0x0a, 0xd9, 0x13, 0xd8, 0x36, 0xa8, 0x38, 0xc9, 0x5b, 0x2c, 0x6a, 0x4e, 0x8b,
-	0xb4, 0xeb, 0x31, 0x49, 0x9b, 0xbc, 0xe0, 0xb4, 0x60, 0xcf, 0x61, 0x57, 0x48, 0x2a, 0xf4, 0xec,
-	0x23, 0xce, 0xa9, 0x28, 0xa5, 0xc1, 0xb9, 0xab, 0x9f, 0xc6, 0x1e, 0xcb, 0x84, 0xa4, 0xf7, 0xfe,
-	0xea, 0x4d, 0x7b, 0xc3, 0x4e, 0x61, 0xec, 0x5e, 0x70, 0x45, 0x68, 0x96, 0x9c, 0xf0, 0xc7, 0xb7,
-	0x12, 0x6d, 0xda, 0x1b, 0x77, 0x0f, 0x87, 0xf9, 0xbe, 0x90, 0x74, 0xdc, 0xc2, 0xbe, 0x2f, 0x23,
-	0xd1, 0xba, 0xfe, 0x84, 0x2a, 0xcc, 0x9a, 0x53, 0xda, 0x0f, 0xfd, 0x09, 0xb5, 0xc1, 0xf3, 0x29,
-	0xfc, 0x2d, 0x54, 0x51, 0x1b, 0xed, 0xff, 0xf0, 0x34, 0x06, 0x1e, 0xb6, 0x2d, 0xd4, 0x45, 0xc8,
-	0x3a, 0x1e, 0xe7, 0xf1, 0x20, 0xda, 0xe9, 0x9c, 0xc7, 0x83, 0xad, 0x9d, 0x41, 0x1e, 0x3b, 0x58,
-	0xf6, 0x35, 0x82, 0xe1, 0xa9, 0xa4, 0xd7, 0xba, 0xaa, 0x24, 0xb1, 0xbf, 0xa0, 0x23, 0xcb, 0x34,
-	0xf2, 0x4f, 0x3b, 0xb2, 0x64, 0x29, 0x6c, 0xd9, 0x95, 0x6f, 0xc9, 0x8f, 0x2e, 0xc9, 0xdb, 0x90,
-	0x31, 0x88, 0x67, 0xba, 0xbc, 0xf3, 0xd3, 0x4a, 0x72, 0x7f, 0x66, 0xcf, 0xa0, 0xcf, 0x57, 0xb4,
-	0xd0, 0xc6, 0xcf, 0x65, 0x34, 0xdd, 0x9d, 0x04, 0xd9, 0x26, 0xa1, 0xfa, 0xb1, 0xbf, 0xcb, 0x1b,
-	0x0c, 0x9b, 0xc2, 0x70, 0xee, 0xf3, 0x84, 0x26, 0xed, 0xfd, 0xe6, 0xc1, 0x03, 0x8c, 0xed, 0x03,
-	0xd4, 0xdc, 0xe0, 0x92, 0x0a, 0x59, 0xda, 0xb4, 0xef, 0xe7, 0x37, 0x0c, 0x99, 0xb3, 0xd2, 0xb2,
-	0xff, 0x60, 0xe8, 0x1a, 0x29, 0xac, 0xbc, 0xc7, 0x74, 0x6b, 0x1c, 0x1d, 0x76, 0xf3, 0x81, 0x4b,
-	0x5c, 0xca, 0x7b, 0xcc, 0x16, 0x90, 0x6c, 0x96, 0x75, 0x0c, 0xbc, 0x27, 0xa2, 0xc0, 0xc0, 0x9d,
-	0xd9, 0x2e, 0xf4, 0xb0, 0xe2, 0x52, 0x35, 0x6c, 0x43, 0xc0, 0x26, 0x10, 0x97, 0x9c, 0xd0, 0x73,
-	0x1d, 0x4d, 0xf7, 0x26, 0xc1, 0x84, 0x93, 0xd6, 0x84, 0x93, 0xab, 0xd6, 0x84, 0xb9, 0xc7, 0x65,
-	0x19, 0xc0, 0xdb, 0x4f, 0x92, 0x2e, 0x89, 0xd3, 0xca, 0xba, 0x9a, 0xb7, 0x5c, 0xad, 0xc2, 0x47,
-	0xbd, 0x3c, 0x04, 0xd9, 0x15, 0xf4, 0x4f, 0x0c, 0x5f, 0xce, 0x17, 0x8f, 0xf6, 0xf1, 0x12, 0xb6,
-	0x89, 0x1b, 0x81, 0x54, 0x04, 0xee, 0xbe, 0x9f, 0xd1, 0xf4, 0x9f, 0x76, 0x3e, 0x6b, 0xc5, 0xf2,
-	0x24, 0xe0, 0x42, 0x94, 0x7d, 0x89, 0xa0, 0x7b, 0xc5, 0xc5, 0xa3, 0x35, 0x83, 0xb6, 0x9d, 0xb5,
-	0xb6, 0x3f, 0xfd, 0xd1, 0xfd, 0xa3, 0x3f, 0x9c, 0x27, 0x2a, 0xb4, 0x96, 0x0b, 0xf4, 0x32, 0x27,
-	0x79, 0x1b, 0xba, 0x6d, 0x6b, 0x8e, 0x41, 0x81, 0x9e, 0x57, 0x60, 0xd4, 0xe4, 0x9c, 0x08, 0xce,
-	0x22, 0xc4, 0x85, 0x40, 0xe3, 0x6d, 0xfc, 0x4b, 0x8b, 0x04, 0x4c, 0x76, 0x03, 0xf1, 0xb5, 0x45,
-	0xc3, 0xfe, 0x85, 0x9e, 0x50, 0xc5, 0xda, 0x99, 0xb1, 0x50, 0x67, 0xe5, 0x9a, 0x63, 0xe7, 0x31,
-	0xfd, 0xba, 0x9b, 0xfa, 0x1d, 0xc0, 0x48, 0xa8, 0x62, 0x65, 0xdd, 0x8a, 0x55, 0xd8, 0x2c, 0x2d,
-	0x08, 0x75, 0xdd, 0x64, 0xb2, 0x57, 0x00, 0x61, 0xf1, 0x2e, 0xb4, 0x56, 0x6c, 0x0a, 0xb0, 0xb1,
-	0x6e, 0x91, 0xef, 0x93, 0xb5, 0x7d, 0x3e, 0x2c, 0x5d, 0xbe, 0x81, 0x3a, 0x81, 0x0f, 0x83, 0x00,
-	0xa8, 0x67, 0xb3, 0xbe, 0x37, 0xc6, 0x8b, 0x6f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x41, 0x1f, 0x9f,
-	0xf6, 0xc3, 0x04, 0x00, 0x00,
+	proto.RegisterEnum("gitaly.OperationMsg_Operation", OperationMsg_Operation_name, OperationMsg_Operation_value)
+	proto.RegisterExtension(E_OpType)
+}
+
+func init() { proto.RegisterFile("shared.proto", fileDescriptor_shared_c632aa5c49ccb806) }
+
+var fileDescriptor_shared_c632aa5c49ccb806 = []byte{
+	// 771 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xdd, 0x6e, 0x23, 0x35,
+	0x14, 0x66, 0x26, 0xbf, 0x73, 0x32, 0x5d, 0x82, 0xe9, 0xc5, 0xa8, 0x68, 0x69, 0x18, 0x24, 0xd4,
+	0x0b, 0x76, 0xb2, 0xca, 0x4a, 0x5c, 0x70, 0x45, 0xb7, 0xac, 0x56, 0xbb, 0xa8, 0x4d, 0xe5, 0xa6,
+	0x42, 0xe2, 0x66, 0xe4, 0x64, 0xbc, 0x8e, 0x91, 0x27, 0xb6, 0x6c, 0x67, 0x45, 0xf6, 0x92, 0x07,
+	0xe2, 0x49, 0x78, 0x0f, 0xde, 0x02, 0x21, 0xdb, 0x33, 0x69, 0x68, 0x0b, 0xda, 0x3b, 0x9f, 0xcf,
+	0x9f, 0xcf, 0xdf, 0x77, 0x8e, 0x21, 0x35, 0x6b, 0xa2, 0x69, 0x55, 0x28, 0x2d, 0xad, 0x44, 0x7d,
+	0xc6, 0x2d, 0x11, 0xbb, 0x93, 0x53, 0x26, 0x25, 0x13, 0x74, 0xea, 0xd1, 0xe5, 0xf6, 0xdd, 0xd4,
+	0xf2, 0x9a, 0x1a, 0x4b, 0x6a, 0x15, 0x88, 0x27, 0x93, 0xfb, 0x84, 0x8a, 0x9a, 0x95, 0xe6, 0xca,
+	0x4a, 0x1d, 0x18, 0xb9, 0x81, 0x74, 0xae, 0xa8, 0x26, 0x96, 0xcb, 0xcd, 0xa5, 0x61, 0xa8, 0x80,
+	0x58, 0xaa, 0x2c, 0x9a, 0x44, 0x67, 0x4f, 0x66, 0x5f, 0x16, 0x21, 0x4e, 0x71, 0xc8, 0xb8, 0x33,
+	0x70, 0x2c, 0x55, 0xfe, 0x02, 0x92, 0x3d, 0x80, 0x46, 0x30, 0xb8, 0xbd, 0xfa, 0xe9, 0x6a, 0xfe,
+	0xf3, 0xd5, 0xf8, 0x13, 0x67, 0x5c, 0xde, 0x2e, 0xce, 0x17, 0x73, 0x3c, 0x8e, 0x50, 0x0a, 0xc3,
+	0xf3, 0x8b, 0x8b, 0x57, 0x37, 0x37, 0x73, 0x3c, 0x8e, 0xf3, 0x3f, 0x62, 0x00, 0x4c, 0x95, 0x34,
+	0xdc, 0x4a, 0xbd, 0x43, 0x5f, 0x41, 0x6a, 0xac, 0xd4, 0x84, 0xd1, 0x72, 0x43, 0x6a, 0x9a, 0xc5,
+	0x93, 0xe8, 0x2c, 0xc1, 0xa3, 0x06, 0xbb, 0x22, 0x35, 0x45, 0x5f, 0xc3, 0x91, 0xa6, 0x82, 0x58,
+	0xfe, 0x9e, 0x96, 0x8a, 0xd8, 0x75, 0xd6, 0xf1, 0x9c, 0xb4, 0x05, 0xaf, 0x89, 0x5d, 0xa3, 0xe7,
+	0x70, 0xcc, 0xb8, 0x2d, 0xe5, 0xf2, 0x57, 0xba, 0xb2, 0x65, 0xc5, 0x35, 0x5d, 0x39, 0xff, 0x59,
+	0xd7, 0x73, 0x11, 0xe3, 0x76, 0xee, 0xaf, 0x7e, 0x6c, 0x6f, 0xd0, 0x6b, 0x98, 0xb8, 0x17, 0x44,
+	0x58, 0xaa, 0x37, 0xc4, 0xd2, 0xfb, 0x6f, 0x39, 0x35, 0x59, 0x6f, 0xd2, 0x39, 0x4b, 0xf0, 0x53,
+	0xc6, 0xed, 0x79, 0x4b, 0xfb, 0xb7, 0x1b, 0x4e, 0x8d, 0xcb, 0x8f, 0x89, 0x52, 0xef, 0x6b, 0xca,
+	0xfa, 0x21, 0x3f, 0x26, 0x0e, 0xea, 0xfc, 0x06, 0x3e, 0x65, 0xa2, 0x54, 0x5a, 0xfa, 0x18, 0xbe,
+	0x8c, 0xa1, 0xa7, 0x1d, 0x31, 0x71, 0x1d, 0x50, 0x57, 0xc7, 0xdb, 0xee, 0x30, 0x1a, 0xc7, 0x6f,
+	0xbb, 0xc3, 0xc1, 0x78, 0x88, 0xbb, 0x8e, 0x96, 0xff, 0x15, 0x41, 0xf2, 0x9a, 0xdb, 0x0b, 0x59,
+	0xd7, 0xdc, 0xa2, 0x27, 0x10, 0xf3, 0xca, 0x6b, 0x94, 0xe0, 0x98, 0x57, 0x28, 0x83, 0x81, 0xd9,
+	0xfa, 0x94, 0x7c, 0xeb, 0x52, 0xdc, 0x9a, 0x08, 0x41, 0x77, 0x29, 0xab, 0x9d, 0xef, 0x56, 0x8a,
+	0xfd, 0x19, 0x7d, 0x0b, 0x7d, 0xb2, 0xb5, 0x6b, 0xa9, 0x7d, 0x5f, 0x46, 0xb3, 0xe3, 0x56, 0xe5,
+	0xe0, 0xfd, 0xdc, 0xdf, 0xe1, 0x86, 0x83, 0x66, 0x90, 0xac, 0x3c, 0x6e, 0xa9, 0xce, 0x7a, 0xff,
+	0xf3, 0xe0, 0x8e, 0x86, 0x9e, 0x02, 0x28, 0xa2, 0xe9, 0xc6, 0x96, 0xbc, 0x32, 0x59, 0xdf, 0xf7,
+	0x2f, 0x09, 0xc8, 0x9b, 0xca, 0xa0, 0x2f, 0x20, 0x71, 0x89, 0x94, 0x86, 0x7f, 0xa0, 0xd9, 0x60,
+	0x12, 0x9d, 0x75, 0xf0, 0xd0, 0x01, 0x37, 0xfc, 0x03, 0xcd, 0xd7, 0x90, 0x1e, 0xba, 0x75, 0x15,
+	0xf8, 0x99, 0x88, 0x42, 0x05, 0xee, 0x8c, 0x8e, 0xa1, 0x47, 0x6b, 0xc2, 0x45, 0x53, 0x6d, 0x30,
+	0x50, 0x01, 0xdd, 0x8a, 0x58, 0xea, 0x6b, 0x1d, 0xcd, 0x4e, 0x8a, 0x30, 0xfa, 0x45, 0x3b, 0xfa,
+	0xc5, 0xa2, 0xdd, 0x0d, 0xec, 0x79, 0x79, 0x0e, 0xf0, 0xea, 0x37, 0x6e, 0x6f, 0x2c, 0xb1, 0x5b,
+	0xe3, 0x7c, 0xbe, 0x27, 0x62, 0x1b, 0x02, 0xf5, 0x70, 0x30, 0xf2, 0x05, 0xf4, 0x5f, 0x6a, 0xb2,
+	0x59, 0xad, 0x1f, 0xcd, 0xe3, 0x3b, 0x38, 0xb2, 0x44, 0x33, 0x6a, 0xcb, 0x50, 0xbb, 0xcf, 0x67,
+	0x34, 0xfb, 0xac, 0xed, 0xcf, 0x5e, 0x31, 0x9c, 0x06, 0x5e, 0xb0, 0xf2, 0x3f, 0x23, 0xe8, 0x2c,
+	0x08, 0x7b, 0xd4, 0x67, 0xd0, 0x36, 0xde, 0x6b, 0xfb, 0x20, 0x46, 0xe7, 0xa3, 0x62, 0xb8, 0x99,
+	0xa8, 0xa9, 0x31, 0x84, 0x51, 0x2f, 0x73, 0x8a, 0x5b, 0xd3, 0x6d, 0x5b, 0x73, 0x0c, 0x0a, 0xf4,
+	0xbc, 0x02, 0xa3, 0x06, 0x73, 0x22, 0xb8, 0x11, 0xb1, 0x84, 0x31, 0xaa, 0xfd, 0x18, 0xff, 0xe7,
+	0x88, 0x04, 0x4e, 0xfe, 0x0e, 0xba, 0xb7, 0x86, 0x6a, 0xf4, 0x39, 0xf4, 0x98, 0x28, 0xf7, 0x93,
+	0xd9, 0x65, 0xe2, 0x4d, 0xb5, 0xaf, 0x31, 0x7e, 0x4c, 0xbf, 0xce, 0xa1, 0x7e, 0xa7, 0x30, 0x62,
+	0xa2, 0xdc, 0x1a, 0xb7, 0x62, 0x35, 0x6d, 0x96, 0x16, 0x98, 0xb8, 0x6d, 0x90, 0xfc, 0x07, 0x80,
+	0xb0, 0x78, 0xd7, 0x52, 0x0a, 0x34, 0x03, 0x38, 0x58, 0xb7, 0xc8, 0xe7, 0x89, 0xda, 0x3c, 0xef,
+	0x96, 0x0e, 0x1f, 0xb0, 0xbe, 0xbf, 0x86, 0x81, 0x54, 0xa5, 0xdd, 0x29, 0x8a, 0x4e, 0x1f, 0xcc,
+	0xc7, 0x65, 0x68, 0xc0, 0x5c, 0xb9, 0xaf, 0xcc, 0x64, 0x7f, 0xff, 0x7e, 0x6f, 0xda, 0x0f, 0x3f,
+	0x41, 0xdc, 0x97, 0x6a, 0xb1, 0x53, 0xf4, 0xe5, 0xf3, 0x5f, 0xdc, 0xb5, 0x20, 0xcb, 0x62, 0x25,
+	0xeb, 0x69, 0x38, 0x3e, 0x93, 0x9a, 0x4d, 0xc3, 0xa3, 0x67, 0xde, 0xfb, 0x94, 0xc9, 0xc6, 0x56,
+	0xcb, 0x65, 0xdf, 0x43, 0x2f, 0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0xab, 0xc2, 0xfc, 0x8c, 0xd2,
+	0x05, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/smarthttp.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/smarthttp.pb.go
index 314e688b73f65a17bcb49d2bd2d092327af0af6b..8f3d6ba4a27a9b1d0fe3bb081b9ef3a6b6b43c90 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/smarthttp.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/smarthttp.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: smarthttp.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -38,7 +38,7 @@ func (m *InfoRefsRequest) Reset()         { *m = InfoRefsRequest{} }
 func (m *InfoRefsRequest) String() string { return proto.CompactTextString(m) }
 func (*InfoRefsRequest) ProtoMessage()    {}
 func (*InfoRefsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_smarthttp_135d2a4f87c9c40a, []int{0}
+	return fileDescriptor_smarthttp_d15d08ac1e07ff5f, []int{0}
 }
 func (m *InfoRefsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InfoRefsRequest.Unmarshal(m, b)
@@ -90,7 +90,7 @@ func (m *InfoRefsResponse) Reset()         { *m = InfoRefsResponse{} }
 func (m *InfoRefsResponse) String() string { return proto.CompactTextString(m) }
 func (*InfoRefsResponse) ProtoMessage()    {}
 func (*InfoRefsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_smarthttp_135d2a4f87c9c40a, []int{1}
+	return fileDescriptor_smarthttp_d15d08ac1e07ff5f, []int{1}
 }
 func (m *InfoRefsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InfoRefsResponse.Unmarshal(m, b)
@@ -135,7 +135,7 @@ func (m *PostUploadPackRequest) Reset()         { *m = PostUploadPackRequest{} }
 func (m *PostUploadPackRequest) String() string { return proto.CompactTextString(m) }
 func (*PostUploadPackRequest) ProtoMessage()    {}
 func (*PostUploadPackRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_smarthttp_135d2a4f87c9c40a, []int{2}
+	return fileDescriptor_smarthttp_d15d08ac1e07ff5f, []int{2}
 }
 func (m *PostUploadPackRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PostUploadPackRequest.Unmarshal(m, b)
@@ -195,7 +195,7 @@ func (m *PostUploadPackResponse) Reset()         { *m = PostUploadPackResponse{}
 func (m *PostUploadPackResponse) String() string { return proto.CompactTextString(m) }
 func (*PostUploadPackResponse) ProtoMessage()    {}
 func (*PostUploadPackResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_smarthttp_135d2a4f87c9c40a, []int{3}
+	return fileDescriptor_smarthttp_d15d08ac1e07ff5f, []int{3}
 }
 func (m *PostUploadPackResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PostUploadPackResponse.Unmarshal(m, b)
@@ -245,7 +245,7 @@ func (m *PostReceivePackRequest) Reset()         { *m = PostReceivePackRequest{}
 func (m *PostReceivePackRequest) String() string { return proto.CompactTextString(m) }
 func (*PostReceivePackRequest) ProtoMessage()    {}
 func (*PostReceivePackRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_smarthttp_135d2a4f87c9c40a, []int{4}
+	return fileDescriptor_smarthttp_d15d08ac1e07ff5f, []int{4}
 }
 func (m *PostReceivePackRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PostReceivePackRequest.Unmarshal(m, b)
@@ -326,7 +326,7 @@ func (m *PostReceivePackResponse) Reset()         { *m = PostReceivePackResponse
 func (m *PostReceivePackResponse) String() string { return proto.CompactTextString(m) }
 func (*PostReceivePackResponse) ProtoMessage()    {}
 func (*PostReceivePackResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_smarthttp_135d2a4f87c9c40a, []int{5}
+	return fileDescriptor_smarthttp_d15d08ac1e07ff5f, []int{5}
 }
 func (m *PostReceivePackResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PostReceivePackResponse.Unmarshal(m, b)
@@ -659,35 +659,38 @@ var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "smarthttp.proto",
 }
 
-func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor_smarthttp_135d2a4f87c9c40a) }
-
-var fileDescriptor_smarthttp_135d2a4f87c9c40a = []byte{
-	// 423 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0xd1, 0x8a, 0xd3, 0x40,
-	0x14, 0x75, 0xd2, 0x6e, 0x65, 0x6f, 0xa3, 0x2d, 0x77, 0xd1, 0x0d, 0x01, 0xdd, 0x1a, 0x41, 0xf2,
-	0xb0, 0x96, 0xa5, 0x7e, 0x82, 0x2f, 0x2e, 0x0a, 0x86, 0xd9, 0x2d, 0xf8, 0x16, 0xc6, 0x64, 0x3a,
-	0x3b, 0x38, 0x9b, 0x89, 0x99, 0xd9, 0x85, 0xfe, 0x83, 0xcf, 0x7e, 0x87, 0x5f, 0xe4, 0xb7, 0x48,
-	0x93, 0xa6, 0x69, 0x9b, 0x46, 0x44, 0xf1, 0x2d, 0xdc, 0x7b, 0x72, 0xee, 0x39, 0xe7, 0xde, 0x81,
-	0x91, 0xb9, 0x65, 0x85, 0xbd, 0xb1, 0x36, 0x9f, 0xe6, 0x85, 0xb6, 0x1a, 0x07, 0x42, 0x5a, 0xa6,
-	0x96, 0xbe, 0x6b, 0x6e, 0x58, 0xc1, 0xd3, 0xaa, 0x1a, 0x7c, 0x27, 0x30, 0xba, 0xcc, 0x16, 0x9a,
-	0xf2, 0x85, 0xa1, 0xfc, 0xeb, 0x1d, 0x37, 0x16, 0x67, 0x00, 0x05, 0xcf, 0xb5, 0x91, 0x56, 0x17,
-	0x4b, 0x8f, 0x4c, 0x48, 0x38, 0x9c, 0xe1, 0xb4, 0xfa, 0x7d, 0x4a, 0x37, 0x1d, 0xba, 0x85, 0xc2,
-	0x73, 0x40, 0x21, 0x6d, 0x9c, 0xe8, 0x6c, 0x21, 0x45, 0xac, 0x73, 0x2b, 0x75, 0x66, 0x3c, 0x67,
-	0xd2, 0x0b, 0x8f, 0xe9, 0x58, 0x48, 0xfb, 0xb6, 0x6c, 0x7c, 0xac, 0xea, 0xf8, 0x02, 0xdc, 0x15,
-	0xba, 0x94, 0x90, 0x68, 0xe5, 0xf5, 0x26, 0x24, 0x3c, 0xa6, 0x43, 0x21, 0x6d, 0xb4, 0x2e, 0x05,
-	0xaf, 0x60, 0xdc, 0xe8, 0x32, 0xb9, 0xce, 0x0c, 0x47, 0x84, 0x7e, 0xca, 0x2c, 0x2b, 0x25, 0xb9,
-	0xb4, 0xfc, 0x0e, 0x7e, 0x10, 0x78, 0x12, 0x69, 0x63, 0xe7, 0xb9, 0xd2, 0x2c, 0x8d, 0x58, 0xf2,
-	0xe5, 0x5f, 0x6c, 0xd4, 0x13, 0x9c, 0x66, 0x42, 0x87, 0xb5, 0xde, 0x1f, 0x5a, 0xeb, 0xb7, 0xad,
-	0x9d, 0xc3, 0xd3, 0x7d, 0xc5, 0xbf, 0x31, 0xf8, 0xcd, 0xa9, 0xe0, 0x94, 0x27, 0x5c, 0xde, 0xf3,
-	0xff, 0xe1, 0xf0, 0x04, 0x8e, 0x84, 0x8a, 0x65, 0xba, 0xde, 0x43, 0x5f, 0xa8, 0xcb, 0x14, 0x5f,
-	0xc2, 0x23, 0xa1, 0xe2, 0x2d, 0xfe, 0xca, 0x89, 0x2b, 0x54, 0xc3, 0x8c, 0x67, 0x30, 0x14, 0x2a,
-	0xbe, 0x33, 0xbc, 0xc8, 0xd8, 0x2d, 0xf7, 0x8e, 0x4a, 0x08, 0x08, 0x35, 0x5f, 0x57, 0x5a, 0x71,
-	0x0c, 0x5a, 0x71, 0x74, 0xe4, 0xfb, 0xf0, 0x70, 0xbe, 0xc1, 0x6b, 0x38, 0x6d, 0xa5, 0xd1, 0x9d,
-	0xde, 0xec, 0xa7, 0x03, 0xe3, 0xab, 0xd5, 0x4b, 0x78, 0x77, 0x7d, 0x1d, 0x5d, 0xf1, 0xe2, 0x5e,
-	0x26, 0x1c, 0xdf, 0x03, 0xd6, 0xb7, 0xd5, 0x2c, 0x01, 0x4f, 0xeb, 0xe4, 0xf6, 0xde, 0x83, 0xef,
-	0xb5, 0x1b, 0xd5, 0xc4, 0xe0, 0xc1, 0x05, 0xc1, 0x0f, 0x70, 0xd2, 0xd4, 0x37, 0xa2, 0xfe, 0x96,
-	0x6d, 0x0e, 0x8f, 0x77, 0x6f, 0x03, 0x9f, 0xd5, 0xf8, 0x83, 0x57, 0xee, 0x3f, 0xef, 0x6a, 0xd7,
-	0xa4, 0x21, 0xb9, 0x20, 0xf8, 0x09, 0x46, 0x7b, 0xa9, 0xe1, 0xce, 0x8f, 0xed, 0xe3, 0xf2, 0xcf,
-	0x3a, 0xfb, 0xdb, 0xcc, 0x9f, 0x07, 0xe5, 0x6a, 0xdf, 0xfc, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xf1,
-	0x46, 0x34, 0x66, 0x70, 0x04, 0x00, 0x00,
+func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor_smarthttp_d15d08ac1e07ff5f) }
+
+var fileDescriptor_smarthttp_d15d08ac1e07ff5f = []byte{
+	// 465 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0xcb, 0x6e, 0xd3, 0x40,
+	0x14, 0x65, 0x9c, 0x34, 0xd0, 0x9b, 0x40, 0xa2, 0x5b, 0x41, 0xad, 0x48, 0xd0, 0x60, 0x24, 0xe4,
+	0x45, 0xf3, 0x50, 0xd8, 0xb1, 0x84, 0x0d, 0x15, 0x48, 0x58, 0x6e, 0x23, 0x21, 0x36, 0xd6, 0xc4,
+	0x9e, 0x4c, 0x47, 0x4c, 0x3c, 0xc6, 0x33, 0xad, 0xd4, 0xff, 0x40, 0x62, 0xc7, 0x77, 0xf0, 0x35,
+	0x7c, 0x04, 0x5f, 0x80, 0xe2, 0x47, 0x9d, 0xc6, 0x35, 0x42, 0x20, 0x76, 0x33, 0xe7, 0x9e, 0xfb,
+	0x38, 0x67, 0xee, 0x40, 0x5f, 0xaf, 0x69, 0x6a, 0xce, 0x8d, 0x49, 0x26, 0x49, 0xaa, 0x8c, 0xc2,
+	0x0e, 0x17, 0x86, 0xca, 0xab, 0x61, 0x4f, 0x9f, 0xd3, 0x94, 0x45, 0x39, 0xea, 0x7c, 0x23, 0xd0,
+	0x3f, 0x89, 0x57, 0xca, 0x67, 0x2b, 0xed, 0xb3, 0xcf, 0x17, 0x4c, 0x1b, 0x9c, 0x03, 0xa4, 0x2c,
+	0x51, 0x5a, 0x18, 0x95, 0x5e, 0xd9, 0x64, 0x44, 0xdc, 0xee, 0x1c, 0x27, 0x79, 0xfa, 0xc4, 0xbf,
+	0x8e, 0xf8, 0x5b, 0x2c, 0x3c, 0x06, 0xe4, 0xc2, 0x04, 0xa1, 0x8a, 0x57, 0x82, 0x07, 0x2a, 0x31,
+	0x42, 0xc5, 0xda, 0xb6, 0x46, 0x2d, 0x77, 0xdf, 0x1f, 0x70, 0x61, 0x5e, 0x67, 0x81, 0xf7, 0x39,
+	0x8e, 0x4f, 0xa1, 0xb7, 0x61, 0x67, 0x23, 0x84, 0x4a, 0xda, 0xad, 0x11, 0x71, 0xf7, 0xfd, 0x2e,
+	0x17, 0xc6, 0x2b, 0xa0, 0x97, 0x9d, 0x9f, 0x5f, 0x5d, 0xeb, 0x9e, 0xe5, 0x3c, 0x87, 0x41, 0x35,
+	0x9f, 0x4e, 0x54, 0xac, 0x19, 0x22, 0xb4, 0x23, 0x6a, 0x68, 0x36, 0x5a, 0xcf, 0xcf, 0xce, 0xce,
+	0x77, 0x02, 0x0f, 0x3d, 0xa5, 0xcd, 0x22, 0x91, 0x8a, 0x46, 0x1e, 0x0d, 0x3f, 0xfd, 0x8b, 0x9c,
+	0xb2, 0x83, 0x55, 0x75, 0x68, 0x90, 0xd8, 0xfa, 0x43, 0x89, 0xed, 0x66, 0x89, 0xc7, 0xf0, 0x68,
+	0x77, 0xf2, 0xdf, 0x08, 0xfd, 0x62, 0xe5, 0x74, 0x9f, 0x85, 0x4c, 0x5c, 0xb2, 0xff, 0xa1, 0xf4,
+	0x00, 0xf6, 0xb8, 0x0c, 0x44, 0x54, 0xbc, 0x4b, 0x9b, 0xcb, 0x93, 0x08, 0x9f, 0xc1, 0x7d, 0x2e,
+	0x83, 0xad, 0xfa, 0xb9, 0xa2, 0x1e, 0x97, 0x55, 0x65, 0x3c, 0x82, 0x2e, 0x97, 0xc1, 0x85, 0x66,
+	0x69, 0x4c, 0xd7, 0xcc, 0xde, 0xcb, 0x28, 0xc0, 0xe5, 0xa2, 0x40, 0x6a, 0xb6, 0x74, 0x6a, 0xb6,
+	0x34, 0xf8, 0x7c, 0xf7, 0x76, 0x9f, 0x0b, 0x13, 0x89, 0x33, 0x86, 0xc3, 0x9a, 0x2b, 0xcd, 0x2e,
+	0xce, 0x7f, 0x58, 0x30, 0x38, 0xdd, 0xfc, 0x90, 0x37, 0x67, 0x67, 0xde, 0x29, 0x4b, 0x2f, 0x45,
+	0xc8, 0xf0, 0x2d, 0x60, 0xb9, 0x6b, 0xd5, 0x63, 0xe0, 0x61, 0xe9, 0xe0, 0xce, 0x3f, 0x19, 0xda,
+	0xf5, 0x40, 0xde, 0xd1, 0xb9, 0x33, 0x23, 0xf8, 0x0e, 0x0e, 0x2a, 0xfc, 0x7a, 0xa8, 0xbf, 0xad,
+	0xb6, 0x80, 0x07, 0x37, 0x77, 0x04, 0x1f, 0x97, 0xfc, 0x5b, 0xb7, 0x7e, 0xf8, 0xa4, 0x29, 0x5c,
+	0x16, 0x75, 0xc9, 0x8c, 0xe0, 0x07, 0xe8, 0xef, 0xb8, 0x86, 0x37, 0x12, 0xeb, 0x4b, 0x36, 0x3c,
+	0x6a, 0x8c, 0x6f, 0x57, 0x7e, 0x35, 0xfb, 0xb8, 0xe1, 0x49, 0xba, 0x9c, 0x84, 0x6a, 0x3d, 0xcd,
+	0x8f, 0x63, 0x95, 0xf2, 0x69, 0x9e, 0x3d, 0xce, 0x36, 0x60, 0xca, 0x55, 0x71, 0x4f, 0x96, 0xcb,
+	0x4e, 0x06, 0xbd, 0xf8, 0x15, 0x00, 0x00, 0xff, 0xff, 0x06, 0xb7, 0x75, 0xf3, 0xba, 0x04, 0x00,
+	0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ssh.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ssh.pb.go
index 14df1271135e217c412671da994664e07f562507..5243e0db89baeb8ee90de0fce937848365183b15 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ssh.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ssh.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: ssh.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -41,7 +41,7 @@ func (m *SSHUploadPackRequest) Reset()         { *m = SSHUploadPackRequest{} }
 func (m *SSHUploadPackRequest) String() string { return proto.CompactTextString(m) }
 func (*SSHUploadPackRequest) ProtoMessage()    {}
 func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ssh_22394c3f711a1084, []int{0}
+	return fileDescriptor_ssh_e79ebe9ec5e2177f, []int{0}
 }
 func (m *SSHUploadPackRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SSHUploadPackRequest.Unmarshal(m, b)
@@ -106,7 +106,7 @@ func (m *SSHUploadPackResponse) Reset()         { *m = SSHUploadPackResponse{} }
 func (m *SSHUploadPackResponse) String() string { return proto.CompactTextString(m) }
 func (*SSHUploadPackResponse) ProtoMessage()    {}
 func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ssh_22394c3f711a1084, []int{1}
+	return fileDescriptor_ssh_e79ebe9ec5e2177f, []int{1}
 }
 func (m *SSHUploadPackResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SSHUploadPackResponse.Unmarshal(m, b)
@@ -170,7 +170,7 @@ func (m *SSHReceivePackRequest) Reset()         { *m = SSHReceivePackRequest{} }
 func (m *SSHReceivePackRequest) String() string { return proto.CompactTextString(m) }
 func (*SSHReceivePackRequest) ProtoMessage()    {}
 func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ssh_22394c3f711a1084, []int{2}
+	return fileDescriptor_ssh_e79ebe9ec5e2177f, []int{2}
 }
 func (m *SSHReceivePackRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SSHReceivePackRequest.Unmarshal(m, b)
@@ -256,7 +256,7 @@ func (m *SSHReceivePackResponse) Reset()         { *m = SSHReceivePackResponse{}
 func (m *SSHReceivePackResponse) String() string { return proto.CompactTextString(m) }
 func (*SSHReceivePackResponse) ProtoMessage()    {}
 func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ssh_22394c3f711a1084, []int{3}
+	return fileDescriptor_ssh_e79ebe9ec5e2177f, []int{3}
 }
 func (m *SSHReceivePackResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SSHReceivePackResponse.Unmarshal(m, b)
@@ -311,7 +311,7 @@ func (m *SSHUploadArchiveRequest) Reset()         { *m = SSHUploadArchiveRequest
 func (m *SSHUploadArchiveRequest) String() string { return proto.CompactTextString(m) }
 func (*SSHUploadArchiveRequest) ProtoMessage()    {}
 func (*SSHUploadArchiveRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ssh_22394c3f711a1084, []int{4}
+	return fileDescriptor_ssh_e79ebe9ec5e2177f, []int{4}
 }
 func (m *SSHUploadArchiveRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SSHUploadArchiveRequest.Unmarshal(m, b)
@@ -361,7 +361,7 @@ func (m *SSHUploadArchiveResponse) Reset()         { *m = SSHUploadArchiveRespon
 func (m *SSHUploadArchiveResponse) String() string { return proto.CompactTextString(m) }
 func (*SSHUploadArchiveResponse) ProtoMessage()    {}
 func (*SSHUploadArchiveResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ssh_22394c3f711a1084, []int{5}
+	return fileDescriptor_ssh_e79ebe9ec5e2177f, []int{5}
 }
 func (m *SSHUploadArchiveResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SSHUploadArchiveResponse.Unmarshal(m, b)
@@ -651,37 +651,39 @@ var _SSHService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ssh.proto",
 }
 
-func init() { proto.RegisterFile("ssh.proto", fileDescriptor_ssh_22394c3f711a1084) }
-
-var fileDescriptor_ssh_22394c3f711a1084 = []byte{
-	// 452 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x53, 0xc1, 0x6e, 0xd3, 0x40,
-	0x10, 0xc5, 0x89, 0x13, 0xc8, 0xc4, 0x45, 0xd1, 0xd2, 0x16, 0x2b, 0x02, 0x6a, 0xcc, 0xc5, 0x07,
-	0x14, 0xa1, 0xf4, 0x0b, 0x10, 0x42, 0x2a, 0x5c, 0xa8, 0xd6, 0xca, 0x89, 0x83, 0x65, 0xec, 0x61,
-	0xb3, 0x62, 0xeb, 0x35, 0xbb, 0x9b, 0xa8, 0x95, 0x40, 0x7c, 0x01, 0x37, 0xbe, 0x8b, 0x6f, 0x42,
-	0xac, 0x4d, 0xb0, 0xe3, 0xfa, 0x06, 0xb9, 0x79, 0xe6, 0x8d, 0xdf, 0xcc, 0xbc, 0x37, 0x0b, 0x13,
-	0xad, 0xd7, 0x8b, 0x52, 0x49, 0x23, 0xc9, 0x98, 0x71, 0x93, 0x8a, 0x9b, 0xb9, 0xa7, 0xd7, 0xa9,
-	0xc2, 0xbc, 0xca, 0x86, 0x3f, 0x1d, 0x38, 0x8e, 0xe3, 0x8b, 0x55, 0x29, 0x64, 0x9a, 0x5f, 0xa6,
-	0xd9, 0x27, 0x8a, 0x9f, 0x37, 0xa8, 0x0d, 0x59, 0x02, 0x28, 0x2c, 0xa5, 0xe6, 0x46, 0xaa, 0x1b,
-	0xdf, 0x09, 0x9c, 0x68, 0xba, 0x24, 0x8b, 0x8a, 0x63, 0x41, 0x77, 0x08, 0x6d, 0x54, 0x91, 0x63,
-	0x18, 0x69, 0x93, 0xf3, 0xc2, 0x1f, 0x04, 0x4e, 0xe4, 0xd1, 0x2a, 0x20, 0xcf, 0x81, 0x30, 0x6e,
-	0x92, 0x4c, 0x16, 0x1f, 0x39, 0x4b, 0x64, 0x69, 0xb8, 0x2c, 0xb4, 0xef, 0x06, 0xc3, 0x68, 0x42,
-	0x67, 0x8c, 0x9b, 0x57, 0x16, 0x78, 0x57, 0xe5, 0xc9, 0x53, 0xf0, 0x7e, 0x57, 0xdb, 0xe9, 0x32,
-	0x29, 0xfc, 0x51, 0xe0, 0x44, 0x13, 0x3a, 0x65, 0xdc, 0x5c, 0xd6, 0xa9, 0xb7, 0xee, 0xbd, 0xe1,
-	0xcc, 0xa5, 0x27, 0x0d, 0xd2, 0x32, 0x55, 0xe9, 0x15, 0x1a, 0x54, 0x3a, 0xfc, 0x02, 0x27, 0x7b,
-	0xfb, 0xe8, 0x52, 0x16, 0x1a, 0xc9, 0x29, 0x8c, 0xb5, 0xc9, 0xe5, 0xc6, 0xd8, 0x65, 0x3c, 0x5a,
-	0x47, 0x75, 0x1e, 0x95, 0xaa, 0xa7, 0xae, 0x23, 0x72, 0x0e, 0x53, 0xbc, 0xe6, 0x26, 0xd1, 0x26,
-	0x35, 0x1b, 0xed, 0x0f, 0xdb, 0x0a, 0xbc, 0xbe, 0xe6, 0x26, 0xb6, 0x08, 0x05, 0xdc, 0x7d, 0x87,
-	0xdf, 0x07, 0xb6, 0x3d, 0xc5, 0x0c, 0xf9, 0x16, 0xff, 0x8f, 0x9e, 0x0f, 0x60, 0xc4, 0x44, 0xc2,
-	0x73, 0x3b, 0xd2, 0x84, 0xba, 0x4c, 0xbc, 0xc9, 0xc9, 0x33, 0x38, 0x62, 0x22, 0x69, 0x74, 0x70,
-	0x2d, 0xe8, 0x31, 0xf1, 0x97, 0x9b, 0x9c, 0xc1, 0x94, 0x89, 0x64, 0xa3, 0x51, 0x15, 0xe9, 0x15,
-	0xd6, 0xd2, 0x02, 0x13, 0xab, 0x3a, 0xd3, 0x11, 0x7f, 0xdc, 0x11, 0xbf, 0xc7, 0xcd, 0xbb, 0xb7,
-	0xbb, 0x19, 0x7e, 0x85, 0xd3, 0x7d, 0x39, 0x0e, 0x69, 0x47, 0x06, 0x0f, 0x77, 0xc7, 0xf0, 0x52,
-	0x65, 0x6b, 0xbe, 0xc5, 0x7f, 0xee, 0x47, 0xf8, 0x0d, 0xfc, 0x6e, 0x93, 0x03, 0x6e, 0xb9, 0xfc,
-	0x31, 0x00, 0x88, 0xe3, 0x8b, 0x18, 0xd5, 0x96, 0x67, 0x48, 0x28, 0x1c, 0xb5, 0x5e, 0x00, 0x79,
-	0xf4, 0xe7, 0xff, 0xdb, 0x1e, 0xfa, 0xfc, 0x71, 0x0f, 0x5a, 0x6d, 0x10, 0xde, 0x89, 0x9c, 0x17,
-	0x0e, 0x59, 0xc1, 0xfd, 0xb6, 0x8f, 0xa4, 0xf9, 0x5b, 0xf7, 0xdc, 0xe7, 0x4f, 0xfa, 0xe0, 0x16,
-	0xed, 0x7b, 0x98, 0xed, 0x4b, 0x47, 0xce, 0x3a, 0xf3, 0xb4, 0x9d, 0x9b, 0x07, 0xfd, 0x05, 0x4d,
-	0xf2, 0x0f, 0x63, 0x7b, 0xc6, 0xe7, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x1e, 0x98, 0x8e, 0xd7,
-	0x04, 0x05, 0x00, 0x00,
+func init() { proto.RegisterFile("ssh.proto", fileDescriptor_ssh_e79ebe9ec5e2177f) }
+
+var fileDescriptor_ssh_e79ebe9ec5e2177f = []byte{
+	// 494 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0x4d, 0x6e, 0xd3, 0x40,
+	0x14, 0xc6, 0x8e, 0x63, 0x9a, 0x17, 0x17, 0x45, 0x43, 0x5b, 0xac, 0x08, 0xa8, 0x31, 0x1b, 0x2f,
+	0x68, 0x52, 0xa5, 0x3b, 0x76, 0x80, 0x90, 0x0a, 0x1b, 0xaa, 0xb1, 0xb2, 0x81, 0x85, 0xe5, 0xd8,
+	0xc3, 0x64, 0xd4, 0x89, 0xc7, 0xcc, 0x4c, 0xa2, 0x56, 0x02, 0x71, 0x09, 0x10, 0x37, 0xe3, 0x20,
+	0x9c, 0x00, 0xd5, 0x36, 0xc1, 0x8e, 0x9b, 0x1d, 0x64, 0x37, 0xef, 0xfb, 0xde, 0xff, 0xf7, 0x6c,
+	0xe8, 0x29, 0x35, 0x1f, 0xe5, 0x52, 0x68, 0x81, 0x6c, 0xca, 0x74, 0xcc, 0xaf, 0x87, 0x8e, 0x9a,
+	0xc7, 0x92, 0xa4, 0x25, 0xea, 0xff, 0x34, 0xe0, 0x20, 0x0c, 0xcf, 0xa7, 0x39, 0x17, 0x71, 0x7a,
+	0x11, 0x27, 0x97, 0x98, 0x7c, 0x5a, 0x12, 0xa5, 0xd1, 0x04, 0x40, 0x92, 0x5c, 0x28, 0xa6, 0x85,
+	0xbc, 0x76, 0x0d, 0xcf, 0x08, 0xfa, 0x13, 0x34, 0x2a, 0x73, 0x8c, 0xf0, 0x9a, 0xc1, 0x35, 0x2f,
+	0x74, 0x00, 0x5d, 0xa5, 0x53, 0x96, 0xb9, 0xa6, 0x67, 0x04, 0x0e, 0x2e, 0x0d, 0xf4, 0x0c, 0x10,
+	0x65, 0x3a, 0x4a, 0x44, 0xf6, 0x91, 0xd1, 0x48, 0xe4, 0x9a, 0x89, 0x4c, 0xb9, 0x96, 0xd7, 0x09,
+	0x7a, 0x78, 0x40, 0x99, 0x7e, 0x55, 0x10, 0xef, 0x4a, 0x1c, 0x3d, 0x01, 0xe7, 0xc6, 0xbb, 0xe8,
+	0x2e, 0x11, 0xdc, 0xed, 0x7a, 0x46, 0xd0, 0xc3, 0x7d, 0xca, 0xf4, 0x45, 0x05, 0x3d, 0xb7, 0x7f,
+	0xfd, 0x08, 0xcc, 0x3d, 0xf3, 0xad, 0xb5, 0xd7, 0x19, 0x58, 0xf8, 0xb0, 0x96, 0x3c, 0x8f, 0x65,
+	0xbc, 0x20, 0x9a, 0x48, 0xe5, 0x7f, 0x86, 0xc3, 0x8d, 0xb9, 0x54, 0x2e, 0x32, 0x45, 0xd0, 0x11,
+	0xd8, 0x4a, 0xa7, 0x62, 0xa9, 0x8b, 0xa1, 0x1c, 0x5c, 0x59, 0x15, 0x4e, 0xa4, 0xac, 0xba, 0xaf,
+	0x2c, 0x74, 0x06, 0x7d, 0x72, 0xc5, 0x74, 0xa4, 0x74, 0xac, 0x97, 0xca, 0xed, 0x34, 0x37, 0xf1,
+	0xfa, 0x8a, 0xe9, 0xb0, 0x60, 0x30, 0x90, 0xf5, 0xdb, 0xff, 0x6e, 0x16, 0xe5, 0x31, 0x49, 0x08,
+	0x5b, 0x91, 0xff, 0xb3, 0xd7, 0xfb, 0xd0, 0xa5, 0x3c, 0x62, 0x69, 0xd1, 0x52, 0x0f, 0x5b, 0x94,
+	0xbf, 0x49, 0xd1, 0x53, 0xd8, 0xa7, 0x3c, 0xaa, 0x55, 0xb0, 0x0a, 0xd2, 0xa1, 0xfc, 0x6f, 0x6e,
+	0x74, 0x0c, 0x7d, 0xca, 0xa3, 0xa5, 0x22, 0x32, 0x8b, 0x17, 0xa4, 0x5a, 0x31, 0x50, 0x3e, 0xad,
+	0x90, 0x96, 0x08, 0x76, 0x4b, 0x84, 0x2d, 0xaa, 0xde, 0xbd, 0x5d, 0xd5, 0x4a, 0x32, 0xc3, 0xff,
+	0x02, 0x47, 0x9b, 0x6b, 0xd9, 0xa5, 0x2c, 0x97, 0xf0, 0x60, 0x7d, 0x14, 0x2f, 0x64, 0x32, 0x67,
+	0x2b, 0xf2, 0xcf, 0x75, 0x59, 0xcf, 0xfa, 0x15, 0xdc, 0x76, 0xb1, 0x1d, 0x4e, 0x3b, 0xf9, 0x66,
+	0x02, 0x84, 0xe1, 0x79, 0x48, 0xe4, 0x8a, 0x25, 0x04, 0x61, 0xd8, 0x6f, 0x7c, 0x11, 0xe8, 0xe1,
+	0x9f, 0xf8, 0xdb, 0x7e, 0x00, 0xc3, 0x47, 0x5b, 0xd8, 0x72, 0x02, 0xff, 0x4e, 0x60, 0x9c, 0x1a,
+	0x68, 0x0a, 0xf7, 0x9a, 0x7a, 0xa2, 0x7a, 0x58, 0xfb, 0xfc, 0x87, 0x8f, 0xb7, 0xd1, 0x8d, 0xb4,
+	0x1f, 0x60, 0xb0, 0xb9, 0x3a, 0x74, 0xdc, 0xea, 0xa7, 0xa9, 0xe0, 0xd0, 0xdb, 0xee, 0x50, 0x4f,
+	0xfe, 0xf2, 0xf4, 0xfd, 0x8d, 0x23, 0x8f, 0x67, 0xa3, 0x44, 0x2c, 0xc6, 0xe5, 0xf3, 0x44, 0x48,
+	0x3a, 0x2e, 0xc3, 0x4f, 0x8a, 0xab, 0x1f, 0x53, 0x51, 0xd9, 0xf9, 0x6c, 0x66, 0x17, 0xd0, 0xd9,
+	0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x96, 0xf9, 0x08, 0x4e, 0x05, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/storage.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/storage.pb.go
index 3015bf30618a9345b32f17d5ca5bb7adeb4f8eaf..ff115a64bd7871eb5e75ad4d44041a1838451b53 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/storage.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/storage.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: storage.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -35,7 +35,7 @@ func (m *ListDirectoriesRequest) Reset()         { *m = ListDirectoriesRequest{}
 func (m *ListDirectoriesRequest) String() string { return proto.CompactTextString(m) }
 func (*ListDirectoriesRequest) ProtoMessage()    {}
 func (*ListDirectoriesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_storage_40b92399a791179d, []int{0}
+	return fileDescriptor_storage_7d59321d1c916edc, []int{0}
 }
 func (m *ListDirectoriesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListDirectoriesRequest.Unmarshal(m, b)
@@ -80,7 +80,7 @@ func (m *ListDirectoriesResponse) Reset()         { *m = ListDirectoriesResponse
 func (m *ListDirectoriesResponse) String() string { return proto.CompactTextString(m) }
 func (*ListDirectoriesResponse) ProtoMessage()    {}
 func (*ListDirectoriesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_storage_40b92399a791179d, []int{1}
+	return fileDescriptor_storage_7d59321d1c916edc, []int{1}
 }
 func (m *ListDirectoriesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListDirectoriesResponse.Unmarshal(m, b)
@@ -118,7 +118,7 @@ func (m *DeleteAllRepositoriesRequest) Reset()         { *m = DeleteAllRepositor
 func (m *DeleteAllRepositoriesRequest) String() string { return proto.CompactTextString(m) }
 func (*DeleteAllRepositoriesRequest) ProtoMessage()    {}
 func (*DeleteAllRepositoriesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_storage_40b92399a791179d, []int{2}
+	return fileDescriptor_storage_7d59321d1c916edc, []int{2}
 }
 func (m *DeleteAllRepositoriesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteAllRepositoriesRequest.Unmarshal(m, b)
@@ -155,7 +155,7 @@ func (m *DeleteAllRepositoriesResponse) Reset()         { *m = DeleteAllReposito
 func (m *DeleteAllRepositoriesResponse) String() string { return proto.CompactTextString(m) }
 func (*DeleteAllRepositoriesResponse) ProtoMessage()    {}
 func (*DeleteAllRepositoriesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_storage_40b92399a791179d, []int{3}
+	return fileDescriptor_storage_7d59321d1c916edc, []int{3}
 }
 func (m *DeleteAllRepositoriesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteAllRepositoriesResponse.Unmarshal(m, b)
@@ -315,23 +315,27 @@ var _StorageService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "storage.proto",
 }
 
-func init() { proto.RegisterFile("storage.proto", fileDescriptor_storage_40b92399a791179d) }
+func init() { proto.RegisterFile("storage.proto", fileDescriptor_storage_7d59321d1c916edc) }
 
-var fileDescriptor_storage_40b92399a791179d = []byte{
-	// 238 bytes of a gzipped FileDescriptorProto
+var fileDescriptor_storage_7d59321d1c916edc = []byte{
+	// 289 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2d, 0x2e, 0xc9, 0x2f,
 	0x4a, 0x4c, 0x4f, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc,
-	0xa9, 0x54, 0x0a, 0xe4, 0x12, 0xf3, 0xc9, 0x2c, 0x2e, 0x71, 0xc9, 0x2c, 0x4a, 0x4d, 0x2e, 0xc9,
-	0x2f, 0xca, 0x4c, 0x2d, 0x0e, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x11, 0x52, 0xe4, 0xe2, 0x81,
-	0x6a, 0x89, 0xcf, 0x4b, 0xcc, 0x4d, 0x95, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0xe2, 0x86, 0x8a,
-	0xf9, 0x25, 0xe6, 0xa6, 0x0a, 0x89, 0x70, 0xb1, 0xa6, 0xa4, 0x16, 0x94, 0x64, 0x48, 0x30, 0x29,
-	0x30, 0x6a, 0xf0, 0x06, 0x41, 0x38, 0x4a, 0xfa, 0x5c, 0xe2, 0x18, 0x46, 0x16, 0x17, 0xe4, 0xe7,
-	0x15, 0x83, 0x35, 0x14, 0x24, 0x96, 0x64, 0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6b, 0x70, 0x06, 0x41,
-	0x38, 0x4a, 0x8e, 0x5c, 0x32, 0x2e, 0xa9, 0x39, 0xa9, 0x25, 0xa9, 0x8e, 0x39, 0x39, 0x41, 0xa9,
-	0x05, 0xf9, 0xc5, 0x99, 0xa4, 0xba, 0x44, 0x49, 0x9e, 0x4b, 0x16, 0x87, 0x11, 0x10, 0x9b, 0x8d,
-	0x2e, 0x30, 0x72, 0xf1, 0x05, 0x43, 0x34, 0x04, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x0a, 0x85,
-	0x71, 0xf1, 0xa3, 0xb9, 0x53, 0x48, 0x4e, 0x0f, 0x12, 0x2c, 0x7a, 0xd8, 0xc3, 0x44, 0x4a, 0x1e,
-	0xa7, 0x3c, 0xc4, 0x1a, 0x25, 0x06, 0x03, 0x46, 0xa1, 0x34, 0x2e, 0x51, 0xac, 0x6e, 0x11, 0x52,
-	0x81, 0xe9, 0xc6, 0xe7, 0x5b, 0x29, 0x55, 0x02, 0xaa, 0x60, 0x36, 0x25, 0xb1, 0x81, 0x63, 0xd2,
-	0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xb8, 0xfc, 0x6c, 0x48, 0xda, 0x01, 0x00, 0x00,
+	0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81, 0x88, 0x2a, 0x45, 0x72, 0x89, 0xf9,
+	0x64, 0x16, 0x97, 0xb8, 0x64, 0x16, 0xa5, 0x26, 0x97, 0xe4, 0x17, 0x65, 0xa6, 0x16, 0x07, 0xa5,
+	0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x29, 0x72, 0xf1, 0x40, 0x0d, 0x88, 0xcf, 0x4b, 0xcc, 0x4d,
+	0x95, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0xe2, 0x86, 0x8a, 0xf9, 0x25, 0xe6, 0xa6, 0x0a, 0x89,
+	0x70, 0xb1, 0xa6, 0xa4, 0x16, 0x94, 0x64, 0x48, 0x30, 0x29, 0x30, 0x6a, 0xf0, 0x06, 0x41, 0x38,
+	0x56, 0x6c, 0x9f, 0xa6, 0x6b, 0x30, 0x71, 0x30, 0x2a, 0xe9, 0x73, 0x89, 0x63, 0x18, 0x5d, 0x5c,
+	0x90, 0x9f, 0x57, 0x0c, 0xd6, 0x58, 0x90, 0x58, 0x92, 0x51, 0x2c, 0xc1, 0xa8, 0xc0, 0xac, 0xc1,
+	0x19, 0x04, 0xe1, 0x28, 0x79, 0x72, 0xc9, 0xb8, 0xa4, 0xe6, 0xa4, 0x96, 0xa4, 0x3a, 0xe6, 0xe4,
+	0x04, 0xa5, 0x16, 0xe4, 0x17, 0x67, 0x92, 0xea, 0x22, 0xb8, 0xdd, 0xf2, 0x5c, 0xb2, 0x38, 0x8c,
+	0x82, 0xb8, 0xc0, 0xe8, 0x02, 0x23, 0x17, 0x5f, 0x30, 0x44, 0x63, 0x70, 0x6a, 0x51, 0x59, 0x66,
+	0x72, 0xaa, 0x50, 0x18, 0x17, 0x3f, 0x9a, 0x7b, 0x85, 0xe4, 0xf4, 0x20, 0x81, 0xa6, 0x87, 0x3d,
+	0x8c, 0xa4, 0xe4, 0x71, 0xca, 0x43, 0xac, 0x51, 0x62, 0x30, 0x60, 0x14, 0x4a, 0xe3, 0x12, 0xc5,
+	0xea, 0x16, 0x21, 0x15, 0x98, 0x6e, 0x7c, 0xbe, 0x96, 0x52, 0x25, 0xa0, 0x0a, 0x66, 0x93, 0x93,
+	0x41, 0x14, 0x48, 0x65, 0x4e, 0x62, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0x84, 0xa9, 0x9b, 0x5f,
+	0x94, 0xae, 0x0f, 0xd1, 0xaf, 0x0b, 0x8e, 0x70, 0xfd, 0xf4, 0x7c, 0x28, 0xbf, 0x20, 0x29, 0x89,
+	0x0d, 0x2c, 0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x41, 0xb1, 0x4d, 0x55, 0x2a, 0x02, 0x00,
+	0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/wiki.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/wiki.pb.go
index e764da7ea5d4c7f07e64e1dc50776b74c1e5a7e6..5147e2907623b1a0c2e780790dd76e0fc2d4cfb1 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/wiki.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/wiki.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: wiki.proto
 
-package gitalypb
+package gitalypb // import "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -23,6 +23,29 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
+type WikiGetAllPagesRequest_SortBy int32
+
+const (
+	WikiGetAllPagesRequest_TITLE      WikiGetAllPagesRequest_SortBy = 0
+	WikiGetAllPagesRequest_CREATED_AT WikiGetAllPagesRequest_SortBy = 1
+)
+
+var WikiGetAllPagesRequest_SortBy_name = map[int32]string{
+	0: "TITLE",
+	1: "CREATED_AT",
+}
+var WikiGetAllPagesRequest_SortBy_value = map[string]int32{
+	"TITLE":      0,
+	"CREATED_AT": 1,
+}
+
+func (x WikiGetAllPagesRequest_SortBy) String() string {
+	return proto.EnumName(WikiGetAllPagesRequest_SortBy_name, int32(x))
+}
+func (WikiGetAllPagesRequest_SortBy) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{15, 0}
+}
+
 type WikiCommitDetails struct {
 	Name                 []byte   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
 	Email                []byte   `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"`
@@ -38,7 +61,7 @@ func (m *WikiCommitDetails) Reset()         { *m = WikiCommitDetails{} }
 func (m *WikiCommitDetails) String() string { return proto.CompactTextString(m) }
 func (*WikiCommitDetails) ProtoMessage()    {}
 func (*WikiCommitDetails) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{0}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{0}
 }
 func (m *WikiCommitDetails) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiCommitDetails.Unmarshal(m, b)
@@ -105,7 +128,7 @@ func (m *WikiPageVersion) Reset()         { *m = WikiPageVersion{} }
 func (m *WikiPageVersion) String() string { return proto.CompactTextString(m) }
 func (*WikiPageVersion) ProtoMessage()    {}
 func (*WikiPageVersion) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{1}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{1}
 }
 func (m *WikiPageVersion) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiPageVersion.Unmarshal(m, b)
@@ -159,7 +182,7 @@ func (m *WikiPage) Reset()         { *m = WikiPage{} }
 func (m *WikiPage) String() string { return proto.CompactTextString(m) }
 func (*WikiPage) ProtoMessage()    {}
 func (*WikiPage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{2}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{2}
 }
 func (m *WikiPage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiPage.Unmarshal(m, b)
@@ -249,7 +272,7 @@ func (m *WikiGetPageVersionsRequest) Reset()         { *m = WikiGetPageVersionsR
 func (m *WikiGetPageVersionsRequest) String() string { return proto.CompactTextString(m) }
 func (*WikiGetPageVersionsRequest) ProtoMessage()    {}
 func (*WikiGetPageVersionsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{3}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{3}
 }
 func (m *WikiGetPageVersionsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiGetPageVersionsRequest.Unmarshal(m, b)
@@ -308,7 +331,7 @@ func (m *WikiGetPageVersionsResponse) Reset()         { *m = WikiGetPageVersions
 func (m *WikiGetPageVersionsResponse) String() string { return proto.CompactTextString(m) }
 func (*WikiGetPageVersionsResponse) ProtoMessage()    {}
 func (*WikiGetPageVersionsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{4}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{4}
 }
 func (m *WikiGetPageVersionsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiGetPageVersionsResponse.Unmarshal(m, b)
@@ -353,7 +376,7 @@ func (m *WikiWritePageRequest) Reset()         { *m = WikiWritePageRequest{} }
 func (m *WikiWritePageRequest) String() string { return proto.CompactTextString(m) }
 func (*WikiWritePageRequest) ProtoMessage()    {}
 func (*WikiWritePageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{5}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{5}
 }
 func (m *WikiWritePageRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiWritePageRequest.Unmarshal(m, b)
@@ -419,7 +442,7 @@ func (m *WikiWritePageResponse) Reset()         { *m = WikiWritePageResponse{} }
 func (m *WikiWritePageResponse) String() string { return proto.CompactTextString(m) }
 func (*WikiWritePageResponse) ProtoMessage()    {}
 func (*WikiWritePageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{6}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{6}
 }
 func (m *WikiWritePageResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiWritePageResponse.Unmarshal(m, b)
@@ -464,7 +487,7 @@ func (m *WikiUpdatePageRequest) Reset()         { *m = WikiUpdatePageRequest{} }
 func (m *WikiUpdatePageRequest) String() string { return proto.CompactTextString(m) }
 func (*WikiUpdatePageRequest) ProtoMessage()    {}
 func (*WikiUpdatePageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{7}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{7}
 }
 func (m *WikiUpdatePageRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiUpdatePageRequest.Unmarshal(m, b)
@@ -537,7 +560,7 @@ func (m *WikiUpdatePageResponse) Reset()         { *m = WikiUpdatePageResponse{}
 func (m *WikiUpdatePageResponse) String() string { return proto.CompactTextString(m) }
 func (*WikiUpdatePageResponse) ProtoMessage()    {}
 func (*WikiUpdatePageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{8}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{8}
 }
 func (m *WikiUpdatePageResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiUpdatePageResponse.Unmarshal(m, b)
@@ -577,7 +600,7 @@ func (m *WikiDeletePageRequest) Reset()         { *m = WikiDeletePageRequest{} }
 func (m *WikiDeletePageRequest) String() string { return proto.CompactTextString(m) }
 func (*WikiDeletePageRequest) ProtoMessage()    {}
 func (*WikiDeletePageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{9}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{9}
 }
 func (m *WikiDeletePageRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiDeletePageRequest.Unmarshal(m, b)
@@ -628,7 +651,7 @@ func (m *WikiDeletePageResponse) Reset()         { *m = WikiDeletePageResponse{}
 func (m *WikiDeletePageResponse) String() string { return proto.CompactTextString(m) }
 func (*WikiDeletePageResponse) ProtoMessage()    {}
 func (*WikiDeletePageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{10}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{10}
 }
 func (m *WikiDeletePageResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiDeletePageResponse.Unmarshal(m, b)
@@ -662,7 +685,7 @@ func (m *WikiFindPageRequest) Reset()         { *m = WikiFindPageRequest{} }
 func (m *WikiFindPageRequest) String() string { return proto.CompactTextString(m) }
 func (*WikiFindPageRequest) ProtoMessage()    {}
 func (*WikiFindPageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{11}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{11}
 }
 func (m *WikiFindPageRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiFindPageRequest.Unmarshal(m, b)
@@ -723,7 +746,7 @@ func (m *WikiFindPageResponse) Reset()         { *m = WikiFindPageResponse{} }
 func (m *WikiFindPageResponse) String() string { return proto.CompactTextString(m) }
 func (*WikiFindPageResponse) ProtoMessage()    {}
 func (*WikiFindPageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{12}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{12}
 }
 func (m *WikiFindPageResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiFindPageResponse.Unmarshal(m, b)
@@ -764,7 +787,7 @@ func (m *WikiFindFileRequest) Reset()         { *m = WikiFindFileRequest{} }
 func (m *WikiFindFileRequest) String() string { return proto.CompactTextString(m) }
 func (*WikiFindFileRequest) ProtoMessage()    {}
 func (*WikiFindFileRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{13}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{13}
 }
 func (m *WikiFindFileRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiFindFileRequest.Unmarshal(m, b)
@@ -820,7 +843,7 @@ func (m *WikiFindFileResponse) Reset()         { *m = WikiFindFileResponse{} }
 func (m *WikiFindFileResponse) String() string { return proto.CompactTextString(m) }
 func (*WikiFindFileResponse) ProtoMessage()    {}
 func (*WikiFindFileResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{14}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{14}
 }
 func (m *WikiFindFileResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiFindFileResponse.Unmarshal(m, b)
@@ -871,17 +894,19 @@ func (m *WikiFindFileResponse) GetPath() []byte {
 type WikiGetAllPagesRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
 	// Passing 0 means no limit is applied
-	Limit                uint32   `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Limit                uint32                        `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
+	DirectionDesc        bool                          `protobuf:"varint,3,opt,name=direction_desc,json=directionDesc,proto3" json:"direction_desc,omitempty"`
+	Sort                 WikiGetAllPagesRequest_SortBy `protobuf:"varint,4,opt,name=sort,proto3,enum=gitaly.WikiGetAllPagesRequest_SortBy" json:"sort,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
+	XXX_unrecognized     []byte                        `json:"-"`
+	XXX_sizecache        int32                         `json:"-"`
 }
 
 func (m *WikiGetAllPagesRequest) Reset()         { *m = WikiGetAllPagesRequest{} }
 func (m *WikiGetAllPagesRequest) String() string { return proto.CompactTextString(m) }
 func (*WikiGetAllPagesRequest) ProtoMessage()    {}
 func (*WikiGetAllPagesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{15}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{15}
 }
 func (m *WikiGetAllPagesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiGetAllPagesRequest.Unmarshal(m, b)
@@ -915,6 +940,20 @@ func (m *WikiGetAllPagesRequest) GetLimit() uint32 {
 	return 0
 }
 
+func (m *WikiGetAllPagesRequest) GetDirectionDesc() bool {
+	if m != nil {
+		return m.DirectionDesc
+	}
+	return false
+}
+
+func (m *WikiGetAllPagesRequest) GetSort() WikiGetAllPagesRequest_SortBy {
+	if m != nil {
+		return m.Sort
+	}
+	return WikiGetAllPagesRequest_TITLE
+}
+
 // The WikiGetAllPagesResponse stream is a concatenation of WikiPage streams
 type WikiGetAllPagesResponse struct {
 	Page *WikiPage `protobuf:"bytes,1,opt,name=page,proto3" json:"page,omitempty"`
@@ -929,7 +968,7 @@ func (m *WikiGetAllPagesResponse) Reset()         { *m = WikiGetAllPagesResponse
 func (m *WikiGetAllPagesResponse) String() string { return proto.CompactTextString(m) }
 func (*WikiGetAllPagesResponse) ProtoMessage()    {}
 func (*WikiGetAllPagesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{16}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{16}
 }
 func (m *WikiGetAllPagesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiGetAllPagesResponse.Unmarshal(m, b)
@@ -977,7 +1016,7 @@ func (m *WikiGetFormattedDataRequest) Reset()         { *m = WikiGetFormattedDat
 func (m *WikiGetFormattedDataRequest) String() string { return proto.CompactTextString(m) }
 func (*WikiGetFormattedDataRequest) ProtoMessage()    {}
 func (*WikiGetFormattedDataRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{17}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{17}
 }
 func (m *WikiGetFormattedDataRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiGetFormattedDataRequest.Unmarshal(m, b)
@@ -1036,7 +1075,7 @@ func (m *WikiGetFormattedDataResponse) Reset()         { *m = WikiGetFormattedDa
 func (m *WikiGetFormattedDataResponse) String() string { return proto.CompactTextString(m) }
 func (*WikiGetFormattedDataResponse) ProtoMessage()    {}
 func (*WikiGetFormattedDataResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_wiki_1d32eab65dda3828, []int{18}
+	return fileDescriptor_wiki_48d6ca74f1924b83, []int{18}
 }
 func (m *WikiGetFormattedDataResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WikiGetFormattedDataResponse.Unmarshal(m, b)
@@ -1083,6 +1122,7 @@ func init() {
 	proto.RegisterType((*WikiGetAllPagesResponse)(nil), "gitaly.WikiGetAllPagesResponse")
 	proto.RegisterType((*WikiGetFormattedDataRequest)(nil), "gitaly.WikiGetFormattedDataRequest")
 	proto.RegisterType((*WikiGetFormattedDataResponse)(nil), "gitaly.WikiGetFormattedDataResponse")
+	proto.RegisterEnum("gitaly.WikiGetAllPagesRequest_SortBy", WikiGetAllPagesRequest_SortBy_name, WikiGetAllPagesRequest_SortBy_value)
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1594,67 +1634,75 @@ var _WikiService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "wiki.proto",
 }
 
-func init() { proto.RegisterFile("wiki.proto", fileDescriptor_wiki_1d32eab65dda3828) }
-
-var fileDescriptor_wiki_1d32eab65dda3828 = []byte{
-	// 937 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xcd, 0x6e, 0xe4, 0x44,
-	0x10, 0x5e, 0x67, 0xfe, 0x3c, 0x95, 0x9f, 0x65, 0x9b, 0x65, 0xe3, 0x75, 0x42, 0x88, 0x9a, 0x95,
-	0x08, 0x97, 0x08, 0x66, 0xaf, 0x1c, 0x16, 0x11, 0x12, 0x71, 0x00, 0x82, 0x77, 0xd9, 0x3d, 0x5a,
-	0x9d, 0x71, 0x25, 0x69, 0xad, 0x3d, 0x36, 0xed, 0x9e, 0x44, 0xf3, 0x10, 0x3c, 0x00, 0x12, 0x17,
-	0xae, 0x3c, 0x09, 0x67, 0xde, 0x82, 0x2b, 0x4f, 0x80, 0xfa, 0xc7, 0xe3, 0xb6, 0x67, 0x32, 0x28,
-	0x0c, 0x48, 0xdc, 0xdc, 0x55, 0xdd, 0xd5, 0xf5, 0x7d, 0x5f, 0x57, 0xd5, 0x0c, 0xc0, 0x2d, 0x7f,
-	0xcb, 0x8f, 0x0b, 0x91, 0xcb, 0x9c, 0xf4, 0xaf, 0xb8, 0x64, 0xe9, 0x2c, 0xdc, 0x2a, 0xaf, 0x99,
-	0xc0, 0xc4, 0x58, 0xe9, 0x8f, 0x1e, 0x3c, 0x7a, 0xc3, 0xdf, 0xf2, 0x2f, 0xf2, 0x2c, 0xe3, 0xf2,
-	0x04, 0x25, 0xe3, 0x69, 0x49, 0x08, 0x74, 0x27, 0x2c, 0xc3, 0xc0, 0x3b, 0xf4, 0x8e, 0xb6, 0x22,
-	0xfd, 0x4d, 0x1e, 0x43, 0x0f, 0x33, 0xc6, 0xd3, 0x60, 0x43, 0x1b, 0xcd, 0x82, 0x04, 0x30, 0xc8,
-	0xb0, 0x2c, 0xd9, 0x15, 0x06, 0x1d, 0x6d, 0xaf, 0x96, 0x64, 0x17, 0x06, 0xd3, 0x12, 0x45, 0xcc,
-	0x93, 0xa0, 0x7b, 0xe8, 0x1d, 0xf5, 0xa2, 0xbe, 0x5a, 0x7e, 0x95, 0x90, 0x3d, 0x18, 0x6a, 0x87,
-	0xbe, 0xa1, 0xa7, 0x0f, 0xf9, 0xca, 0xf0, 0x0d, 0xcb, 0x90, 0xbe, 0x82, 0x87, 0x2a, 0x9d, 0x73,
-	0x76, 0x85, 0xaf, 0x51, 0x94, 0x3c, 0x9f, 0x90, 0x8f, 0xa1, 0x3f, 0xd6, 0xd9, 0xe9, 0x74, 0x36,
-	0x47, 0x8f, 0x8e, 0x0d, 0x92, 0xe3, 0x33, 0x2e, 0x4d, 0xda, 0x91, 0xdd, 0x40, 0x9e, 0x40, 0xff,
-	0x32, 0x17, 0x19, 0x93, 0x3a, 0xc9, 0x61, 0x64, 0x57, 0xf4, 0x0f, 0x0f, 0xfc, 0x2a, 0x2c, 0xf9,
-	0x14, 0x06, 0x37, 0x26, 0xb4, 0x0d, 0xb8, 0x5b, 0x05, 0x6c, 0xdd, 0x1c, 0x55, 0xfb, 0xee, 0x8a,
-	0xab, 0x38, 0x91, 0x5c, 0xa6, 0x15, 0x76, 0xb3, 0x20, 0x4f, 0xc1, 0x9f, 0x8a, 0x34, 0x2e, 0x98,
-	0xbc, 0xd6, 0xd0, 0x87, 0xd1, 0x60, 0x2a, 0xd2, 0x73, 0x26, 0xaf, 0x15, 0xb1, 0xda, 0x6c, 0x60,
-	0xeb, 0xef, 0x39, 0xd9, 0x7d, 0x87, 0xec, 0x03, 0x80, 0x6b, 0x5e, 0xca, 0x5c, 0xf0, 0x31, 0x4b,
-	0x83, 0xc1, 0xa1, 0x77, 0xe4, 0x47, 0x8e, 0x45, 0x5d, 0x21, 0xd8, 0x6d, 0x9c, 0x30, 0xc9, 0x02,
-	0xdf, 0xf0, 0x2e, 0xd8, 0xed, 0x09, 0x93, 0x8c, 0xfe, 0xec, 0x41, 0xa8, 0x80, 0x9c, 0xa1, 0x74,
-	0xb0, 0x94, 0x11, 0xfe, 0x30, 0xc5, 0x52, 0x92, 0x11, 0x80, 0xc0, 0x22, 0x2f, 0xb9, 0xcc, 0xc5,
-	0xcc, 0x12, 0x40, 0x2a, 0x02, 0xa2, 0xb9, 0x27, 0x72, 0x76, 0x29, 0xc5, 0x0a, 0x76, 0x85, 0x06,
-	0x91, 0x91, 0xdf, 0x57, 0x86, 0x1a, 0x92, 0x95, 0xbf, 0x17, 0xe9, 0x6f, 0x95, 0x5e, 0x81, 0x22,
-	0xd6, 0x76, 0x23, 0xfe, 0xa0, 0x40, 0xa1, 0xd2, 0xa1, 0x11, 0xec, 0x2d, 0xcd, 0xae, 0x2c, 0xf2,
-	0x49, 0x89, 0xe4, 0x39, 0xf8, 0x96, 0xf4, 0x32, 0xf0, 0x0e, 0x3b, 0xab, 0xd4, 0x99, 0x6f, 0xa4,
-	0xbf, 0x7b, 0xf0, 0x58, 0x79, 0xdf, 0x08, 0x2e, 0x51, 0x6d, 0x59, 0x07, 0x6c, 0x25, 0xc7, 0x86,
-	0x23, 0x47, 0xad, 0x7f, 0xa7, 0xa1, 0xff, 0x0b, 0xd8, 0x31, 0x2f, 0x2f, 0x4e, 0x4c, 0xe5, 0x68,
-	0xb4, 0x9b, 0xa3, 0xa7, 0x6e, 0xce, 0x8d, 0xd2, 0x8a, 0xb6, 0xc7, 0x8d, 0x4a, 0x0b, 0x60, 0x30,
-	0xce, 0x27, 0x12, 0x27, 0xd2, 0xbe, 0x89, 0x6a, 0x49, 0x5f, 0xc0, 0x7b, 0x2d, 0x4c, 0x96, 0xa2,
-	0x8f, 0xe0, 0x61, 0x32, 0x2d, 0x52, 0x3e, 0x66, 0x12, 0x63, 0x14, 0x22, 0x17, 0xb6, 0x4e, 0x77,
-	0xe6, 0xe6, 0x2f, 0x95, 0x95, 0xfe, 0xe9, 0x99, 0x10, 0xdf, 0x17, 0x09, 0x5b, 0x9f, 0x97, 0x95,
-	0x8f, 0x60, 0x79, 0x21, 0xd4, 0xb4, 0x75, 0xff, 0x86, 0xb6, 0xde, 0x3f, 0xa7, 0xad, 0xdf, 0xa4,
-	0xed, 0x18, 0x9e, 0xb4, 0x31, 0x5b, 0xde, 0x54, 0x03, 0x73, 0xd8, 0x32, 0x0b, 0xfa, 0xab, 0x25,
-	0xe9, 0x04, 0x53, 0xfc, 0x8f, 0x49, 0x5a, 0x84, 0xdd, 0xb9, 0x1f, 0x6c, 0x1a, 0x18, 0x70, 0x6e,
-	0xae, 0x06, 0x1c, 0xfd, 0xc9, 0x83, 0x77, 0x95, 0xeb, 0x94, 0x4f, 0x92, 0x75, 0x41, 0xcc, 0xc5,
-	0xdc, 0x70, 0xc5, 0x0c, 0xc1, 0x17, 0x78, 0xc3, 0x75, 0xdf, 0x34, 0x2a, 0xcf, 0xd7, 0x64, 0x1f,
-	0x86, 0x09, 0x17, 0x38, 0xd6, 0x97, 0x74, 0xb5, 0xb3, 0x36, 0xd0, 0xcf, 0x4c, 0x75, 0xd6, 0xa9,
-	0x59, 0x41, 0x9e, 0xd9, 0xce, 0x61, 0xb2, 0x7a, 0xa7, 0x5d, 0xe7, 0xa6, 0x97, 0xd0, 0x59, 0x0d,
-	0xec, 0x94, 0xa7, 0xff, 0x7a, 0x69, 0xaf, 0x80, 0x45, 0x6f, 0xea, 0xc4, 0xcd, 0xd5, 0x36, 0xf1,
-	0x65, 0xe3, 0x71, 0x0f, 0x86, 0x19, 0xcf, 0x30, 0x96, 0xb3, 0x02, 0xed, 0x94, 0xf0, 0x95, 0xe1,
-	0xd5, 0xac, 0xc0, 0x46, 0xbb, 0xee, 0x34, 0xda, 0xf5, 0x7c, 0x22, 0x74, 0xeb, 0x89, 0x40, 0x2f,
-	0x8c, 0xcc, 0x67, 0x28, 0x3f, 0x4f, 0x53, 0x45, 0x45, 0xb9, 0xa6, 0x9c, 0x29, 0x57, 0xe3, 0x53,
-	0x65, 0xb5, 0x1d, 0x99, 0x05, 0x8d, 0x61, 0x77, 0xe1, 0x8e, 0xfb, 0xe8, 0x42, 0x0e, 0x60, 0x13,
-	0x27, 0x49, 0x9c, 0x5f, 0x9a, 0x36, 0xbf, 0xa1, 0x67, 0xd4, 0x10, 0x27, 0xc9, 0xb7, 0x97, 0xba,
-	0xd1, 0xff, 0xe2, 0xcd, 0x3b, 0xfd, 0xa9, 0x2e, 0x7b, 0x89, 0x89, 0x42, 0xfc, 0x7f, 0x7a, 0x99,
-	0x23, 0xd8, 0x5f, 0x9e, 0x62, 0x2d, 0xb4, 0xd6, 0xcc, 0x0a, 0xad, 0xbe, 0x47, 0xbf, 0xf5, 0x60,
-	0x53, 0x1d, 0x7a, 0x89, 0xe2, 0x86, 0x8f, 0x91, 0x5c, 0x98, 0xf7, 0xd9, 0x1a, 0x68, 0x84, 0xba,
-	0xb4, 0x2d, 0x9f, 0xc5, 0xe1, 0x87, 0x2b, 0xf7, 0xd8, 0xca, 0x7e, 0xf0, 0x89, 0x47, 0xce, 0x61,
-	0xbb, 0x31, 0x0b, 0xc8, 0xbe, 0x7b, 0xb2, 0x3d, 0xf6, 0xc2, 0xf7, 0xef, 0xf0, 0x56, 0x11, 0x8f,
-	0x3c, 0xf2, 0x12, 0x76, 0x9a, 0x6d, 0x92, 0x34, 0x0e, 0x2d, 0x8c, 0x8c, 0xf0, 0xe0, 0x2e, 0xb7,
-	0x13, 0xf4, 0x3b, 0x13, 0xb4, 0x6e, 0x4f, 0xcd, 0xa0, 0x0b, 0x2d, 0xb6, 0x19, 0x74, 0x49, 0x57,
-	0x7b, 0x40, 0xbe, 0x86, 0x2d, 0xb7, 0x77, 0x90, 0x3d, 0xf7, 0x44, 0xab, 0xd9, 0x85, 0xfb, 0xcb,
-	0x9d, 0x0e, 0x91, 0x4e, 0x38, 0x55, 0xd1, 0x8b, 0xe1, 0x9c, 0x16, 0xb3, 0x18, 0xce, 0x6d, 0x02,
-	0x3a, 0xdc, 0x6b, 0xf3, 0x6b, 0xd5, 0x29, 0x22, 0x72, 0xd0, 0xd2, 0xb4, 0x55, 0xc1, 0xe1, 0x07,
-	0x77, 0xfa, 0x9d, 0xb8, 0x68, 0x1a, 0x4f, 0xfb, 0x5d, 0x92, 0xf6, 0x83, 0x59, 0x56, 0x58, 0xe1,
-	0xb3, 0xd5, 0x9b, 0xea, 0x6b, 0x2e, 0xfa, 0xfa, 0x3f, 0xc0, 0xf3, 0xbf, 0x02, 0x00, 0x00, 0xff,
-	0xff, 0x1d, 0x26, 0x5c, 0x57, 0x27, 0x0c, 0x00, 0x00,
+func init() { proto.RegisterFile("wiki.proto", fileDescriptor_wiki_48d6ca74f1924b83) }
+
+var fileDescriptor_wiki_48d6ca74f1924b83 = []byte{
+	// 1064 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0x4b, 0x6f, 0xdb, 0x46,
+	0x10, 0x36, 0x65, 0x3d, 0xa8, 0xb1, 0xad, 0x38, 0xdb, 0x34, 0x66, 0x64, 0xd7, 0x35, 0x98, 0x04,
+	0x75, 0x0f, 0x91, 0x53, 0xe5, 0xd4, 0xa2, 0x87, 0x38, 0xf1, 0x03, 0x01, 0xfa, 0x70, 0x69, 0x35,
+	0x01, 0x7a, 0x21, 0xd6, 0xe4, 0x5a, 0x5e, 0x84, 0x14, 0xd9, 0xe5, 0xca, 0x86, 0x8e, 0xfd, 0x01,
+	0x3d, 0xf7, 0x5c, 0xa0, 0x97, 0x5e, 0xfb, 0x2b, 0xfa, 0x1b, 0xfa, 0x0f, 0x7a, 0x6c, 0x8f, 0x3d,
+	0x15, 0xfb, 0x10, 0xb9, 0xa4, 0x64, 0x15, 0xa9, 0x5b, 0x20, 0x37, 0xce, 0xec, 0xec, 0xec, 0x7c,
+	0xdf, 0xbc, 0x24, 0x80, 0x2b, 0xfa, 0x9a, 0xf6, 0x52, 0x96, 0xf0, 0x04, 0x35, 0x87, 0x94, 0xe3,
+	0x68, 0xd2, 0x5d, 0xcd, 0x2e, 0x30, 0x23, 0xa1, 0xd2, 0xba, 0xdf, 0x5b, 0x70, 0xfb, 0x15, 0x7d,
+	0x4d, 0x9f, 0x27, 0x71, 0x4c, 0xf9, 0x01, 0xe1, 0x98, 0x46, 0x19, 0x42, 0x50, 0x1f, 0xe1, 0x98,
+	0x38, 0xd6, 0x8e, 0xb5, 0xbb, 0xea, 0xc9, 0x6f, 0x74, 0x07, 0x1a, 0x24, 0xc6, 0x34, 0x72, 0x6a,
+	0x52, 0xa9, 0x04, 0xe4, 0x40, 0x2b, 0x26, 0x59, 0x86, 0x87, 0xc4, 0x59, 0x96, 0xfa, 0xa9, 0x88,
+	0x36, 0xa0, 0x35, 0xce, 0x08, 0xf3, 0x69, 0xe8, 0xd4, 0x77, 0xac, 0xdd, 0x86, 0xd7, 0x14, 0xe2,
+	0x8b, 0x10, 0x6d, 0x42, 0x5b, 0x1e, 0xc8, 0x17, 0x1a, 0xf2, 0x92, 0x2d, 0x14, 0x5f, 0xe0, 0x98,
+	0xb8, 0x03, 0xb8, 0x25, 0xc2, 0x39, 0xc1, 0x43, 0xf2, 0x92, 0xb0, 0x8c, 0x26, 0x23, 0xf4, 0x21,
+	0x34, 0x03, 0x19, 0x9d, 0x0c, 0x67, 0xa5, 0x7f, 0xbb, 0xa7, 0x90, 0xf4, 0x8e, 0x29, 0x57, 0x61,
+	0x7b, 0xda, 0x00, 0xdd, 0x85, 0xe6, 0x79, 0xc2, 0x62, 0xcc, 0x65, 0x90, 0x6d, 0x4f, 0x4b, 0xee,
+	0xef, 0x16, 0xd8, 0x53, 0xb7, 0xe8, 0x23, 0x68, 0x5d, 0x2a, 0xd7, 0xda, 0xe1, 0xc6, 0xd4, 0x61,
+	0xe5, 0x65, 0x6f, 0x6a, 0x77, 0x9d, 0x5f, 0xc1, 0x09, 0xa7, 0x3c, 0x9a, 0x62, 0x57, 0x02, 0xba,
+	0x07, 0xf6, 0x98, 0x45, 0x7e, 0x8a, 0xf9, 0x85, 0x84, 0xde, 0xf6, 0x5a, 0x63, 0x16, 0x9d, 0x60,
+	0x7e, 0x21, 0x88, 0x95, 0x6a, 0x05, 0x5b, 0x7e, 0xe7, 0x64, 0x37, 0x0d, 0xb2, 0xb7, 0x01, 0x2e,
+	0x68, 0xc6, 0x13, 0x46, 0x03, 0x1c, 0x39, 0xad, 0x1d, 0x6b, 0xd7, 0xf6, 0x0c, 0x8d, 0x78, 0x82,
+	0xe1, 0x2b, 0x3f, 0xc4, 0x1c, 0x3b, 0xb6, 0xe2, 0x9d, 0xe1, 0xab, 0x03, 0xcc, 0xb1, 0xfb, 0x93,
+	0x05, 0x5d, 0x01, 0xe4, 0x98, 0x70, 0x03, 0x4b, 0xe6, 0x91, 0x6f, 0xc7, 0x24, 0xe3, 0xa8, 0x0f,
+	0xc0, 0x48, 0x9a, 0x64, 0x94, 0x27, 0x6c, 0xa2, 0x09, 0x40, 0x53, 0x02, 0xbc, 0xfc, 0xc4, 0x33,
+	0xac, 0x44, 0xc6, 0x52, 0x3c, 0x24, 0x0a, 0x91, 0x4a, 0xbf, 0x2d, 0x14, 0x05, 0x24, 0x9d, 0xfe,
+	0x86, 0x27, 0xbf, 0x45, 0x78, 0x29, 0x61, 0xbe, 0xd4, 0xab, 0xe4, 0xb7, 0x52, 0xc2, 0x44, 0x38,
+	0x9f, 0x34, 0xff, 0xfc, 0x61, 0xb7, 0x66, 0xd7, 0x5c, 0x0f, 0x36, 0xe7, 0x46, 0x99, 0xa5, 0xc9,
+	0x28, 0x23, 0xe8, 0x09, 0xd8, 0x9a, 0xfc, 0xcc, 0xb1, 0x76, 0x96, 0x17, 0x65, 0x29, 0x37, 0x74,
+	0x7f, 0xb3, 0xe0, 0x8e, 0x38, 0x7d, 0xc5, 0x28, 0x27, 0xc2, 0xe4, 0x26, 0xa0, 0xa7, 0x69, 0xa9,
+	0x19, 0x69, 0x29, 0xea, 0x60, 0xb9, 0x54, 0x07, 0x4f, 0xa1, 0xa3, 0x2a, 0xd0, 0x0f, 0x55, 0x07,
+	0x49, 0xd4, 0x2b, 0xfd, 0x7b, 0x66, 0xcc, 0xa5, 0x16, 0xf3, 0xd6, 0x82, 0x52, 0xc7, 0x39, 0xd0,
+	0x0a, 0x92, 0x11, 0x27, 0x23, 0xae, 0x6b, 0x63, 0x2a, 0x6a, 0xc2, 0x2c, 0xf7, 0x29, 0xbc, 0x5b,
+	0xc1, 0xa6, 0xa9, 0xfa, 0x00, 0x6e, 0x85, 0xe3, 0x34, 0xa2, 0x01, 0xe6, 0xc4, 0x27, 0x8c, 0x25,
+	0x4c, 0xf7, 0x6d, 0x27, 0x57, 0x1f, 0x0a, 0xad, 0xfb, 0x97, 0xa5, 0x5c, 0x7c, 0x9d, 0x86, 0xf8,
+	0xe6, 0xfc, 0x2c, 0x2c, 0x8a, 0xf9, 0x8d, 0x51, 0xd0, 0x57, 0xff, 0x07, 0xfa, 0x1a, 0xff, 0x9e,
+	0xbe, 0xe6, 0x7c, 0xfa, 0x7a, 0x70, 0xb7, 0x8a, 0x5d, 0xf3, 0x27, 0x06, 0x9b, 0xc1, 0x9a, 0x12,
+	0xdc, 0x5f, 0x34, 0x59, 0x07, 0x24, 0x22, 0xff, 0x33, 0x59, 0xb3, 0xf0, 0x97, 0xdf, 0x0c, 0x7e,
+	0x0e, 0xd2, 0x51, 0x20, 0xcd, 0x98, 0x15, 0x48, 0xf7, 0x47, 0x0b, 0xde, 0x11, 0x47, 0x47, 0x74,
+	0x14, 0xde, 0x14, 0x4c, 0x9e, 0xdc, 0x9a, 0x99, 0xdc, 0x2e, 0xd8, 0x8c, 0x5c, 0x52, 0x39, 0x57,
+	0x55, 0xd6, 0x73, 0x19, 0x6d, 0x41, 0x3b, 0xa4, 0x8c, 0x04, 0xf2, 0x91, 0xba, 0x3c, 0x2c, 0x14,
+	0xf9, 0x48, 0xf8, 0x54, 0x75, 0x6f, 0x11, 0xa2, 0x4e, 0xd0, 0x03, 0x3d, 0x61, 0x54, 0x74, 0xeb,
+	0xd5, 0x39, 0xa0, 0x66, 0x8e, 0xfb, 0x9d, 0x81, 0xf0, 0x88, 0x46, 0xff, 0x79, 0xef, 0x2f, 0xc0,
+	0x97, 0x23, 0xb8, 0x2c, 0x10, 0xa8, 0x10, 0x34, 0x82, 0x79, 0xfb, 0x74, 0x13, 0xda, 0x31, 0x8d,
+	0x89, 0xcf, 0x27, 0x29, 0xd1, 0x6b, 0xc5, 0x16, 0x8a, 0xc1, 0x24, 0x25, 0xa5, 0xf9, 0xbe, 0x5c,
+	0x9a, 0xef, 0xf9, 0x0a, 0xa9, 0x17, 0x2b, 0xc4, 0xfd, 0xc3, 0x52, 0x89, 0x3f, 0x26, 0x7c, 0x3f,
+	0x8a, 0x04, 0x29, 0xd9, 0x0d, 0x13, 0x1c, 0x51, 0xb1, 0x70, 0x45, 0x58, 0x6b, 0x9e, 0x12, 0xd0,
+	0x43, 0xe8, 0xa8, 0x9c, 0xd1, 0x64, 0xe4, 0x87, 0x24, 0x0b, 0x64, 0x64, 0xb6, 0xb7, 0x96, 0x6b,
+	0x0f, 0x48, 0x16, 0xa0, 0x8f, 0xa1, 0x9e, 0x25, 0x4c, 0xb5, 0x78, 0xa7, 0xff, 0xd0, 0xcc, 0xd6,
+	0x6c, 0x78, 0xbd, 0xd3, 0x84, 0xf1, 0x67, 0x13, 0x4f, 0x5e, 0x71, 0xef, 0x43, 0x53, 0xc9, 0xa8,
+	0x0d, 0x8d, 0xc1, 0x8b, 0xc1, 0x67, 0x87, 0xeb, 0x4b, 0xa8, 0x03, 0xf0, 0xdc, 0x3b, 0xdc, 0x1f,
+	0x1c, 0x1e, 0xf8, 0xfb, 0x83, 0x75, 0x2b, 0xe7, 0xda, 0x87, 0x8d, 0x19, 0x9f, 0x6f, 0x52, 0x30,
+	0x68, 0x1b, 0x56, 0xc8, 0x28, 0xf4, 0x93, 0x73, 0xb5, 0xa7, 0x6a, 0x12, 0x4c, 0x9b, 0x8c, 0xc2,
+	0x2f, 0xcf, 0x85, 0x95, 0xfb, 0xb3, 0x95, 0xaf, 0xa8, 0x23, 0x39, 0xa7, 0x38, 0x09, 0x45, 0x06,
+	0xde, 0xc6, 0xd6, 0xe9, 0xc3, 0xd6, 0xfc, 0x50, 0x8b, 0x02, 0x94, 0xb5, 0xa4, 0x0b, 0x50, 0x7c,
+	0xf7, 0x7f, 0x6d, 0xc0, 0x8a, 0xb8, 0x74, 0x4a, 0xd8, 0x25, 0x0d, 0x08, 0x3a, 0x53, 0xfd, 0x53,
+	0xd9, 0xc8, 0xc8, 0xad, 0x64, 0x70, 0xce, 0x8f, 0x8a, 0xee, 0xfd, 0x85, 0x36, 0x7a, 0x04, 0x2d,
+	0x3d, 0xb6, 0xd0, 0x09, 0xac, 0x95, 0x96, 0x18, 0xda, 0x32, 0x6f, 0x56, 0xf7, 0x76, 0xf7, 0xbd,
+	0x6b, 0x4e, 0xa7, 0x1e, 0x77, 0x2d, 0x74, 0x0a, 0x9d, 0xf2, 0x5c, 0x47, 0xa5, 0x4b, 0x33, 0xbb,
+	0xae, 0xbb, 0x7d, 0xdd, 0xb1, 0xe1, 0xf4, 0x2b, 0xe5, 0xb4, 0x98, 0xa3, 0x65, 0xa7, 0x33, 0x3b,
+	0xa1, 0xec, 0x74, 0xce, 0xf8, 0x5d, 0x42, 0x9f, 0xc3, 0xaa, 0x39, 0xdc, 0xd0, 0xa6, 0x79, 0xa3,
+	0x32, 0x95, 0xbb, 0x5b, 0xf3, 0x0f, 0x0d, 0x22, 0x0d, 0x77, 0x62, 0xd2, 0xcc, 0xba, 0x33, 0x46,
+	0xe0, 0xac, 0x3b, 0x73, 0x38, 0x49, 0x77, 0x2f, 0xd5, 0xcf, 0x6e, 0xa3, 0x99, 0xd0, 0xf6, 0xe2,
+	0xce, 0xed, 0xbe, 0x7f, 0xed, 0xb9, 0xe1, 0x97, 0xa8, 0x81, 0x58, 0xad, 0x4b, 0x54, 0x2d, 0x98,
+	0x79, 0x0d, 0xd6, 0x7d, 0xb0, 0xd8, 0xa8, 0x78, 0xe6, 0xd9, 0xe3, 0x6f, 0x84, 0x69, 0x84, 0xcf,
+	0x7a, 0x41, 0x12, 0xef, 0xa9, 0xcf, 0x47, 0x09, 0x1b, 0xee, 0x29, 0x07, 0x8f, 0xe4, 0x7f, 0x9d,
+	0xbd, 0x61, 0xa2, 0xe5, 0xf4, 0xec, 0xac, 0x29, 0x55, 0x4f, 0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff,
+	0xce, 0x01, 0x69, 0x5b, 0x22, 0x0d, 0x00, 0x00,
 }
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 64ca3b25ba754cee2a7b5d1c4b7de1f289c76740..0cda668d31dd2d9ed47047cf4f1031b94ac782eb 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -485,12 +485,12 @@
 			"revisionTime": "2018-11-02T16:30:54Z"
 		},
 		{
-			"checksumSHA1": "1jQpFgPUfpQIXB+xAFkG93CibrE=",
+			"checksumSHA1": "b8CgsZYi8mvMRLRaWFtXTyOu2To=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb",
-			"revision": "3af1b8b22e630206bb1451307a92696b45a864ff",
-			"revisionTime": "2019-03-01T18:34:55Z",
-			"version": "v1.14.0",
-			"versionExact": "v1.14.0"
+			"revision": "021b342a9ea503d2908773e090ecc896858d3d53",
+			"revisionTime": "2019-03-12T18:07:06Z",
+			"version": "jc-geo-fast-initial-fetch",
+			"versionExact": "jc-geo-fast-initial-fetch"
 		},
 		{
 			"checksumSHA1": "WMOuBgCyclqy+Mqunb0NbykaC4Y=",